RubyGems - win32-clipboard - Versions diffs - 0.5.2 → 0.6.0 - Mend

win32-clipboard 0.5.2 → 0.6.0

Files changed (15) hide show

checksums.yaml +7 -0
data/CHANGES +91 -81
data/MANIFEST +12 -8
data/README +112 -112
data/Rakefile +40 -15
data/examples/clipboard_test.rb +28 -28
data/lib/win32/clipboard.rb +414 -412
data/lib/win32/html_clipboard.rb +232 -0
data/lib/win32/windows/constants.rb +10 -0
data/lib/win32/windows/functions.rb +56 -0
data/lib/win32/windows/structs.rb +43 -0
data/test/test_clipboard.rb +155 -135
data/test/test_html_clipboard.rb +50 -0
data/win32-clipboard.gemspec +26 -30
metadata +78 -46

@@ -0,0 +1,232 @@
+# The Win32 module serves as a namespace only.
+#
+module Win32
+  # The HtmlClipboard class is a subclass of Clipboard that explicitly
+  # handles text in HTML format.
+  #
+  class HtmlClipboard < Clipboard
+    private
+    # Marker block output
+    #--
+    # Version: Version of the clipboard.
+    #
+    # StartHTML: bytecount from the beginning of the clipboard to the
+    #    start of the context, or -1 if no context.
+    #
+    # EndHTML: bytecount from the beginning of the clipboard to the end
+    #    of the context, or -1 if no context.
+    #
+    # StartFragment: bytecount from the beginning of the clipboard to
+    #    the start of the fragment.
+    #
+    # EndFragment: bytecount from the beginning of the clipboard to the
+    #    end of the fragment.
+    #
+    # StartSelection: bytecount from the beginning of the clipboard to
+    #    the start of the selection.
+    #
+    # EndSelection: bytecount from the beginning of the clipboard to the
+    #    end of the selection.
+    #
+    MARKER_BLOCK_OUTPUT =
+      "Version:1.0\r\n" \
+      "StartHTML:%09d\r\n" \
+      "EndHTML:%09d\r\n" \
+      "StartFragment:%09d\r\n" \
+      "EndFragment:%09d\r\n" \
+      "StartSelection:%09d\r\n" \
+      "EndSelection:%09d\r\n" \
+      "SourceURL:%s\r\n"
+    # Extended marker block
+    MARKER_BLOCK_EX =
+      'Version:(\S+)\s+' \
+      'StartHTML:(\d+)\s+' \
+      'EndHTML:(\d+)\s+' \
+      'StartFragment:(\d+)\s+' \
+      'EndFragment:(\d+)\s+' \
+      'StartSelection:(\d+)\s+' \
+      'EndSelection:(\d+)\s+' \
+      'SourceURL:(\S+)'
+    # Regular expression for extended marker block
+    MARKER_BLOCK_EX_RE = Regexp.new(MARKER_BLOCK_EX, Regexp::MULTILINE) # :nodoc:
+    # Standard marker block
+    MARKER_BLOCK =
+      'Version:(\S+)\s+' \
+      'StartHTML:(\d+)\s+' \
+      'EndHTML:(\d+)\s+' \
+      'StartFragment:(\d+)\s+' \
+      'EndFragment:(\d+)\s+' \
+      'SourceURL:(\S+)'
+    # Regular expression for the standard marker block
+    MARKER_BLOCK_RE = Regexp.new(MARKER_BLOCK, Regexp::MULTILINE)
+    # Default HTML body
+    DEFAULT_HTML_BODY =
+      "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 Transitional//EN\">\r\n" \
+      "<HTML><BODY><!--StartFragment-->%s<!--EndFragment--></BODY></HTML>"
+    public
+    # Clipboard format value
+    CF_HTML = RegisterClipboardFormat("HTML Format")
+    def initialize # :nodoc:
+      @html      = nil
+      @fragment  = nil
+      @selection = nil
+      @source    = nil
+      @version   = nil
+    end
+    # Returns a boolean indicating whether or not the clipboard contains
+    # data in HTML format.
+    #
+    def self.html_format?
+      format_available?(CF_HTML)
+    end
+    # This method is nearly identical to the Clipboard.data method, but
+    # it decodes the data to preserve the HTML formatting.
+    #
+    def self.data
+      begin
+        self.open
+        if IsClipboardFormatAvailable(CF_HTML)
+          handle = GetClipboardData(CF_HTML)
+          size   = GlobalSize(handle)
+          ptr    = FFI::Pointer.new(:char, handle)
+          clip_data = decode_data(ptr.read_bytes(size))
+        else
+          clip_data = ''
+        end
+      ensure
+        self.close
+      end
+      clip_data
+    end
+    # Returns the block marker information for the HTML, or an empty
+    # string if there is no clipboard data.
+    #
+    def self.data_details
+      clip_data = data
+      string = ""
+      unless clip_data.empty?
+        string << "prefix=>>>#{@prefix}<<<END"
+        string << "version=>>>#{@version}<<<END"
+        string << "selection=>>>#{@selection}<<<END"
+        string << "fragment=>>>#{@fragment}<<<END"
+        string << "html=>>>#{@html}<<<END"
+        string << "source=>>>#{@source}<<<END"
+      end
+      string
+    end
+    # Put a well-formed fragment of HTML on the clipboard.
+    #
+    # The +selection+, if provided, must be a literal string within a
+    # fragment.
+    #
+    # The +html+ value, if provided, must be a well formed HTML document
+    # that textually contains a fragment and its required markers.
+    #
+    # The +source+, if provided, should include a scheme (file, http, or
+    # https) plus a file name. The default is file:// + __FILE__.
+    #
+    def self.set_data(fragment, selection=nil, html=nil, source=nil)
+      selection ||= fragment
+      html      ||= DEFAULT_HTML_BODY % fragment
+      source    ||= 'file://' + __FILE__
+      fragment_start  = html.index(fragment)
+      fragment_end    = fragment_start + fragment.length
+      selection_start = html.index(selection)
+      selection_end   = selection_start + selection.length
+      clip_data = encode_data(
+        html,
+        fragment_start,
+        fragment_end,
+        selection_start,
+        selection_end,
+        source
+      )
+      self.open
+      EmptyClipboard()
+      # Global Allocate a movable piece of memory.
+      hmem = GlobalAlloc(GHND, clip_data.length + 4)
+      mem  = GlobalLock(hmem)
+      mem.write_bytes(clip_data, 0, clip_data.size)
+      clip_data2 = fragment.gsub(/<[^>]+?>/,'')
+      hmem2 = GlobalAlloc(GHND, clip_data2.length + 4)
+      mem2  = GlobalLock(hmem2)
+      mem2.write_bytes(clip_data2, 0, clip_data2.size)
+      # Set the new data
+      begin
+        if SetClipboardData(CF_HTML, hmem) == 0
+          raise SystemCallError.new('SetClipboardData', FFI.errno)
+        end
+        if SetClipboardData(CF_TEXT, hmem2) == 0
+          raise SystemCallError.new('SetClipboardData', FFI.errno)
+        end
+      ensure
+        GlobalFree(hmem)
+        GlobalFree(hmem2)
+        self.close
+      end
+      self
+    end
+    private
+    # Encode the data markers into the HTML data
+    def self.encode_data(html,frag_start,frag_end,select_start,select_end,src)
+      dummy_prefix = MARKER_BLOCK_OUTPUT % [0,0,0,0,0,0,src]
+      len_prefix = dummy_prefix.length
+      prefix = MARKER_BLOCK_OUTPUT % [len_prefix, html.length + len_prefix,
+      frag_start + len_prefix, frag_end + len_prefix,
+      select_start + len_prefix, select_end + len_prefix, src]
+      prefix + html
+    end
+    # Decode the given string to figure out the details of the HTML
+    # that's on the string.
+    #--
+    # Try the extended format first, which has an explicit selection.
+    # If that fails, try the version without a selection.
+    #
+    def self.decode_data(src)
+      if (matches = MARKER_BLOCK_EX_RE.match(src))
+        @prefix = matches[0]
+        @version = matches[1]
+        @html = src[matches[2].to_i ... matches[3].to_i]
+        @fragment = src[matches[4].to_i ... matches[5].to_i]
+        @selection = src[matches[6].to_i ... matches[7].to_i]
+        @source = matches[8]
+      elsif (matches = MARKER_BLOCK_RE.match(src))
+        @prefix = matches[0]
+        @version = matches[1]
+        @html = src[matches[2].to_i ... matches[3].to_i]
+        @fragment = src[matches[4].to_i ... matches[5].to_i]
+        @source = matches[6]
+        @selection = @fragment
+      else
+        raise 'failed to match block markers'
+      end
+      @fragment
+    end
+  end
+end

data/lib/win32/windows/constants.rb ADDED

@@ -0,0 +1,10 @@
+module Windows
+  module Constants
+    GHND = 0x0042
+    WM_DRAWCLIPBOARD = 0x0308
+    WM_CHANGECBCHAIN = 0x030D
+    GWL_USERDATA = -21
+    GWL_WNDPROC  = -4
+    CF_TEXT = 1
+  end
+end

data/lib/win32/windows/functions.rb ADDED

@@ -0,0 +1,56 @@
+require 'ffi'
+module Windows
+  module Functions
+    extend FFI::Library
+    typedef :uintptr_t, :hglobal
+    typedef :uintptr_t, :hwnd
+    typedef :uintptr_t, :handle
+    typedef :uintptr_t, :hmenu
+    typedef :uintptr_t, :hdrop
+    typedef :uintptr_t, :hinstance
+    typedef :ulong, :dword
+    callback :wnd_proc, [:hwnd, :uint, :long, :long], :long
+    ffi_lib :kernel32
+    attach_function :GlobalAlloc, [:uint, :size_t], :hglobal
+    attach_function :GlobalFree, [:hglobal], :hglobal
+    attach_function :GlobalLock, [:hglobal], :pointer
+    attach_function :GlobalSize, [:hglobal], :size_t
+    attach_function :GlobalUnlock, [:hglobal], :bool
+    ffi_lib :user32
+    attach_function :CloseClipboard, [], :bool
+    attach_function :CountClipboardFormats, [], :int
+    attach_function :CreateWindowEx, :CreateWindowExA, [:dword, :string, :string, :dword, :int, :int, :int, :int, :hwnd, :hmenu, :hinstance, :pointer], :hwnd
+    attach_function :DefWindowProc, :DefWindowProcA, [:hwnd, :uint, :uint, :uint], :long
+    attach_function :DispatchMessage, :DispatchMessageA, [:pointer], :uint
+    attach_function :EmptyClipboard, [], :bool
+    attach_function :EnumClipboardFormats, [:uint], :uint
+    attach_function :GetClipboardData, [:uint], :handle
+    attach_function :GetClipboardFormatName, :GetClipboardFormatNameA, [:uint, :pointer, :int], :int
+    attach_function :GetWindowLongPtr, :GetWindowLongPtrA, [:hwnd, :int], :long
+    attach_function :IsClipboardFormatAvailable, [:uint], :bool
+    attach_function :OpenClipboard, [:hwnd], :bool
+    attach_function :PeekMessage, :PeekMessageA, [:pointer, :hwnd, :uint, :uint, :uint], :bool
+    attach_function :PostMessage, :PostMessageA, [:hwnd, :uint, :uintptr_t, :uintptr_t], :bool
+    attach_function :RegisterClipboardFormat, :RegisterClipboardFormatA, [:string], :uint
+    attach_function :SetClipboardData, [:uint, :handle], :handle
+    attach_function :SetClipboardViewer, [:hwnd], :hwnd
+    attach_function :SetWindowLongPtr, :SetWindowLongPtrA, [:hwnd, :int, :uintptr_t], :long
+    attach_function :TranslateMessage, [:pointer], :bool
+    ffi_lib :shell32
+    attach_function :DragQueryFileA, [:hdrop, :uint, :pointer, :uint], :uint
+    ffi_lib :gdi32
+    attach_function :GetEnhMetaFileBits, [:handle, :uint, :pointer], :uint
+  end
+end

data/lib/win32/windows/structs.rb ADDED

@@ -0,0 +1,43 @@
+require 'ffi'
+module Windows
+  module Structs
+    extend FFI::Library
+    typedef :uchar, :byte
+    typedef :ulong, :dword
+    typedef :ushort, :word
+    class RGBQUAD < FFI::Struct
+      layout(
+        :rgbBlue, :byte,
+        :rgbGreen, :byte,
+        :rgbRed, :byte,
+        :rgbReserved, :byte,
+      )
+    end
+    class BITMAPINFOHEADER < FFI::Struct
+      layout(
+        :biSize, :dword,
+        :biWidth, :long,
+        :biHeight, :long,
+        :biPlanes, :word,
+        :biBitCount, :word,
+        :biCompression, :dword,
+        :biSizeImage, :dword,
+        :biXPelsPerMeter, :long,
+        :biYPelsPerMeter, :long,
+        :biClrUsed, :dword,
+        :biClrImportant, :dword
+      )
+    end
+    class BITMAPINFO < FFI::Struct
+      layout(
+        :bmiHeader, BITMAPINFOHEADER,
+        :bmiColor, [RGBQUAD, 1]
+      )
+    end
+  end
+end

data/test/test_clipboard.rb CHANGED

@@ -1,135 +1,155 @@
-###########################################################################
-# test_clipboard.rb
-#
-# Test suite for the win32-clipboard library.  This will copy and remove
-# data from your clipboard. If your current clipboard data is crucial to
-# you, please save it first.
-#
-# You should run this test case via the 'rake test' task.
-###########################################################################
-require 'rubygems'
-gem 'test-unit'
-require 'win32/clipboard'
-require 'test/unit'
-include Win32
-class TC_Win32_ClipBoard < Test::Unit::TestCase
-   def test_version
-      assert_equal('0.5.2', Clipboard::VERSION)
-   end
-   def test_data
-      assert_respond_to(Clipboard, :data)
-      assert_nothing_raised{ Clipboard.data }
-      assert_kind_of(String, Clipboard.data)
-   end
-   def test_data_expected_errors
-      assert_raise(TypeError){ Clipboard.data('test') }
-      assert_raise(NameError){ Clipboard.data(CF_FOO) }
-   end
-   def test_get_data_alias
-      assert_respond_to(Clipboard, :get_data)
-      assert_true(Clipboard.method(:data) == Clipboard.method(:get_data))
-   end
-   def test_set_data
-      assert_respond_to(Clipboard, :set_data)
-      assert_nothing_raised{ Clipboard.set_data("foo") }
-   end
-   def test_set_data_unicode
-      assert_nothing_raised{
-         Clipboard.set_data('Ηελλας', Clipboard::UNICODETEXT)
-      }
-   end
-   def test_set_data_expected_errors
-      assert_raise(ArgumentError){ Clipboard.set_data }
-      assert_raise(NameError){ Clipboard.set_data('foo', CF_FOO) }
-   end
-   def test_set_and_get_ascii
-      assert_nothing_raised{ Clipboard.set_data('foobar') }
-      assert_equal('foobar', Clipboard.data)
-   end
-   def test_set_and_get_unicode
-      assert_nothing_raised{
-         Clipboard.set_data('Ηελλας', Clipboard::UNICODETEXT)
-      }
-      assert_equal('Ηελλας', Clipboard.data(Clipboard::UNICODETEXT))
-   end
-   def test_empty
-      assert_respond_to(Clipboard, :empty)
-      assert_nothing_raised{ Clipboard.empty }
-   end
-   def test_clear_alias
-      assert_respond_to(Clipboard, :clear)
-      assert_true(Clipboard.method(:clear) == Clipboard.method(:empty))
-   end
-   def test_num_formats
-      assert_respond_to(Clipboard, :num_formats)
-      assert_nothing_raised{ Clipboard.num_formats }
-      assert_kind_of(Fixnum, Clipboard.num_formats)
-   end
-   def test_num_formats_expected_errors
-      assert_raise(ArgumentError){ Clipboard.num_formats(true) }
-   end
-   def test_register_format
-      assert_respond_to(Clipboard, :register_format)
-      assert_nothing_raised{ Clipboard.register_format('Ruby') }
-      assert_kind_of(Integer, Clipboard.register_format('Ruby'))
-   end
-   def test_register_format_expected_errors
-      assert_raises(TypeError){ Clipboard.register_format(1) }
-   end
-   def test_formats
-      assert_respond_to(Clipboard, :formats)
-      assert_nothing_raised{ Clipboard.formats }
-      assert_kind_of(Hash, Clipboard.formats)
-   end
-   def test_formats_expected_errors
-      assert_raise(ArgumentError){ Clipboard.formats(true) }
-   end
-   def test_format_available
-      assert_respond_to(Clipboard, :format_available?)
-      assert_nothing_raised{ Clipboard.format_available?(1) }
-      assert_boolean(Clipboard.format_available?(1))
-   end
-   def test_format_name
-      assert_respond_to(Clipboard, :format_name)
-      assert_nothing_raised{ Clipboard.format_name(1) }
-      assert_nil(Clipboard.format_name(9999999))
-   end
-   def test_format_name_expected_errors
-      assert_raise(TypeError){ Clipboard.format_name('foo') }
-   end
-   def test_notify_change
-      assert_respond_to(Clipboard, :notify_change)
-   end
-   def test_constants
-      assert_not_nil(Clipboard::TEXT)
-      assert_not_nil(Clipboard::OEMTEXT)
-      assert_not_nil(Clipboard::UNICODETEXT)
-      assert_not_nil(Clipboard::BITMAP)
-      assert_not_nil(Clipboard::DIB)
-      assert_not_nil(Clipboard::HDROP)
-      assert_not_nil(Clipboard::ENHMETAFILE)
-   end
-end
+# encoding: utf-8
+###########################################################################
+# test_clipboard.rb
+#
+# Test suite for the win32-clipboard library.  This will copy and remove
+# data from your clipboard. If your current clipboard data is crucial to
+# you, please save it first.
+#
+# You should run this test case via the 'rake test' task.
+###########################################################################
+require 'test-unit'
+require 'win32/clipboard'
+include Win32
+class TC_Win32_ClipBoard < Test::Unit::TestCase
+  test "version is set to expected value" do
+    assert_equal('0.6.0', Clipboard::VERSION)
+  end
+  test "data method basic functionality" do
+    assert_respond_to(Clipboard, :data)
+    assert_nothing_raised{ Clipboard.data }
+    assert_kind_of(String, Clipboard.data)
+  end
+  test "data method requires proper format" do
+    assert_raise(TypeError){ Clipboard.data('test') }
+    assert_raise(NameError){ Clipboard.data(CF_FOO) }
+  end
+  test "get_data is an alias for data" do
+    assert_respond_to(Clipboard, :get_data)
+    assert_alias_method(Clipboard, :data, :get_data)
+  end
+  test "set_data basic functionality" do
+    assert_respond_to(Clipboard, :set_data)
+    assert_nothing_raised{ Clipboard.set_data('foo') }
+  end
+  test "set_data works with unicode text" do
+    assert_nothing_raised{
+      Clipboard.set_data('Ηελλας', Clipboard::UNICODETEXT)
+    }
+  end
+  test "set_data requires at least one argument" do
+    assert_raise(ArgumentError){ Clipboard.set_data }
+  end
+  test "set_data requires a valid data format" do
+    assert_raise(NameError){ Clipboard.set_data('foo', CF_FOO) }
+  end
+  test "set and get ascii data as expected" do
+    assert_nothing_raised{ Clipboard.set_data('foobar') }
+    assert_equal('foobar', Clipboard.data)
+  end
+  test "set and get unicode data as expected" do
+    assert_nothing_raised{
+       Clipboard.set_data('Ηελλας', Clipboard::UNICODETEXT)
+    }
+    assert_equal('Ηελλας', Clipboard.data(Clipboard::UNICODETEXT))
+  end
+  test "empty method basic functionality" do
+    assert_respond_to(Clipboard, :empty)
+    assert_nothing_raised{ Clipboard.empty }
+  end
+  test "clear is an alias for empty" do
+    assert_respond_to(Clipboard, :clear)
+    assert_alias_method(Clipboard, :clear, :empty)
+  end
+  test "num_formats basic functionality" do
+    assert_respond_to(Clipboard, :num_formats)
+    assert_nothing_raised{ Clipboard.num_formats }
+    assert_kind_of(Fixnum, Clipboard.num_formats)
+  end
+  test "num_formats returns an expected value" do
+    assert_true(Clipboard.num_formats >= 0)
+    assert_true(Clipboard.num_formats < 1000)
+  end
+  test "num_formats does not accept any arguments" do
+    assert_raise(ArgumentError){ Clipboard.num_formats(true) }
+  end
+  test "register_format basic functionality" do
+    assert_respond_to(Clipboard, :register_format)
+    assert_nothing_raised{ Clipboard.register_format('Ruby') }
+    assert_kind_of(Integer, Clipboard.register_format('Ruby'))
+  end
+  test "register_format requires a string argument" do
+    assert_raises(TypeError){ Clipboard.register_format(1) }
+  end
+  test "formats method basic functionality" do
+    assert_respond_to(Clipboard, :formats)
+    assert_nothing_raised{ Clipboard.formats }
+    assert_kind_of(Hash, Clipboard.formats)
+  end
+  # TODO: Why do these fail?
+  #test "formats result contains expected values" do
+  #  assert_true(Clipboard.formats.size > 0)
+  #  assert_true(Clipboard.formats.include?(1))
+  #end
+  test "formats method does not accept any arguments" do
+    assert_raise(ArgumentError){ Clipboard.formats(true) }
+  end
+  test "format_available basic functionality" do
+    assert_respond_to(Clipboard, :format_available?)
+    assert_nothing_raised{ Clipboard.format_available?(1) }
+  end
+  test "format_available returns a boolean value" do
+    assert_boolean(Clipboard.format_available?(1))
+  end
+  test "format_name basic functionality" do
+    assert_respond_to(Clipboard, :format_name)
+    assert_nothing_raised{ Clipboard.format_name(1) }
+  end
+  test "format_name returns expected value" do
+    format = Clipboard.register_format('HTML Format')
+    assert_equal('HTML Format', Clipboard.format_name(format))
+    assert_nil(Clipboard.format_name(9999999))
+  end
+  test "format_name requires a numeric argument" do
+    assert_raise(TypeError){ Clipboard.format_name('foo') }
+  end
+  test "notify_change basic functionality" do
+    assert_respond_to(Clipboard, :notify_change)
+  end
+  test "expected constants are defined" do
+    assert_not_nil(Clipboard::TEXT)
+    assert_not_nil(Clipboard::OEMTEXT)
+    assert_not_nil(Clipboard::UNICODETEXT)
+    assert_not_nil(Clipboard::BITMAP)
+    assert_not_nil(Clipboard::DIB)
+    assert_not_nil(Clipboard::HDROP)
+    assert_not_nil(Clipboard::ENHMETAFILE)
+  end
+end