win32api4ruby 0.2.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4e12c55a94e41ae82a4caa02b093cca95ee6f62a6fc4781a3acc33fe65b59aa5
+  data.tar.gz: 86a202af58ee9aae510cd9de1735485bc0d5b6023641fe14125044dbb40771c9
+SHA512:
+  metadata.gz: 86de84285923096f3baabaf97ff6e515f2aa0b5fa14face385388274853ddeebcb1d6cca8ae82fa9862a40b2eb1840eb4bdcc912eb1aa21f50d52d7d00401296
+  data.tar.gz: f5d6fef669824a102b9fa7e47f25f7c3907282f0635ba0db20152467569594841e5b27f0c5a4237487543691318694d315eb8016a0ae33b36f8932bf2347aea7

checksums.yaml.gz.sig

@@ -0,0 +1 @@
+.�u�0(I�ͮ� L���qN�ͼE�_�E�6UTU��a��̀�*�F@�|�`*_�a���������3���{P�8���\�k��q[�ߢ|�,x�q��_B��U:Ip9p�'��

data/.autotest

@@ -0,0 +1,23 @@
+# -*- ruby -*-
+
+require 'autotest/restart'
+
+# Autotest.add_hook :initialize do |at|
+#   at.extra_files << "../some/external/dependency.rb"
+#
+#   at.libs << ":../some/external"
+#
+#   at.add_exception 'vendor'
+#
+#   at.add_mapping(/dependency.rb/) do |f, _|
+#     at.files_matching(/test_.*rb$/)
+#   end
+#
+#   %w(TestA TestB).each do |klass|
+#     at.extra_class_map[klass] = "test/test_misc.rb"
+#   end
+# end
+
+# Autotest.add_hook :run_command do |at|
+#   system "rake build"
+# end

data/History.txt

@@ -0,0 +1,11 @@
+=== 0.2.2 / 2026-10-27
+
+* Make the gem open source.
+
+
+=== 1.0.0 / 2009-12-18
+
+* 1 major enhancement
+
+  * Birthday!
+

data/Manifest.txt

@@ -0,0 +1,19 @@
+.autotest
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+lib/win32api4ruby.rb
+lib/win32api4ruby/base.rb
+lib/win32api4ruby/comdlg.rb
+lib/win32api4ruby/gdi.rb
+lib/win32api4ruby/kernel.rb
+lib/win32api4ruby/user.rb
+lib/win32api4ruby/winspool.rb
+test/all_tests.rb
+test/base.rb
+test/test_comdlg.rb
+test/test_gdi.rb
+test/test_kernel.rb
+test/test_user.rb
+test/test_winspool.rb

data/README.txt

@@ -0,0 +1,59 @@
+= win32api4ruby
+
+* https://github.com/larskanis/win32api4ruby
+
+== DESCRIPTION:
+
+Yet another win32 to ruby wrapper
+
+== FEATURES:
+
+* printing functions
+* error handling
+* both Unicode and ANSI-functions supported
+* helpers for UTF-8
+
+== PROBLEMS:
+
+* not compatible to win32-gems for Ruby
+* only a small subset of DLL-functions implemented
+
+== INSTALL:
+
+* gem install win32api4ruby
+
+== SYNOPSIS:
+
+short exsample:
+
+  require "win32api4ruby"
+  Win32api4ruby::Base.unicode = true
+  hwnd = Win32api4ruby::User.create_window_ex(0, 'Button'.to_s_win32, name, User::WS_VISIBLE, 0,0,100,100, 0, 0, 0, 0)
+
+
+== REQUIREMENTS:
+
+* based on FFI
+
+== LICENSE:
+
+(The MIT License)
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,13 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+
+Hoe.spec 'win32api4ruby' do
+  developer('Lars Kanis', 'lars@greiz-reinsdorf.de')
+  self.homepage = "https://github.com/larskanis/win32api4ruby"
+
+  extra_deps << ['ffi', '>=1.0.0']
+end
+
+# vim: syntax=ruby

data/lib/win32api4ruby/base.rb

@@ -0,0 +1,167 @@
+# -*- coding: UTF-8 -*-
+
+require 'ffi'
+
+module Win32api4ruby
+module AbstractMemoryExtensions
+  ZeroZeroString = "\0\0"
+
+  def to_s_utf16
+    i = 0
+    while self.get_bytes(i,2)!=ZeroZeroString
+      i+=2
+    end
+    self.get_bytes(0,i)
+  end
+
+  # Converts the Data containing a Unicode or Ansi-Text based on the current
+  # Win32api4ruby::Base.unicode setting to UTF-8.
+  def to_s_utf8
+    return nil if null?
+    if Win32api4ruby::Base.unicode
+      to_s_utf16.encode(Encoding::UTF_8, Encoding::UTF_16LE)
+    else
+      get_string(0).encode(Encoding::UTF_8, Encoding::Windows_1252)
+    end
+  end
+end
+
+module StringExtensions
+  # Converts a UTF-8 string to Windows-encoding based on the current
+  # Win32api4ruby::Base.unicode setting.
+  def to_s_win32
+    if Win32api4ruby::Base.unicode
+      FFI::MemoryPointer.from_string (self+"\0").encode(Encoding::UTF_16LE, Encoding::UTF_8)
+    else
+      FFI::MemoryPointer.from_string self.encode(Encoding::Windows_1252, Encoding::UTF_8)
+    end
+  end
+end
+
+class ::FFI::AbstractMemory
+  include Win32api4ruby::AbstractMemoryExtensions
+end
+
+class ::String
+  include Win32api4ruby::StringExtensions
+end
+
+class Base
+
+  class ApiError < RuntimeError
+    def initialize(code, text)
+      super(text)
+      @code = code
+    end
+  end
+
+  # use UNICODE-methods by default
+  @@unicode = true
+
+  def self.unicode=(enabled)
+    @@unicode = !!enabled
+  end
+
+  def self.unicode
+    @@unicode
+  end
+
+  def self.exception_for_0
+    delete_errors
+    res = yield
+    raise_last_error if res.to_i == 0
+    return res
+  end
+
+  def self.exception_for_non_0
+    delete_errors
+    res = yield
+    raise_last_error if res.to_i != 0
+    return res
+  end
+
+  def self.exception_for_com_error
+    delete_errors
+    res = yield
+    if res != 0
+      text = case
+        when (res.to_i&0xffff0000) == 0x80070000 then `net helpmsg #{res.to_i&0xffff}`.strip
+        else get_last_error_text
+      end
+      raise ApiError, sprintf('%#x %s', res, text)
+    end
+    return res
+  end
+
+  def self.exception_for_nil
+    delete_errors
+    res = yield
+    raise_last_error if res.nil?
+    return res
+  end
+
+  def self.exception_for_negative
+    delete_errors
+    res = yield
+    raise_last_error if res < 0
+    return res
+  end
+
+  # --------------------------------------------------------------------------------------------------------------
+  def self.get_last_error_text(error_code=nil)
+    message = FFI::MemoryPointer.new(1024) #store 1kb space
+    error_code ||= Kernel.get_last_error()
+    Kernel.format_message(0x1000, '', error_code, 0, message, message.size, '')
+    message_str = message.to_s_utf8
+    sprintf('%s (%d)', message_str.chomp, error_code)
+  end
+  def self.raise_last_error
+    code = Kernel.get_last_error()
+    raise ApiError.new(code, get_last_error_text(code))
+  end
+  # --------------------------------------------------------------------------------------------------------------
+  def self.show_error
+    puts get_last_error_text
+  end
+  # --------------------------------------------------------------------------------------------------------------
+  def self.api_call(apiFunction, *args)
+    begin
+      res = apiFunction.call(*args)
+      erg = res.kind_of?(Array) ? res[0] : res
+      return erg
+    rescue RuntimeError => e
+      raise "#{e.class} #{e}: #{show_error}"
+    end
+  end
+#    private :api_call
+  # --------------------------------------------------------------------------------------------------------------
+  def self.check(variable, klass)
+    raise "#{variable}, #{variable.class} != #{klass.to_s}" unless variable.kind_of?(klass)
+  end
+  # --------------------------------------------------------------------------------------------------------------
+  def self.delete_errors
+    Kernel.set_last_error(0)
+  end
+
+  def self.create_struct(struct, data_or_size=nil)
+    case data_or_size
+      when String
+        struct.new(FFI::MemoryPointer.from_string(data_or_size))
+      when FFI::AbstractMemory
+        struct.new(data_or_size)
+      when Integer
+        struct.new(FFI::MemoryPointer.new(data_or_size))
+      when NilClass
+        struct.new
+      when struct
+        struct
+      else
+        raise "#{data_or_size.class} instead of String, FFI::AbstractMemory or Integer"
+    end
+  end
+
+  FFI.typedef :pointer, :handle
+  FFI.typedef :intptr_t, :lresult
+
+end
+end

data/lib/win32api4ruby/comdlg.rb

@@ -0,0 +1,179 @@
+# -*- coding: UTF-8 -*-
+
+require 'win32api4ruby/base'
+
+module Win32api4ruby
+class Comdlg < Base
+  extend FFI::Library
+  ffi_lib 'comdlg32'
+  ffi_convention :stdcall
+
+  ##
+  ##  Flags for PrintDlg and PrintDlgEx.
+  ##
+  PD_ALLPAGES = 0x00000000
+  PD_SELECTION = 0x00000001
+  PD_PAGENUMS = 0x00000002
+  PD_NOSELECTION = 0x00000004
+  PD_NOPAGENUMS = 0x00000008
+  PD_COLLATE = 0x00000010
+  PD_PRINTTOFILE = 0x00000020
+  PD_PRINTSETUP = 0x00000040
+  PD_NOWARNING = 0x00000080
+  PD_RETURNDC = 0x00000100
+  PD_RETURNIC = 0x00000200
+  PD_RETURNDEFAULT = 0x00000400
+  PD_SHOWHELP = 0x00000800
+  PD_ENABLEPRINTHOOK = 0x00001000
+  PD_ENABLESETUPHOOK = 0x00002000
+  PD_ENABLEPRINTTEMPLATE = 0x00004000
+  PD_ENABLESETUPTEMPLATE = 0x00008000
+  PD_ENABLEPRINTTEMPLATEHANDLE = 0x00010000
+  PD_ENABLESETUPTEMPLATEHANDLE = 0x00020000
+  PD_USEDEVMODECOPIES = 0x00040000
+  PD_USEDEVMODECOPIESANDCOLLATE = 0x00040000
+  PD_DISABLEPRINTTOFILE = 0x00080000
+  PD_HIDEPRINTTOFILE = 0x00100000
+  PD_NONETWORKBUTTON = 0x00200000
+
+  #~ PRINTDLG_types = "L"*2 + "L"*2 + "L"*2 + "H"*5 + "L"*8
+  class PRINTDLG < FFI::Struct
+    packed if RUBY_PLATFORM =~ /i?86/
+    layout :lStructSize, :uint32,
+        :hwndOwner, :handle,
+        :hDevMode, :handle,
+        :hDevNames, :handle,
+        :hDC, :handle,
+        :Flags, :uint32,
+        :nFromPage, :uint16,
+        :nToPage, :uint16,
+        :nMinPage, :uint16,
+        :nMaxPage, :uint16,
+        :nCopies, :uint16,
+        :hInstance, :handle,
+        :lCustData, :pointer,
+        :lpfnPrintHook, :pointer,
+        :lpfnSetupHook, :pointer,
+        :lpPrintTemplateName, :pointer,
+        :lpSetupTemplateName, :pointer,
+        :hPrintTemplate, :handle,
+        :hSetupTemplate, :handle
+  end
+
+  def self.create_PRINTDLG(data_or_size=nil)
+    data = create_struct(PRINTDLG, data_or_size)
+    data[:lStructSize] = data.pointer.size
+    return data
+  end
+
+  #the functions that wrap the Win32API calls enforce type checking on arguments
+  # (through #check). This is to be consistent with the Win32API which will assume
+  # different arguments are calling different functions, throwing wacky errors
+  #API WRAPPERS
+  # --------------------------------------------------------------------------------------------------------------
+  attach_function :PrintDlgW, [ PRINTDLG.by_ref ], :int
+  attach_function :PrintDlgA, [ PRINTDLG.by_ref ], :int
+  def self.print_dlg(pPrintDlg)
+    exception_for_0{
+      unicode ? PrintDlgW(pPrintDlg) : PrintDlgA(pPrintDlg)
+    }
+  end
+
+  attach_function :PrintDlgExW, [ :pointer ], :handle
+  attach_function :PrintDlgExA, [ :pointer ], :handle
+  def self.print_dlg_ex(pPrintDlgEx)
+    exception_for_com_error{
+      unicode ? PrintDlgExW(pPrintDlgEx) : PrintDlgExA(pPrintDlgEx)
+    }
+  end
+
+  attach_function :PageSetupDlgW, [ :pointer ], :int
+  attach_function :PageSetupDlgA, [ :pointer ], :int
+  def self.print_setup_dlg(pPageSetupDlg)
+    exception_for_0{
+      unicode ? PageSetupDlgW(pPageSetupDlg) : PageSetupDlgA(pPageSetupDlg)
+    }
+  end
+
+  class PAGESETUPDLG < FFI::Struct
+    layout  :lStructSize, :uint32,
+      :hwndOwner, :handle,
+      :hDevMode, :handle,
+      :hDevNames, :handle,
+      :Flags, :uint32,
+
+      :ptPaperSizeX, :long,
+      :ptPaperSizeY, :long,
+
+      :rtMinMarginL, :long,
+      :rtMinMarginT, :long,
+      :rtMinMarginR, :long,
+      :rtMinMarginB, :long,
+
+      :rtMarginL, :long,
+      :rtMarginT, :long,
+      :rtMarginR, :long,
+      :rtMarginB, :long,
+
+      :hInstance, :handle,
+      :lCustData, :pointer,
+      :lpfnPageSetupHook, :pointer,
+      :lpfnPagePaintHook, :pointer,
+      :lpPageSetupTemplateName, :pointer,
+      :hPageSetupTemplate, :handle
+  end
+
+  def self.create_PAGESETUPDLG(data_or_size=nil)
+    data = create_struct(PAGESETUPDLG, data_or_size)
+    data[:lStructSize] = data.pointer.size
+    return data
+  end
+
+  class PRINTDLGEX < FFI::Struct
+    layout :lStructSize, :uint32,
+      :hwndOwner, :handle,
+      :hDevMode, :handle,
+      :hDevNames, :handle,
+      :hDC, :handle,
+      :Flags, :uint32,
+      :Flags2, :uint32,
+      :ExclusionFlags, :uint32,
+      :nPageRanges, :uint32,
+      :nMaxPageRanges, :uint32,
+      :lpPageRanges, :pointer,
+      :nMinPage, :uint32,
+      :nMaxPage, :uint32,
+      :nCopies, :uint32,
+      :hInstance, :handle,
+      :lpPrintTemplateName, :pointer,
+      :lpCallback, :pointer,
+      :nPropertyPages, :uint32,
+      :plphPropertyPages, :pointer,
+      :nStartPage, :uint32,
+      :dwResultAction, :uint32
+  end
+  def self.create_PRINTDLGEX(data_or_size=nil)
+    data = create_struct(PRINTDLGEX, data_or_size)
+    data[:lStructSize] = data.pointer.size
+    return data
+  end
+
+  class DEVNAMES < FFI::Struct
+    # struct tagDEVNAMES {
+    #   WORD wDriverOffset;
+    #   WORD wDeviceOffset;
+    #   WORD wOutputOffset;
+    #   WORD wDefault;
+    # } DEVNAMES
+    layout :wDriverOffset, :uint16,
+        :wDeviceOffset, :uint16,
+        :wOutputOffset, :uint16,
+        :wDefault, :uint16
+  end
+  def self.create_DEVNAMES(data_or_size=nil)
+    create_struct(DEVNAMES, data_or_size)
+  end
+
+
+end
+end