win32api4ruby 0.2.2

data/lib/win32api4ruby/winspool.rb

@@ -0,0 +1,320 @@
+# -*- coding: UTF-8 -*-
+
+require 'win32api4ruby/base'
+
+module Win32api4ruby
+class Winspool < Base
+  extend FFI::Library
+  ffi_lib 'winspool.drv'
+  ffi_convention :stdcall
+
+  PRINTER_ENUM_DEFAULT = 0x00000001
+  PRINTER_ENUM_LOCAL = 0x00000002
+  PRINTER_ENUM_CONNECTIONS = 0x00000004
+  PRINTER_ENUM_FAVORITE = 0x00000004
+  PRINTER_ENUM_NAME = 0x00000008
+  PRINTER_ENUM_REMOTE = 0x00000010
+  PRINTER_ENUM_SHARED = 0x00000020
+  PRINTER_ENUM_NETWORK = 0x00000040
+
+  PRINTER_INFO_1 = 1
+  PRINTER_INFO_2 = 2
+  PRINTER_INFO_3 = 3
+  PRINTER_INFO_4 = 4
+  PRINTER_INFO_5 = 5
+
+  DM_PROMPT = 4
+  DM_IN_PROMPT = DM_PROMPT
+  DM_MODIFY = 8
+  DM_IN_BUFFER = DM_MODIFY
+  DM_COPY = 2
+  DM_OUT_BUFFER = DM_COPY
+
+  IDOK = 1
+  IDCANCEL = 2
+
+  attach_function :EnumPrintersA, [ :long, :pointer, :long, :pointer, :long, :pointer, :pointer ], :int
+  attach_function :EnumPrintersW, [ :long, :pointer, :long, :pointer, :long, :pointer, :pointer ], :int
+  def self.enum_printers(flags, name, level)
+    pcbNeeded = FFI::MemoryPointer.new(:long)
+    pcReturned = FFI::MemoryPointer.new(:long)
+    pcbNeeded.write_long 0
+
+    # erst einmal ermitteln, wieviel Speicher gebraucht wird
+    args = flags, name, level, nil, 0, pcbNeeded, pcReturned
+    unicode ? EnumPrintersW(*args) : EnumPrintersA(*args)
+
+    # und dann die Infos holen
+    cbBuf = pcbNeeded.read_long
+#     puts "pcbNeeded: #{cbBuf}"
+    pPrinterEnum = FFI::MemoryPointer.new(cbBuf)
+    exception_for_0{
+      args = flags, name, level, pPrinterEnum, cbBuf, pcbNeeded, pcReturned
+      unicode ? EnumPrintersW(*args) : EnumPrintersA(*args)
+    }
+
+    #~ p "Laenge des übergebenen Puffers: #{cbBuf}"
+    returned = pcReturned.read_long
+#     puts "benoetigte Bytes: #{pcbNeeded.read_long}"
+#     puts "zurueckgegebene Drucker: #{returned}"
+
+    printers = (0...returned).map{|idx|
+      case level
+      when PRINTER_INFO_4
+        create_PRINTER_INFO_4(pPrinterEnum + idx*PRINTER_INFO_4_struct.size)
+      else
+        raise "unsupported printer info level #{level.inspect}"
+      end
+    }
+    return printers
+  end
+
+  class PRINTER_INFO_4_struct < FFI::Struct
+    #   typedef self.struct _PRINTER_INFO_4 {
+    #     LPTSTR pPrinterName;
+    #     LPTSTR pServerName;
+    #     DWORD  Attributes;
+    #   }PRINTER_INFO_4, *PPRINTER_INFO_4;
+    #
+    layout :pPrinterName, :pointer,
+      :pServerName, :pointer,
+      :Attributes, :uint32
+  end
+
+  def self.create_PRINTER_INFO_4(data_or_size=nil)
+    create_struct(PRINTER_INFO_4_struct, data_or_size)
+  end
+
+
+  # LONG DocumentProperties(
+  #   __in   HWND hWnd,
+  #   __in   HANDLE hPrinter,
+  #   __in   LPTSTR pDeviceName,
+  #   __out  PDEVMODE pDevModeOutput,
+  #   __in   PDEVMODE pDevModeInput,
+  #   __in   DWORD fMode
+  # );
+  #
+  attach_function :DocumentPropertiesW, [ :handle, :handle, :pointer, :pointer, :pointer, :uint32 ], :long
+  attach_function :DocumentPropertiesA, [ :handle, :handle, :pointer, :pointer, :pointer, :uint32 ], :long
+  def self.document_properties(hWnd, hPrinter, deviceName, devModeInput, mode)
+    # erst einmal ermitteln, wieviel Speicher gebraucht wird
+    bufsize = exception_for_negative{
+      args = hWnd, hPrinter, deviceName, nil, devModeInput, 0
+      unicode ? DocumentPropertiesW(*args) : DocumentPropertiesA(*args)
+    }
+
+    # und dann die Infos holen
+    pDevModeOutput = create_DEVMOD(bufsize)
+    res = exception_for_negative{
+      args = hWnd, hPrinter, deviceName, pDevModeOutput, devModeInput, mode
+      unicode ? DocumentPropertiesW(*args) : DocumentPropertiesA(*args)
+    }
+    if res==IDOK
+      return pDevModeOutput
+    else
+      return nil
+    end
+  end
+
+
+  attach_function :OpenPrinterW, [ :pointer, :pointer, :pointer ], :long
+  attach_function :OpenPrinterA, [ :pointer, :pointer, :pointer ], :long
+  # BOOL OpenPrinter(
+  #   __in   LPTSTR pPrinterName,
+  #   __out  LPHANDLE phPrinter,
+  #   __in   LPPRINTER_DEFAULTS pDefault
+  # );
+  def self.open_printer(pPrinterName, phPrinter, pDefault)
+    check(pPrinterName,String)
+    #phPrinter is the PRINTER_DEFAULTS structure.. 0 for default
+    # since we want to send through a zero for default, can't enforce string check...
+    exception_for_0{
+      args = pPrinterName, phPrinter, pDefault
+      unicode ? OpenPrinterW(*args) : OpenPrinterA(*args)
+    }
+  end
+  #-----------------------------------------------------------------------------------------------------------------
+
+  attach_function :ClosePrinter, [ :handle ], :int
+  def self.close_printer(hPrinter)
+    exception_for_0{
+      ClosePrinter(hPrinter)
+    }
+  end
+  #-----------------------------------------------------------------------------------------------------------------
+
+  attach_function :AbortPrinter, [ :handle ], :int
+  def self.abort_printer(hPrinter)
+    exception_for_0{
+      AbortPrinter(hPrinter)
+    }
+  end
+  #-----------------------------------------------------------------------------------------------------------------
+
+  attach_function :StartDocPrinterA, [ :handle, :uint32, :pointer ], :uint32
+  attach_function :StartDocPrinterW, [ :handle, :uint32, :pointer ], :uint32
+  def self.start_doc_printer(hPrinter, level, pDocInfo)
+    check(level, Integer);
+#    check(pDocInfo, String)
+    exception_for_0{
+      args = hPrinter, level, pDocInfo
+      unicode ? StartDocPrinterW(*args) : StartDocPrinterA(*args)
+    }
+  end
+  #-----------------------------------------------------------------------------------------------------------------
+
+  attach_function :EndDocPrinter, [ :handle ], :int
+  def self.end_doc_printer(hPrinter)
+    exception_for_0{
+      EndDocPrinter(hPrinter)
+    }
+  end
+  #-----------------------------------------------------------------------------------------------------------------
+
+  attach_function :StartPagePrinter, [ :handle ], :int
+  def self.start_page_printer(hPrinter)
+    exception_for_0{
+      StartPagePrinter(hPrinter)
+    }
+  end
+  #-----------------------------------------------------------------------------------------------------------------
+
+  attach_function :EndPagePrinter, [ :handle ], :int
+  def self.end_page_printer(hPrinter)
+    exception_for_0{
+      EndPagePrinter(hPrinter)
+    }
+  end
+  #-----------------------------------------------------------------------------------------------------------------
+
+  attach_function :GetPrinterA, [ :handle, :uint32, :pointer, :uint32, :pointer ], :int
+  attach_function :GetPrinterW, [ :handle, :uint32, :pointer, :uint32, :pointer ], :int
+  def self.get_printer(hPrinter, level, pPrinter, cbBuf, pcbNeeded)
+    #~ BOOL GetPrinter(
+      #~ __in   HANDLE hPrinter,
+      #~ __in   DWORD Level,
+      #~ __out  LPBYTE pPrinter,
+      #~ __in   DWORD cbBuf,
+      #~ __out  LPDWORD pcbNeeded
+    #~ );
+    #~ exception_for_0{
+      args = hPrinter, level, pPrinter, cbBuf, pcbNeeded
+      unicode ? GetPrinterW(*args) : GetPrinterA(*args)
+    #~ }
+  end
+
+#-----------------------------------------------------------------------------------------------------------------
+
+  attach_function :WritePrinter, [ :handle, :pointer, :uint32, :pointer ], :int
+	def self.write_printer(hPrinter, pBuf)
+    #~ BOOL WritePrinter(
+    #~ __in   HANDLE hPrinter,
+    #~ __in   LPVOID pBuf,
+    #~ __in   DWORD cbBuf,
+    #~ __out  LPDWORD pcWritten
+    #~ );
+		pcWritten = FFI::MemoryPointer.new :uint32
+    exception_for_0{
+      WritePrinter(hPrinter, pBuf, pBuf.length, pcWritten)
+		}
+		pcWritten.read_uint32
+  end
+
+  class DOC_INFO_1W < FFI::Struct
+    layout :pDocName, :pointer,
+      :pOutputFile, :pointer,
+      :pDatatype, :pointer
+  end
+
+  class DOC_INFO_1A < FFI::Struct
+    layout :pDocName, :pointer,
+      :pOutputFile, :pointer,
+      :pDatatype, :pointer
+  end
+
+	def self.create_DOC_INFO_1(data_or_size=nil)
+    create_struct(unicode ? DOC_INFO_1W : DOC_INFO_1A, data_or_size)
+	end
+
+#-----------------------------------------------------------------------------------------------------------------
+
+  class DEVMODW < FFI::Struct
+    layout :dmDeviceName, [:uint16, 32],
+      :dmSpecVersion, :uint16,
+      :dmDriverVersion, :uint16,
+      :dmSize, :uint16,
+      :dmDriverExtra, :uint16,
+      :dmFields, :uint32,
+          :dmOrientation, :int16,
+          :dmPaperSize, :int16,
+          :dmPaperLength, :int16,
+          :dmPaperWidth, :int16,
+          :dmScale, :int16,
+          :dmCopies, :int16,
+          :dmDefaultSource, :int16,
+          :dmPrintQuality, :int16,
+      :dmColor, :int16,
+      :dmDuplex, :int16,
+      :dmYResolution, :int16,
+      :dmTTOption, :int16,
+      :dmCollate, :int16,
+      :dmFormName, [:uint16, 32],
+      :dmLogPixels, :uint16,
+      :dmBitsPerPel, :uint32,
+      :dmPelsWidth, :uint32,
+      :dmPelsHeight, :uint32,
+        :dmNup, :uint32,
+      :dmDisplayFrequency, :uint32,
+      :dmICMMethod, :uint32,
+      :dmICMIntent, :uint32,
+      :dmMediaType, :uint32,
+      :dmDitherType, :uint32,
+      :dmReserved1, :uint32,
+      :dmReserved2, :uint32,
+      :dmPanningWidth, :uint32,
+      :dmPanningHeight, :uint32
+  end
+
+  class DEVMODA < FFI::Struct
+    layout :dmDeviceName, [:uint8, 32],
+      :dmSpecVersion, :uint16,
+      :dmDriverVersion, :uint16,
+      :dmSize, :uint16,
+      :dmDriverExtra, :uint16,
+      :dmFields, :uint32,
+          :dmOrientation, :int16,
+          :dmPaperSize, :int16,
+          :dmPaperLength, :int16,
+          :dmPaperWidth, :int16,
+          :dmScale, :int16,
+          :dmCopies, :int16,
+          :dmDefaultSource, :int16,
+          :dmPrintQuality, :int16,
+      :dmColor, :int16,
+      :dmDuplex, :int16,
+      :dmYResolution, :int16,
+      :dmTTOption, :int16,
+      :dmCollate, :int16,
+      :dmFormName, [:uint8, 32],
+      :dmLogPixels, :uint16,
+      :dmBitsPerPel, :uint32,
+      :dmPelsWidth, :uint32,
+      :dmPelsHeight, :uint32,
+        :dmNup, :uint32,
+      :dmDisplayFrequency, :uint32,
+      :dmICMMethod, :uint32,
+      :dmICMIntent, :uint32,
+      :dmMediaType, :uint32,
+      :dmDitherType, :uint32,
+      :dmReserved1, :uint32,
+      :dmReserved2, :uint32,
+      :dmPanningWidth, :uint32,
+      :dmPanningHeight, :uint32
+  end
+
+  def self.create_DEVMOD(data_or_size=nil)
+    create_struct(unicode ? DEVMODW : DEVMODA, data_or_size)
+  end
+end
+end

data/lib/win32api4ruby.rb

@@ -0,0 +1,12 @@
+# -*- coding: UTF-8 -*-
+
+module Win32api4ruby
+  VERSION = '0.2.2'
+
+  autoload 'Base', 'win32api4ruby/base'
+  autoload 'Comdlg', 'win32api4ruby/comdlg'
+  autoload 'Gdi', 'win32api4ruby/gdi'
+  autoload 'Kernel', 'win32api4ruby/kernel'
+  autoload 'User', 'win32api4ruby/user'
+  autoload 'Winspool', 'win32api4ruby/winspool'
+end

data/test/all_tests.rb

@@ -0,0 +1,5 @@
+require "test/unit"
+require "win32api4ruby"
+
+basedir = File.dirname(__FILE__)
+Dir[File.join(basedir, 'test_*.rb')].each{|f| load f }

data/test/base.rb

@@ -0,0 +1,17 @@
+
+def define_test_class(modul)
+  Class.instance_eval <<-EOT
+    class TestAnsi#{modul} < Test::Unit::TestCase
+      include #{modul}
+      def setup
+        Win32api4ruby::Base.unicode = false
+      end
+    end
+    class TestUnicode#{modul} < Test::Unit::TestCase
+      include #{modul}
+      def setup
+        Win32api4ruby::Base.unicode = true
+      end
+    end
+  EOT
+end

data/test/test_comdlg.rb

@@ -0,0 +1,30 @@
+require "test/unit"
+require "win32api4ruby"
+require File.join(File.dirname(__FILE__),"base")
+
+module TestComdlg
+  include Win32api4ruby
+
+  def test_print_dialog
+    # wird zwar gestartet, liefert aber keine gef�llte struktur zur�ck
+    pdlg = Comdlg.create_PRINTDLG
+    pdlg[:hwndOwner] = 0
+    pdlg[:Flags] = Comdlg::PD_RETURNDC | Comdlg::PD_NOSELECTION
+    ok = Comdlg.print_dlg(pdlg)
+
+    puts "res: #{ok.to_s(16)}" # pdlg: #{pdlg.values}"
+    hDevNames = pdlg[:hDevNames]
+    Kernel.with_global_lock(hDevNames){|pDevNames|
+      dn_prt = Comdlg.create_DEVNAMES(pDevNames)
+
+      u = Base.unicode ? 2 : 1
+      driver = FFI::Pointer.new(pDevNames+dn_prt[:wDriverOffset]*u).to_s_utf8
+      device = FFI::Pointer.new(pDevNames+dn_prt[:wDeviceOffset]*u).to_s_utf8
+      output = FFI::Pointer.new(pDevNames+dn_prt[:wOutputOffset]*u).to_s_utf8
+      default = FFI::Pointer.new(pDevNames+dn_prt[:wDefault]*u).to_s_utf8
+      puts "Driver: #{driver.inspect} Device: #{device.inspect} Output: #{output.inspect} Default: #{default.inspect}"
+    }
+  end
+end
+
+define_test_class(TestComdlg)

data/test/test_gdi.rb

@@ -0,0 +1,85 @@
+require "test/unit"
+require "win32api4ruby"
+require File.join(File.dirname(__FILE__),"base")
+
+module TestGdi
+  include Win32api4ruby
+
+  def test_create_font
+    nHeight = 0
+    nWidth = 0
+    nEscapement = 0
+    nOrientation = 0
+    fnWeight = 400
+    fdwItalic = 0
+    fdwUnderline = 0
+    fdwStrikeOut = 0
+    fdwCharSet = 0
+    fdwOutputPrecision = 0
+    fdwClipPrecision = 0
+    fdwQuality = 0
+    fdwPitchAndFamily = 0
+    lpszFace = "Arial".to_s_win32
+
+    font = Gdi.create_font(nHeight, nWidth, nEscapement, nOrientation, fnWeight, fdwItalic, fdwUnderline, fdwStrikeOut, fdwCharSet, fdwOutputPrecision, fdwClipPrecision, fdwQuality, fdwPitchAndFamily, lpszFace)
+
+    assert font.to_i != 0
+  end
+
+  def test_create_bitmap
+    hwnd = User.create_window_ex(0, 'STATIC'.to_s_win32, 'Name'.to_s_win32, User::WS_VISIBLE, 0,0,600,300, nil, nil, nil)
+    hdc = User.get_dc(hwnd)
+    lpbmi = Gdi.create_BITMAPINFOHEADER
+
+    xDest, yDest, dwWidth, dwHeight, xSrc, ySrc = 0,0, 60,50, 0,0
+    lpvBits = ('z000'+'0z00'+'00z0') * (dwWidth/3) * dwHeight
+    uStartScan, cScanLines = 0, dwHeight
+    fuColorUse = Gdi::DIB_RGB_COLORS
+
+    lpbmi[:biWidth] = dwWidth
+    lpbmi[:biHeight] = dwHeight
+    lpbmi[:biPlanes] = 1
+    lpbmi[:biBitCount] = 32
+    lpbmi[:biCompression] = Gdi::BI_RGB
+    lpbmi[:biSizeImage] = lpvBits.length
+    lpbmi[:biXPelsPerMeter] = 0
+    lpbmi[:biYPelsPerMeter] = 0
+    lpbmi[:biClrUsed] = 0
+    lpbmi[:biClrImportant] = 0
+
+    Gdi.set_dibits_to_device(hdc, xDest, yDest, dwWidth, dwHeight, xSrc, ySrc, uStartScan, cScanLines, lpvBits, lpbmi, fuColorUse)
+  end
+
+	def test_escape
+    hPrinter = Win32api4ruby::Gdi.create_dc(nil, "Microsoft XPS Document Writer".to_s_win32, nil, nil)
+    #~ hPrinter = Win32api4ruby::Gdi.create_dc(nil, "Zebra P430i Card Printer USB".to_s_win32, nil, nil)
+
+    documentName = "Test Escape"
+    docinfo = Win32api4ruby::Gdi.create_DOCINFO
+    docinfo[:lpszDocName] = documentName.to_s_win32
+		Gdi.start_doc(hPrinter, docinfo)
+
+		send_escape(hPrinter, "MCL")
+		send_escape(hPrinter, "MCI")
+
+		Gdi.end_doc(hPrinter)
+		Gdi.delete_dc(hPrinter)
+		GC.start
+	end
+
+	private
+
+	def send_escape(hPrinter, escape)
+		command = ["1B", escape, "0D"].pack("H*a*H*")
+		puts("Send #{escape}")
+		start = Time.now
+		Gdi.escape(hPrinter, Gdi::PASSTHROUGH, [command.length, command].pack('va*'), nil)
+#    dur = Time.now - start
+#		puts("Time for #{escape}: #{dur}s")
+#		puts("Sleep for 5s...")
+		sleep(5)
+	end
+
+end
+
+define_test_class(TestGdi)

data/test/test_kernel.rb

@@ -0,0 +1,34 @@
+require "test/unit"
+require "win32api4ruby"
+require "ffi"
+require File.join(File.dirname(__FILE__),"base")
+
+module TestKernel
+  include Win32api4ruby
+  
+  def test_global_lock
+    assert_raise(Win32api4ruby::Base::ApiError){
+      Kernel.global_lock(FFI::Pointer.new(1234567))
+    }
+  end
+
+  def test_format_message
+    message = FFI::MemoryPointer.new(1024) #store 1kb space
+    Kernel.format_message(0x1000, '', 100, 0, message, 1024, '')
+    mu = message.to_s_utf8
+    assert mu.length > 5
+    assert mu.length < 100
+    if String.method_defined?(:encoding)
+      assert mu.valid_encoding?
+      assert_equal Encoding::UTF_8, mu.encoding
+    end
+  end
+
+  def test_get_set_last_error
+    Kernel.set_last_error(100)
+    # get_last_error wird bereits irgendwo vorher abgefragt:
+    assert_equal 100, Kernel.get_last_error
+  end
+end
+
+define_test_class(TestKernel)

data/test/test_user.rb

@@ -0,0 +1,15 @@
+require "test/unit"
+require "win32api4ruby"
+require File.join(File.dirname(__FILE__),"base")
+
+module TestUser
+  include Win32api4ruby
+
+  def test_create_window_ex
+    hwnd = User.create_window_ex(0, 'Button'.to_s_win32, "name".to_s_win32, User::WS_VISIBLE, 0,0,100,100, nil, nil, nil)
+    assert hwnd.to_i > 0
+    User.destroy_window(hwnd)
+  end
+end
+
+define_test_class(TestUser)

data/test/test_winspool.rb

@@ -0,0 +1,36 @@
+require "test/unit"
+require "win32api4ruby"
+require File.join(File.dirname(__FILE__),"base")
+
+module TestWinspool
+  include Win32api4ruby
+
+  def test_enum_printers
+    flags = Winspool::PRINTER_ENUM_NAME
+    name = nil
+    level = 4
+    infos = Winspool.enum_printers(flags, name, level)
+    infos[0..1].each{|info|
+      puts "PrinterName: #{info[:pPrinterName].to_s_utf8}, ServerName: #{info[:pServerName].to_s_utf8}, Attributes: #{info[:Attributes]}"
+    }
+  end
+
+  def test_document_properties
+    flags = Winspool::PRINTER_ENUM_NAME
+    name = nil
+    level = 4
+    infos = Winspool.enum_printers(flags, name, level)
+    info = infos[0]
+
+    if info
+      devmod = Winspool.document_properties nil, nil, info[:pPrinterName], nil, Winspool::DM_OUT_BUFFER
+      assert devmod.size > 10
+      assert_operator 50..10000, :===, devmod[:dmYResolution]
+      assert_operator 50..10000, :===, devmod[:dmPrintQuality]
+    else
+      puts "no printer installed"
+    end
+  end
+end
+
+define_test_class(TestWinspool)

metadata

@@ -0,0 +1,139 @@
+--- !ruby/object:Gem::Specification
+name: win32api4ruby
+version: !ruby/object:Gem::Version
+  version: 0.2.2
+platform: ruby
+authors:
+- Lars Kanis
+bindir: bin
+cert_chain:
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIEBDCCAmygAwIBAgIBBDANBgkqhkiG9w0BAQsFADAoMSYwJAYDVQQDDB1sYXJz
+  L0RDPWdyZWl6LXJlaW5zZG9yZi9EQz1kZTAeFw0yNjAxMDUxMTE5MzRaFw0yNzAx
+  MDUxMTE5MzRaMCgxJjAkBgNVBAMMHWxhcnMvREM9Z3JlaXotcmVpbnNkb3JmL0RD
+  PWRlMIIBojANBgkqhkiG9w0BAQEFAAOCAY8AMIIBigKCAYEAwum6Y1KznfpzXOT/
+  mZgJTBbxZuuZF49Fq3K0WA67YBzNlDv95qzSp7V/7Ek3NCcnT7G+2kSuhNo1FhdN
+  eSDO/moYebZNAcu3iqLsuzuULXPLuoU0GsMnVMqV9DZPh7cQHE5EBZ7hlzDBK7k/
+  8nBMvR0mHo77kIkapHc26UzVq/G0nKLfDsIHXVylto3PjzOumjG6GhmFN4r3cP6e
+  SDfl1FSeRYVpt4kmQULz/zdSaOH3AjAq7PM2Z91iGwQvoUXMANH2v89OWjQO/NHe
+  JMNDFsmHK/6Ji4Kk48Z3TyscHQnipAID5GhS1oD21/WePdj7GhmbF5gBzkV5uepd
+  eJQPgWGwrQW/Z2oPjRuJrRofzWfrMWqbOahj9uth6WSxhNexUtbjk6P8emmXOJi5
+  chQPnWX+N3Gj+jjYxqTFdwT7Mj3pv1VHa+aNUbqSPpvJeDyxRIuo9hvzDaBHb/Cg
+  9qRVcm8a96n4t7y2lrX1oookY6bkBaxWOMtWlqIprq8JZXM9AgMBAAGjOTA3MAkG
+  A1UdEwQCMAAwCwYDVR0PBAQDAgSwMB0GA1UdDgQWBBQ4h1tIyvdUWtMI739xMzTR
+  7EfMFzANBgkqhkiG9w0BAQsFAAOCAYEAg/1LuXN3X8xwHVnhRvmBCZYkNErko40y
+  juq/qPF9vkPGxLEGaeZF1rv/obTs5SgIGEUkWdRsOl3F6bQN4MYUFlN/n6rPx19g
+  CqUMkmRtuFD+9EFBI4twoF2IJS0pYr9tkjUq8mb0VXblvfbEEUf460BJmuBXZTc6
+  OoLQHxjhhqhKBoP4lHXg/OMK9dnGn8+5DoKcsyWQvqq/GdK8pi4E47M/egzw54Go
+  g+oeyGDsNKOQlnIA9gbyPpExD1+akJ4v88T8jOUnsOkhBBUkpSktC2QmEYIU5e9j
+  N7muw6O5Bz3CQuSWIEjj9mMUS2fEEfq2km6zO5vs5eD6TdFnt8AC/HlOrPaxGcUX
+  Hjw/K7ZTvZLEb4awRijdy4wx3OlL9FAyZPjYOh8TdJrLl076c7GyimAkgnc8BrL5
+  g1vGc759o2t3KNnlUg8VwqkhFJp4gCko1QO/8Io5hPQZOvJw8dmqNiiiHqaDupfl
+  CI4mk2K8yQa8xtQ/RmFZxYS5XbHhDJCw
+  -----END CERTIFICATE-----
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8'
+- !ruby/object:Gem::Dependency
+  name: hoe
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.7'
+description: |
+  Yet another win32 to ruby wrapper
+
+  ==== To Install:
+email:
+- lars@greiz-reinsdorf.de
+executables: []
+extensions: []
+extra_rdoc_files:
+- History.txt
+- README.txt
+files:
+- ".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
+homepage: https://github.com/larskanis/win32api4ruby
+licenses:
+- MIT
+metadata: {}
+rdoc_options:
+- "--main"
+- README.txt
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.16
+specification_version: 4
+summary: 'Yet another win32 to ruby wrapper  ==== To Install:'
+test_files: []