dde 0.2.9 → 0.2.11

data/exp/exp_lib.rb

@@ -1,38 +1,38 @@
-# Quick and dirty DDE Library
-
-require 'ffi'
-require 'win/dde'
-require 'win/gui/message'
-require_relative 'exp_lib'
-
-module DDELib
-  extend FFI::Library
-  CP_WINANSI = 1004
-  DNS_REGISTER = 1
-  APPCLASS_STANDARD = 0
-  CF_TEXT = 1
-
-  XTYPF_NOBLOCK = 0x0002
-  XCLASS_BOOL   = 0x1000
-  XCLASS_FLAGS  = 0x4000
-  XTYP_CONNECT  = 0x0060 | XCLASS_BOOL | XTYPF_NOBLOCK
-  XTYP_POKE     = 0x0090 | XCLASS_FLAGS
-  XTYP_EXECUTE  = 0x0050 | XCLASS_FLAGS
-  TIMEOUT_ASYNC = 0xFFFFFFFF
-
-  DDE_FACK      = 0x8000
-
-  ffi_lib 'user32', 'kernel32'  # Default library
-  ffi_convention :stdcall
-
-  callback :DdeCallback, [:uint, :uint, :ulong, :pointer, :pointer, :pointer, :pointer], :ulong
-
-  attach_function(:DdeInitializeA, [:pointer, :DdeCallback, :uint32, :uint32], :uint)
-  attach_function(:DdeCreateStringHandleA, [:uint32, :pointer, :int], :ulong)
-  attach_function :DdeNameService, [:uint32, :ulong, :ulong, :uint], :ulong
-  attach_function(:DdeConnect, [:uint32, :ulong, :ulong, :pointer], :ulong)
-  attach_function :DdeDisconnect, [:ulong], :int
-  attach_function(:DdeClientTransaction, [:pointer, :uint32, :ulong, :ulong, :uint, :uint, :uint32, :pointer], :pointer)
-  attach_function :DdeGetLastError, [:uint32], :int
-end
-
+# Quick and dirty DDE Library
+
+require 'ffi'
+require 'win/dde'
+require 'win/gui/message'
+require_relative 'exp_lib'
+
+module DdeLib
+  extend FFI::Library
+  CP_WINANSI = 1004
+  DNS_REGISTER = 1
+  APPCLASS_STANDARD = 0
+  CF_TEXT = 1
+
+  XTYPF_NOBLOCK = 0x0002
+  XCLASS_BOOL   = 0x1000
+  XCLASS_FLAGS  = 0x4000
+  XTYP_CONNECT  = 0x0060 | XCLASS_BOOL | XTYPF_NOBLOCK
+  XTYP_POKE     = 0x0090 | XCLASS_FLAGS
+  XTYP_EXECUTE  = 0x0050 | XCLASS_FLAGS
+  TIMEOUT_ASYNC = 0xFFFFFFFF
+
+  DDE_FACK      = 0x8000
+
+  ffi_lib 'user32', 'kernel32'  # Default library
+  ffi_convention :stdcall
+
+  callback :DdeCallback, [:uint, :uint, :ulong, :pointer, :pointer, :pointer, :pointer], :ulong
+
+  attach_function(:DdeInitializeA, [:pointer, :DdeCallback, :uint32, :uint32], :uint)
+  attach_function(:DdeCreateStringHandleA, [:uint32, :pointer, :int], :ulong)
+  attach_function :DdeNameService, [:uint32, :ulong, :ulong, :uint], :ulong
+  attach_function(:DdeConnect, [:uint32, :ulong, :ulong, :pointer], :ulong)
+  attach_function :DdeDisconnect, [:ulong], :int
+  attach_function(:DdeClientTransaction, [:pointer, :uint32, :ulong, :ulong, :uint, :uint, :uint32, :pointer], :pointer)
+  attach_function :DdeGetLastError, [:uint32], :int
+end
+

data/exp/exp_server.rb

@@ -1,44 +1,44 @@
-# Quick and dirty DDE Server (for experimentation)
-
-require 'win/gui/message'
-include Win::GUI::Message
-
-#require_relative 'exp_lib'
-#include DDELib
-
-require 'win/dde'
-include Win::DDE
-
-calls = []
-buffer = FFI::MemoryPointer.new(:long).write_long(0)
-buffer.address
-
-callback = lambda do |*args|
-  calls << [*args]
-  puts "#{Time.now.strftime('%T.%6N')} #{args.map{|e|e.respond_to?(:address) ? e.address : (Win::DDE::TYPES[e] || e)}}"
-  args.first == XTYP_CONNECT ? 1 : DDE_FACK
-end
-
-status = DdeInitialize(buffer, callback, APPCLASS_STANDARD, 0)
-id = buffer.read_long
-
-service = FFI::MemoryPointer.from_string('test_service')
-
-p handle = DdeCreateStringHandle(id, service, CP_WINANSI)
-
-p DdeNameService(id, handle, 0, DNS_REGISTER)
-
-#p DdeDisconnect(conv_handle)
-
-msg = Msg.new  # pointer to Msg FFI struct
-
-# Starting message loop (necessary for DDE processing)
-puts "Starting message loop\n"
-while msg = get_message()
-  translate_message(msg)
-  dispatch_message(msg)
-end
-
-p calls.map{|c| c.map{|e|e.respond_to?(:address) ? e.address : (Win::DDE::TYPES[e] || e)}}
-
-p Win::DDE::ERRORS[DdeGetLastError(id)]
+# Quick and dirty DDE Server (for experimentation)
+
+require 'win/gui/message'
+include Win::GUI::Message
+
+#require_relative 'exp_lib'
+#include DdeLib
+
+require 'win/dde'
+include Win::Dde
+
+calls = []
+buffer = FFI::MemoryPointer.new(:long).write_long(0)
+buffer.address
+
+callback = lambda do |*args|
+  calls << [*args]
+  puts "#{Time.now.strftime('%T.%6N')} #{args.map{|e|e.respond_to?(:address) ? e.address : (Win::Dde::TYPES[e] || e)}}"
+  args.first == XTYP_CONNECT ? 1 : DDE_FACK
+end
+
+status = DdeInitialize(buffer, callback, APPCLASS_STANDARD, 0)
+id = buffer.read_long
+
+service = FFI::MemoryPointer.from_string('test_service')
+
+p handle = DdeCreateStringHandle(id, service, CP_WINANSI)
+
+p DdeNameService(id, handle, 0, DNS_REGISTER)
+
+#p DdeDisconnect(conv_handle)
+
+msg = Msg.new  # pointer to Msg FFI struct
+
+# Starting message loop (necessary for DDE processing)
+puts "Starting message loop\n"
+while msg = get_message()
+  translate_message(msg)
+  dispatch_message(msg)
+end
+
+p calls.map{|c| c.map{|e|e.respond_to?(:address) ? e.address : (Win::Dde::TYPES[e] || e)}}
+
+p Win::Dde::ERRORS[DdeGetLastError(id)]

data/features/dde.feature

@@ -1,9 +1,9 @@
-Feature: something something
-  In order to something something
-  A user something something
-  something something something
-
-  Scenario: something something
-    Given inspiration
-    When I create a sweet new gem
-    Then everyone should see how awesome I am
+Feature: something something
+  In order to something something
+  A user something something
+  something something something
+
+  Scenario: something something
+    Given inspiration
+    When I create a sweet new gem
+    Then everyone should see how awesome I am

data/features/support/env.rb

@@ -1,4 +1,4 @@
-$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../../lib')
-require 'dde'
-
-require 'spec/expectations'
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../../lib')
+require 'dde'
+
+require 'spec/expectations'

data/lib/dde.rb

@@ -1,9 +1,9 @@
-# console output redirection (may need to wrap it in synchronization code, etc)
-require 'rubygems'
-require 'win/dde'
-require 'dde/dde_string'
-require 'dde/app'
-require 'dde/server'
-require 'dde/client'
-require 'dde/monitor'
-require 'dde/xl_server'
+# console output redirection (may need to wrap it in synchronization code, etc)
+require 'rubygems'
+require 'win/dde'
+require 'dde/dde_string'
+require 'dde/app'
+require 'dde/server'
+require 'dde/client'
+require 'dde/monitor'
+require 'dde/xl_server'

data/lib/dde/app.rb

@@ -1,92 +1,92 @@
-module DDE
-
-  module Errors                             # :nodoc:
-    def self.[](error_code)
-      Win::DDE::ERRORS[error_code]
-    end
-
-    class InitError < RuntimeError          # :nodoc:
-    end
-    class FormatError < RuntimeError        # :nodoc:
-    end
-    class StringError < RuntimeError        # :nodoc:
-    end
-    class ServiceError < RuntimeError        # :nodoc:
-    end
-    class ClientError < RuntimeError        # :nodoc:
-    end
-  end
-
-  # Class encapsulates DDE application. DDE::App serves as a base for more specific types,
-  # such as DDE::Server or DDE:: Client.
-  class App
-    include Win::DDE
-
-    attr_reader :id, :init_flags
-
-    # Creates new DDE application (and starts DDE instance if dde_callback block is attached)
-    def initialize( init_flags=nil, &dde_callback )
-      @init_flags = init_flags
-
-      start_dde init_flags, &dde_callback if dde_callback
-
-    end
-#    # todo: Destructor to ensure Dde instance is uninitialized and string handles freed...
-#      ObjectSpace.define_finalizer( self, self.class.finalize))
-#    end
-#
-#    # need to have class method, otherwise proc traps reference to instance (self) and the object
-#    # is never garbage-collected (http://www.mikeperham.com/2010/02/24/the-trouble-with-ruby-finalizers/)
-#    def self.finalize()
-#      proc { stop_dde } #does NOT work since stop_dde is instance method (depends on self)
-#    end
-
-    # (Re)Initialize application with DDEML library, providing attached dde callback
-    # either preserved @init_flags or init_flags argument are used
-    def start_dde( init_flags=nil, &dde_callback )
-      @init_flags = init_flags || @init_flags || APPCLASS_STANDARD
-
-      try "Starting DDE" do
-        @id, status = dde_initialize @id, @init_flags, &dde_callback
-        error(status) unless @id && status == DMLERR_NO_ERROR
-      end
-    end
-
-    # (Re)Initialize application with DDEML library, providing attached dde callback
-    def stop_dde
-      try "Stopping DDE" do
-        error "DDE not started" unless dde_active?
-        error unless dde_uninitialize(@id)   # Uninitialize app with DDEML library
-        @id = nil                                 # Clear instance id if uninitialization successful
-      end
-    end
-
-    # Expects a block, yields to it inside a rescue block, raises given error_type with extended fail message.
-    # Returns self in case of success (to enable method chaining).
-    def try( action, error_type=DDE::Errors::InitError )
-      begin
-        yield
-      rescue => e
-        raise error_type, action + " failed with: #{e}"
-      end
-      self
-    end
-
-    # Raises Runtime error with message based on given message (DdeGetLastError message if no message given)
-    def error( message = nil )
-      raise case message
-        when Integer
-          DDE::Errors[message]
-        when nil
-          DDE::Errors[dde_get_last_error(@id)]
-        else
-          message
-      end
-    end
-
-    def dde_active?
-      !!@id
-    end
-
-  end
+module Dde
+
+  module Errors                             # :nodoc:
+    def self.[](error_code)
+      Win::Dde::ERRORS[error_code]
+    end
+
+    class InitError < RuntimeError          # :nodoc:
+    end
+    class FormatError < RuntimeError        # :nodoc:
+    end
+    class StringError < RuntimeError        # :nodoc:
+    end
+    class ServiceError < RuntimeError        # :nodoc:
+    end
+    class ClientError < RuntimeError        # :nodoc:
+    end
+  end
+
+  # Class encapsulates DDE application. Dde::App serves as a base for more specific types,
+  # such as Dde::Server or Dde:: Client.
+  class App
+    include Win::Dde
+
+    attr_reader :id, :init_flags
+
+    # Creates new DDE application (and starts DDE instance if dde_callback block is attached)
+    def initialize( init_flags=nil, &dde_callback )
+      @init_flags = init_flags
+
+      start_dde init_flags, &dde_callback if dde_callback
+
+    end
+#    # todo: Destructor to ensure Dde instance is uninitialized and string handles freed...
+#      ObjectSpace.define_finalizer( self, self.class.finalize))
+#    end
+#
+#    # need to have class method, otherwise proc traps reference to instance (self) and the object
+#    # is never garbage-collected (http://www.mikeperham.com/2010/02/24/the-trouble-with-ruby-finalizers/)
+#    def self.finalize()
+#      proc { stop_dde } #does NOT work since stop_dde is instance method (depends on self)
+#    end
+
+    # (Re)Initialize application with DDEML library, providing attached dde callback
+    # either preserved @init_flags or init_flags argument are used
+    def start_dde( init_flags=nil, &dde_callback )
+      @init_flags = init_flags || @init_flags || APPCLASS_STANDARD
+
+      try "Starting DDE" do
+        @id, status = dde_initialize @id, @init_flags, &dde_callback
+        error(status) unless @id && status == DMLERR_NO_ERROR
+      end
+    end
+
+    # (Re)Initialize application with DDEML library, providing attached dde callback
+    def stop_dde
+      try "Stopping DDE" do
+        error "DDE not started" unless dde_active?
+        error unless dde_uninitialize(@id)   # Uninitialize app with DDEML library
+        @id = nil                                 # Clear instance id if uninitialization successful
+      end
+    end
+
+    # Expects a block, yields to it inside a rescue block, raises given error_type with extended fail message.
+    # Returns self in case of success (to enable method chaining).
+    def try( action, error_type=Dde::Errors::InitError )
+      begin
+        yield
+      rescue => e
+        raise error_type, action + " failed with: #{e}"
+      end
+      self
+    end
+
+    # Raises Runtime error with message based on given message (DdeGetLastError message if no message given)
+    def error( message = nil )
+      raise case message
+        when Integer
+          Dde::Errors[message]
+        when nil
+          Dde::Errors[dde_get_last_error(@id)]
+        else
+          message
+      end
+    end
+
+    def dde_active?
+      !!@id
+    end
+
+  end
 end

data/lib/dde/client.rb

@@ -1,103 +1,103 @@
-module DDE
-
-  # Class encapsulates DDE Client that requests connection with DDE server and exchanges data with it via DDE
-  class Client < App
-
-    attr_reader :conversation, # active DDE conversation that client is engaged in
-                :service, #service that the client is connected to
-                :topic, # active DDE conversation topic
-                :item   # active DDE conversation item
-
-#    # Creates new DDE client instance
-#    def initialize(init_flags = nil, &dde_callback )
-#      super init_flags, &dde_callback
-#    end
-
-    # Establish a conversation with a server application that supports the specified service
-    # name and topic name pair.
-    def start_conversation( service=nil, topic=nil )
-      try "Starting conversation #{service} #{topic}", DDE::Errors::ClientError do
-        error "DDE is not initialized" unless dde_active?
-        error "Another conversation already established" if conversation_active?
-
-        # Create DDE strings for service and topic unless they are omitted
-        @service = DDE::DdeString.new(@id, service) if service
-        @topic = DDE::DdeString.new(@id, topic) if topic
-
-        # Initiate new DDE conversation, returns conversation handle or nil 
-        error unless @conversation = dde_connect(@id, @service.handle, @topic.handle)
-      end
-    end
-
-    # Stops active conversation, raises error if no conversations active
-    def stop_conversation
-      try "Stopping conversation", DDE::Errors::ClientError do
-        error "DDE not started" unless dde_active?
-        error "Conversation not started" unless conversation_active?
-
-        error unless dde_disconnect(@conversation) &&    # Stop DDE conversation
-        dde_free_string_handle(@id, @service.handle) &&  # Free string handles for service name
-        dde_free_string_handle(@id, @topic.handle)       # Free string handles for topic name
-
-        # Unset attributes for conversation, service and topic
-        @conversation = nil
-        @service = nil
-        @topic = nil
-      end
-    end
-
-    # Sends XTYP_POKE transaction to server if conversation was already established.
-    # data:: data being sent (will be coerced to String unless is already a (packed) String)
-    # format:: standard clipboard format of submitted data item (default CF_TEXT)
-    def send_data( data, format = CF_TEXT, item = "" )
-      data_pointer = FFI::MemoryPointer.from_string(data.to_s)
-      result, trans_id = start_transaction(XTYP_POKE, data_pointer, data_pointer.size, format, item)
-      result
-    end
-
-    # Initiates transaction to server if conversation was already established.
-    # transaction_type:: XTYP_ADVSTART, XTYP_ADVSTOP, XTYP_EXECUTE, XTYP_POKE, XTYP_REQUEST
-    # data_pointer:: pointer to data being sent (either FFI::MemoryPointer or DDE data_handle)
-    # cb:: data set size (or -1 to indicate that data_pointer is in fact DDE data_handle)
-    # format:: standard clipboard format of submitted data item (default CF_TEXT)
-    # item:: item to which transaction is related (String, DdeString or DDE string handle)
-    # timeout:: timeout in milliseconds or TIMEOUT_ASYNC to indicate async transaction
-    #
-    # *Returns*:: A pair of [result, trans_id]. Result is nil for failed transactions,
-    # DDE data handle for synchronous transactions in which the client expects data from the server,
-    # nonzero for successful transactions where clients does not expect data from server.
-    # Trans_id: for asynchronous transactions, a unique transaction identifier for use with the
-    # DdeAbandonTransaction function and the XTYP_XACT_COMPLETE transaction. For synchronous transactions,
-    # the low-order word of this variable contains any applicable DDE_ flags resulting from the transaction.
-    #
-    def start_transaction( transaction_type, data_pointer=nil, cb = data_pointer ? data_pointer.size : 0,
-            format=CF_TEXT, item=0, timeout=1000)
-
-      result = nil
-      trans_id = FFI::MemoryPointer.new(:uint32).put_uint32(0,0)
-
-      try "Sending data to server", DDE::Errors::ClientError do
-        error "DDE not started" unless dde_active?
-        error "Conversation not started" unless conversation_active?
-
-        item_handle = case item
-          when String
-            DDE::DdeString.new(@id, service).handle
-          when DdeString
-            item.handle
-          else
-            item
-        end
-
-        error unless result = dde_client_transaction(data_pointer, cb, @conversation, item_handle,
-                                                     format, transaction_type, timeout, trans_id)
-      end
-      [result, trans_id.get_uint32(0)]
-    end
-
-    def conversation_active?
-      !!@conversation
-    end
-
-  end
+module Dde
+
+  # Class encapsulates DDE Client that requests connection with DDE server and exchanges data with it via DDE
+  class Client < App
+
+    attr_reader :conversation, # active DDE conversation that client is engaged in
+                :service, #service that the client is connected to
+                :topic, # active DDE conversation topic
+                :item   # active DDE conversation item
+
+#    # Creates new DDE client instance
+#    def initialize(init_flags = nil, &dde_callback )
+#      super init_flags, &dde_callback
+#    end
+
+    # Establish a conversation with a server application that supports the specified service
+    # name and topic name pair.
+    def start_conversation( service=nil, topic=nil )
+      try "Starting conversation #{service} #{topic}", Dde::Errors::ClientError do
+        error "DDE is not initialized" unless dde_active?
+        error "Another conversation already established" if conversation_active?
+
+        # Create DDE strings for service and topic unless they are omitted
+        @service = Dde::DdeString.new(@id, service) if service
+        @topic = Dde::DdeString.new(@id, topic) if topic
+
+        # Initiate new DDE conversation, returns conversation handle or nil 
+        error unless @conversation = dde_connect(@id, @service.handle, @topic.handle)
+      end
+    end
+
+    # Stops active conversation, raises error if no conversations active
+    def stop_conversation
+      try "Stopping conversation", Dde::Errors::ClientError do
+        error "DDE not started" unless dde_active?
+        error "Conversation not started" unless conversation_active?
+
+        error unless dde_disconnect(@conversation) &&    # Stop DDE conversation
+        dde_free_string_handle(@id, @service.handle) &&  # Free string handles for service name
+        dde_free_string_handle(@id, @topic.handle)       # Free string handles for topic name
+
+        # Unset attributes for conversation, service and topic
+        @conversation = nil
+        @service = nil
+        @topic = nil
+      end
+    end
+
+    # Sends XTYP_POKE transaction to server if conversation was already established.
+    # data:: data being sent (will be coerced to String unless is already a (packed) String)
+    # format:: standard clipboard format of submitted data item (default CF_TEXT)
+    def send_data( data, format = CF_TEXT, item = "" )
+      data_pointer = FFI::MemoryPointer.from_string(data.to_s)
+      result, trans_id = start_transaction(XTYP_POKE, data_pointer, data_pointer.size, format, item)
+      result
+    end
+
+    # Initiates transaction to server if conversation was already established.
+    # transaction_type:: XTYP_ADVSTART, XTYP_ADVSTOP, XTYP_EXECUTE, XTYP_POKE, XTYP_REQUEST
+    # data_pointer:: pointer to data being sent (either FFI::MemoryPointer or DDE data_handle)
+    # cb:: data set size (or -1 to indicate that data_pointer is in fact DDE data_handle)
+    # format:: standard clipboard format of submitted data item (default CF_TEXT)
+    # item:: item to which transaction is related (String, DdeString or DDE string handle)
+    # timeout:: timeout in milliseconds or TIMEOUT_ASYNC to indicate async transaction
+    #
+    # *Returns*:: A pair of [result, trans_id]. Result is nil for failed transactions,
+    # DDE data handle for synchronous transactions in which the client expects data from the server,
+    # nonzero for successful transactions where clients does not expect data from server.
+    # Trans_id: for asynchronous transactions, a unique transaction identifier for use with the
+    # DdeAbandonTransaction function and the XTYP_XACT_COMPLETE transaction. For synchronous transactions,
+    # the low-order word of this variable contains any applicable DDE_ flags resulting from the transaction.
+    #
+    def start_transaction( transaction_type, data_pointer=nil, cb = data_pointer ? data_pointer.size : 0,
+            format=CF_TEXT, item=0, timeout=1000)
+
+      result = nil
+      trans_id = FFI::MemoryPointer.new(:uint32).put_uint32(0,0)
+
+      try "Sending data to server", Dde::Errors::ClientError do
+        error "DDE not started" unless dde_active?
+        error "Conversation not started" unless conversation_active?
+
+        item_handle = case item
+          when String
+            Dde::DdeString.new(@id, service).handle
+          when DdeString
+            item.handle
+          else
+            item
+        end
+
+        error unless result = dde_client_transaction(data_pointer, cb, @conversation, item_handle,
+                                                     format, transaction_type, timeout, trans_id)
+      end
+      [result, trans_id.get_uint32(0)]
+    end
+
+    def conversation_active?
+      !!@conversation
+    end
+
+  end
 end