dde 0.2.9 → 0.2.11

data/lib/dde/dde_string.rb

@@ -1,33 +1,33 @@
-module DDE
-
-  # Class encapsulates DDE string. In addition to normal string behavior,
-  # it also has *handle* that can be passed to dde functions
-  class DdeString < String
-    include Win::DDE
-
-    attr_accessor :handle, # string handle passable to DDEML functions
-                  :instance_id, # instance id of DDE app that created this DdeString
-                  :code_page, # Windows code page for this string (CP_WINANSI or CP_WINUNICODE)
-                  :name # ORIGINAL string used to create this DdeString
-
-    # Given the DDE application instance_id, you cane create DdeStrings
-    # either from regular string or from known DdeString handle
-    def initialize(instance_id, string_or_handle, code_page=CP_WINANSI)
-      @instance_id = instance_id
-      @code_page = code_page
-
-      begin
-        if string_or_handle.is_a? String
-          @name = string_or_handle
-          error unless @handle = dde_create_string_handle(@instance_id, @name, @code_page)
-        else
-          @handle = string_or_handle
-          error unless @name = dde_query_string(@instance_id, @handle, @code_page)
-        end
-      rescue => e
-      end
-      raise DDE::Errors::StringError, "Failed to initialize DDE string: #{e} #{e.backtrace.join("\n")}" unless @handle && @name && !e
-      super @name
-    end
-  end
+module Dde
+
+  # Class encapsulates DDE string. In addition to normal string behavior,
+  # it also has *handle* that can be passed to dde functions
+  class DdeString < String
+    include Win::Dde
+
+    attr_accessor :handle, # string handle passable to DDEML functions
+                  :instance_id, # instance id of DDE app that created this DdeString
+                  :code_page, # Windows code page for this string (CP_WINANSI or CP_WINUNICODE)
+                  :name # ORIGINAL string used to create this DdeString
+
+    # Given the DDE application instance_id, you cane create DdeStrings
+    # either from regular string or from known DdeString handle
+    def initialize(instance_id, string_or_handle, code_page=CP_WINANSI)
+      @instance_id = instance_id
+      @code_page = code_page
+
+      begin
+        if string_or_handle.is_a? String
+          @name = string_or_handle
+          error unless @handle = dde_create_string_handle(@instance_id, @name, @code_page)
+        else
+          @handle = string_or_handle
+          error unless @name = dde_query_string(@instance_id, @handle, @code_page)
+        end
+      rescue => e
+      end
+      raise Dde::Errors::StringError, "Failed to initialize DDE string: #{e} #{e.backtrace.join("\n")}" unless @handle && @name && !e
+      super @name
+    end
+  end
 end

data/lib/dde/monitor.rb

@@ -1,94 +1,94 @@
-module DDE
-
-  # Class encapsulates DDE Monitor that prints all DDE transactions to console
-  class Monitor < App
-
-    attr_accessor :print, :calls
-
-    # Creates new DDE monitor instance
-    def initialize(init_flags=nil, print = nil, &callback)
-      init_flags ||=
-              APPCLASS_MONITOR |  # this is monitor
-              MF_CALLBACKS     |  # monitor callback functions
-              MF_CONV          |  # monitor conversation data
-              MF_ERRORS        |  # monitor DDEML errors
-              MF_HSZ_INFO      |  # monitor data handle activity
-              MF_LINKS         |  # monitor advise loops
-              MF_POSTMSGS      |  # monitor posted DDE messages
-              MF_SENDMSGS         # monitor sent DDE messages
-
-      @print = print
-      @calls = []
-
-      callback ||= lambda do |*args|
-        time = Time.now.strftime('%T.%6N')
-        values = extract_values(*args)
-        @calls << [time, values]
-        puts "#{time} #{values}" if @print
-        DDE_FACK
-      end
-
-      super init_flags, &callback
-    end
-
-    def extract_values(*args)
-      values = args.map {|arg| interprete_value(arg)}
-
-      # if this is a MONITOR transaction, extract hdata using the DdeAccessData
-      if values.first == :XTYP_MONITOR
-        data_type = case values.last
-          when :MF_CALLBACKS
-            MonCbStruct #.new(dde_get_data(args[5]).first)
-          # cb:: Specifies the structure's size, in bytes.
-          # dwTime:: Specifies the Windows time at which the transaction occurred. Windows time is the number of
-          #          milliseconds that have elapsed since the system was booted.
-          # hTask:: Handle to the task (app instance) containing the DDE callback function that received the transaction.
-          # dwRet:: Specifies the value returned by the DDE callback function that processed the transaction.
-          # wType:: Specifies the transaction type.
-          # wFmt:: Specifies the format of the data exchanged (if any) during the transaction.
-          # hConv:: Handle to the conversation in which the transaction took place.
-          # hsz1:: Handle to a string.
-          # hsz2:: Handle to a string.
-          # hData:: Handle to the data exchanged (if any) during the transaction.
-          # dwData1:: Specifies additional data.
-          # dwData2:: Specifies additional data.
-          # cc:: Specifies a CONVCONTEXT structure containing language information used to share data in different languages.
-          # cbData:: Specifies the amount, in bytes, of data being passed with the transaction. This value can be
-          #          more than 32 bytes.
-          # Data:: Contains the first 32 bytes of data being passed with the transaction (8 * sizeof(DWORD)).
-
-          when :MF_CONV
-            MonConvStruct
-          when :MF_ERRORS
-            MonErrStruct
-          when :MF_HSZ_INFO
-            MonHszStruct
-          when :MF_LINKS
-            MonLinksStruct
-          else
-            MonMsgStruct
-        end
-
-        #casting DDE data pointer into appropriate struct type
-        struct_pointer, size = dde_get_data(args[5])
-        data = data_type.new(struct_pointer)
-
-        values = [values.first, values.last] + data.members.map do |member|
-          value = data[member] rescue 'plonk'
-          "#{member}: #{interprete_value(value)}"
-        end
-      end
-
-      values
-    end
-
-    def interprete_value(arg)
-      return arg unless arg.kind_of? Fixnum rescue return 'plAnk'
-      return 0 if arg == 0
-      #Trying to interpete arg as a DDE string
-      dde_query_string(@id, arg)\
-          || Win::DDE.constants(false).inject(nil) {|res, const| arg == Win::DDE.const_get(const) ? res || const : res }\
-          || arg
-    end
-  end
+module Dde
+
+  # Class encapsulates DDE Monitor that prints all DDE transactions to console
+  class Monitor < App
+
+    attr_accessor :print, :calls
+
+    # Creates new DDE monitor instance
+    def initialize(init_flags=nil, print = nil, &callback)
+      init_flags ||=
+              APPCLASS_MONITOR |  # this is monitor
+              MF_CALLBACKS     |  # monitor callback functions
+              MF_CONV          |  # monitor conversation data
+              MF_ERRORS        |  # monitor DDEML errors
+              MF_HSZ_INFO      |  # monitor data handle activity
+              MF_LINKS         |  # monitor advise loops
+              MF_POSTMSGS      |  # monitor posted DDE messages
+              MF_SENDMSGS         # monitor sent DDE messages
+
+      @print = print
+      @calls = []
+
+      callback ||= lambda do |*args|
+        time = Time.now.strftime('%T.%6N')
+        values = extract_values(*args)
+        @calls << [time, values]
+        puts "#{time} #{values}" if @print
+        DDE_FACK
+      end
+
+      super init_flags, &callback
+    end
+
+    def extract_values(*args)
+      values = args.map {|arg| interprete_value(arg)}
+
+      # if this is a MONITOR transaction, extract hdata using the DdeAccessData
+      if values.first == :XTYP_MONITOR
+        data_type = case values.last
+          when :MF_CALLBACKS
+            MonCbStruct #.new(dde_get_data(args[5]).first)
+          # cb:: Specifies the structure's size, in bytes.
+          # dwTime:: Specifies the Windows time at which the transaction occurred. Windows time is the number of
+          #          milliseconds that have elapsed since the system was booted.
+          # hTask:: Handle to the task (app instance) containing the DDE callback function that received the transaction.
+          # dwRet:: Specifies the value returned by the DDE callback function that processed the transaction.
+          # wType:: Specifies the transaction type.
+          # wFmt:: Specifies the format of the data exchanged (if any) during the transaction.
+          # hConv:: Handle to the conversation in which the transaction took place.
+          # hsz1:: Handle to a string.
+          # hsz2:: Handle to a string.
+          # hData:: Handle to the data exchanged (if any) during the transaction.
+          # dwData1:: Specifies additional data.
+          # dwData2:: Specifies additional data.
+          # cc:: Specifies a CONVCONTEXT structure containing language information used to share data in different languages.
+          # cbData:: Specifies the amount, in bytes, of data being passed with the transaction. This value can be
+          #          more than 32 bytes.
+          # Data:: Contains the first 32 bytes of data being passed with the transaction (8 * sizeof(DWORD)).
+
+          when :MF_CONV
+            MonConvStruct
+          when :MF_ERRORS
+            MonErrStruct
+          when :MF_HSZ_INFO
+            MonHszStruct
+          when :MF_LINKS
+            MonLinksStruct
+          else
+            MonMsgStruct
+        end
+
+        #casting DDE data pointer into appropriate struct type
+        struct_pointer, size = dde_get_data(args[5])
+        data = data_type.new(struct_pointer)
+
+        values = [values.first, values.last] + data.members.map do |member|
+          value = data[member] rescue 'plonk'
+          "#{member}: #{interprete_value(value)}"
+        end
+      end
+
+      values
+    end
+
+    def interprete_value(arg)
+      return arg unless arg.kind_of? Fixnum rescue return 'plAnk'
+      return 0 if arg == 0
+      #Trying to interpete arg as a DDE string
+      dde_query_string(@id, arg)\
+          || Win::Dde.constants(false).inject(nil) {|res, const| arg == Win::Dde.const_get(const) ? res || const : res }\
+          || arg
+    end
+  end
 end

data/lib/dde/server.rb

@@ -1,41 +1,41 @@
-module DDE
-
-  # Class encapsulates DDE Server with basic functionality (starting/stopping named service)
-  class Server < App
-
-    attr_reader :service # service(s) that this Server supports
-
-    def start_service( name, init_flags=nil, &dde_callback )
-      try "Starting service #{name}", DDE::Errors::ServiceError do
-        # Trying to start DDE if it was inactive
-        error unless dde_active? || start_dde( init_flags, &dde_callback )
-
-        # Create DDE string for name (this creates handle that can be passed to DDEML functions)
-        @service = DDE::DdeString.new(@id, name)
-
-        # Register new DDE service, returns true/false success code
-        error unless dde_name_service(@id, @service.handle, DNS_REGISTER)
-      end
-    end
-
-    def stop_service
-      try "Stopping active service", DDE::Errors::ServiceError do
-        error "Either DDE or service not initialized" unless dde_active? && service_active?
-
-        # Unregister DDE service, returns true/false success code
-        error unless dde_name_service(@id, @service.handle, DNS_UNREGISTER);
-
-        # Free string handle for service name
-        error unless dde_free_string_handle(@id, @service.handle)
-
-        # Clear handle if service successfuly stopped
-        @service = nil
-      end
-    end
-
-    def service_active?
-      !!@service
-    end
-
-  end
+module Dde
+
+  # Class encapsulates DDE Server with basic functionality (starting/stopping named service)
+  class Server < App
+
+    attr_reader :service # service(s) that this Server supports
+
+    def start_service( name, init_flags=nil, &dde_callback )
+      try "Starting service #{name}", Dde::Errors::ServiceError do
+        # Trying to start DDE if it was inactive
+        error unless dde_active? || start_dde( init_flags, &dde_callback )
+
+        # Create DDE string for name (this creates handle that can be passed to DDEML functions)
+        @service = Dde::DdeString.new(@id, name)
+
+        # Register new DDE service, returns true/false success code
+        error unless dde_name_service(@id, @service.handle, DNS_REGISTER)
+      end
+    end
+
+    def stop_service
+      try "Stopping active service", Dde::Errors::ServiceError do
+        error "Either DDE or service not initialized" unless dde_active? && service_active?
+
+        # Unregister DDE service, returns true/false success code
+        error unless dde_name_service(@id, @service.handle, DNS_UNREGISTER);
+
+        # Free string handle for service name
+        error unless dde_free_string_handle(@id, @service.handle)
+
+        # Clear handle if service successfuly stopped
+        @service = nil
+      end
+    end
+
+    def service_active?
+      !!@service
+    end
+
+  end
 end

data/lib/dde/xl_server.rb

@@ -1,90 +1,90 @@
-require 'dde/xl_table'
-
-module DDE
-
-  # Class encapsulates DDE Server mimicking Excel. It is used to create DDE server with specific service name
-  # (default name 'excel') and store data received by the server via DDE
-  class XlServer < Server
-
-    attr_reader :format, # data format(s) (registered clipboard formats) that server supports
-                :data    # data storage/processor
-
-    attr_accessor :actions # Actions to be run on table after each successful DDE input (:draw, :debug, :timer)
-
-    # Creates new Xl Server instance
-    def initialize(init_flags = nil, &dde_callback )
-
-      @data = DDE::XlTable.new
-
-      # Trying to register or retrieve existing format XlTable
-      try 'Registering format XlTable', DDE::Errors::FormatError do
-        @format = register_clipboard_format("XlTable")
-      end
-
-      super init_flags, &dde_callback
-    end
-
-    #  HDDEDATA CALLBACK DdeCallback(UINT uType, UINT uFmt, HCONV hConv, HSZ hsz1, HSZ hsz2,
-    #                                      HDDEDATA hData, DWORD dwData1, DWORD dwData2)
-    def default_callback
-      lambda do |type, format, conv, hsz1, hsz2, data_handle, data1, data2|
-        case type
-          when XTYP_CONNECT  # Request to connect from client, creating data exchange channel
-            #     format:: Not used.
-            #     conv:: Not used.
-            #     hsz1:: Handle to the topic name.
-            #     hsz2:: Handle to the service name.
-            #     data_handle:: Handle to DDE data. Meaning depends on the type of the current transaction.
-            #     data1:: Pointer to a CONVCONTEXT structure that contains context information for the conversation.
-            #             If the client is not a DDEML application, this parameter is 0.
-            #     data2:: Specifies whether the client is the same application instance as the server. If the parameter
-            #             is 1, the client is the same instance. If it is 0, the client is a different instance.
-            #     *Returns*:: A server callback function should return TRUE(1, but DDE_FACK works just fine too)
-            #                 to allow the client to establish a conversation on the specified service name and topic
-            #                 name pair, or the function should return FALSE to deny the conversation. If the callback
-            #                 function returns TRUE and a conversation is successfully established, the system passes
-            #                 the conversation handle to the server by issuing an XTYP_CONNECT_CONFIRM transaction to
-            #                 the server's callback function (unless the server specified the CBF_SKIP_CONNECT_CONFIRMS
-            #                 flag in the DdeInitialize function).
-
-            if hsz2 == @service.handle
-              cout "Service #{@service}: connect requested by client\n"
-              DDE_FACK # instead of true     # Yes, this server supports requested (name) handle
-            else
-              cout "Service #{@service} unable to process connection request for #{hsz2}\n"
-              DDE_FNOTPROCESSED # 0 instead of false    # No, server does not support requested (name) handle
-            end
-
-          when XTYP_POKE  # Client initiated XTYP_POKE transaction to push unsolicited data to the server
-            #     format:: Specifies the format of the data sent from the server.
-            #     conv:: Handle to the conversation.
-            #     hsz1:: Handle to the topic name. (Excel: [topic]item ?!)
-            #     hsz2:: Handle to the item name.
-            #     data_handle:: Handle to the data that the client is sending to the server.
-            #     *Returns*:: A server callback function should return the DDE_FACK flag if it processes this
-            #                 transaction, the DDE_FBUSY flag if it is too busy to process this transaction,
-            #                 or the DDE_FNOTPROCESSED flag if it rejects this transaction.
-
-            @data.topic = dde_query_string(@id, hsz1)  # Convert hsz1 into "[topic]item" string and
-            if @data.receive(data_handle)              # Receive incoming DDE data and process it
-
-              # Perform actions like :draw, :debug, :timer, :formats on received data (default :timer)
-              @actions.each{|action| @data.send(action.to_sym)}
-              DDE_FACK  # Transaction successful
-            else
-              @data.debug
-              cout "Service #{@service} unable to process data request (XTYP_POKE) for #{hsz2}"
-              DDE_FNOTPROCESSED   # 0 Transaction NOT successful - return (HDDEDATA)TRUE; ?!(why TRUE, not FALSE)
-            end
-          else
-            DDE_FNOTPROCESSED   # 0 - return((HDDEDATA)NULL);// is it the same as 0 ?!
-        end
-      end
-    end
-
-    def start_service( name='excel', init_flags=nil, &dde_callback)
-      super name, init_flags, &dde_callback || default_callback
-    end
-
-  end
+require 'dde/xl_table'
+
+module Dde
+
+  # Class encapsulates DDE Server mimicking Excel. It is used to create DDE server with specific service name
+  # (default name 'excel') and store data received by the server via DDE
+  class XlServer < Server
+
+    attr_reader :format, # data format(s) (registered clipboard formats) that server supports
+                :data    # data storage/processor
+
+    attr_accessor :actions # Actions to be run on table after each successful DDE input (:draw, :debug, :timer)
+
+    # Creates new Xl Server instance
+    def initialize(init_flags = nil, &dde_callback )
+
+      @data = Dde::XlTable.new
+
+      # Trying to register or retrieve existing format XlTable
+      try 'Registering format XlTable', Dde::Errors::FormatError do
+        @format = register_clipboard_format("XlTable")
+      end
+
+      super init_flags, &dde_callback
+    end
+
+    #  HDDEDATA CALLBACK DdeCallback(UINT uType, UINT uFmt, HCONV hConv, HSZ hsz1, HSZ hsz2,
+    #                                      HDDEDATA hData, DWORD dwData1, DWORD dwData2)
+    def default_callback
+      lambda do |type, format, conv, hsz1, hsz2, data_handle, data1, data2|
+        case type
+          when XTYP_CONNECT  # Request to connect from client, creating data exchange channel
+            #     format:: Not used.
+            #     conv:: Not used.
+            #     hsz1:: Handle to the topic name.
+            #     hsz2:: Handle to the service name.
+            #     data_handle:: Handle to DDE data. Meaning depends on the type of the current transaction.
+            #     data1:: Pointer to a CONVCONTEXT structure that contains context information for the conversation.
+            #             If the client is not a DDEML application, this parameter is 0.
+            #     data2:: Specifies whether the client is the same application instance as the server. If the parameter
+            #             is 1, the client is the same instance. If it is 0, the client is a different instance.
+            #     *Returns*:: A server callback function should return TRUE(1, but DDE_FACK works just fine too)
+            #                 to allow the client to establish a conversation on the specified service name and topic
+            #                 name pair, or the function should return FALSE to deny the conversation. If the callback
+            #                 function returns TRUE and a conversation is successfully established, the system passes
+            #                 the conversation handle to the server by issuing an XTYP_CONNECT_CONFIRM transaction to
+            #                 the server's callback function (unless the server specified the CBF_SKIP_CONNECT_CONFIRMS
+            #                 flag in the DdeInitialize function).
+
+            if hsz2 == @service.handle
+              cout "Service #{@service}: connect requested by client\n"
+              DDE_FACK # instead of true     # Yes, this server supports requested (name) handle
+            else
+              cout "Service #{@service} unable to process connection request for #{hsz2}\n"
+              DDE_FNOTPROCESSED # 0 instead of false    # No, server does not support requested (name) handle
+            end
+
+          when XTYP_POKE  # Client initiated XTYP_POKE transaction to push unsolicited data to the server
+            #     format:: Specifies the format of the data sent from the server.
+            #     conv:: Handle to the conversation.
+            #     hsz1:: Handle to the topic name. (Excel: [topic]item ?!)
+            #     hsz2:: Handle to the item name.
+            #     data_handle:: Handle to the data that the client is sending to the server.
+            #     *Returns*:: A server callback function should return the DDE_FACK flag if it processes this
+            #                 transaction, the DDE_FBUSY flag if it is too busy to process this transaction,
+            #                 or the DDE_FNOTPROCESSED flag if it rejects this transaction.
+
+            @data.topic = dde_query_string(@id, hsz1)  # Convert hsz1 into "[topic]item" string and
+            if @data.receive(data_handle)              # Receive incoming DDE data and process it
+
+              # Perform actions like :draw, :debug, :timer, :formats on received data (default :timer)
+              @actions.each{|action| @data.send(action.to_sym)}
+              DDE_FACK  # Transaction successful
+            else
+              @data.debug
+              cout "Service #{@service} unable to process data request (XTYP_POKE) for #{hsz2}"
+              DDE_FNOTPROCESSED   # 0 Transaction NOT successful - return (HDDEDATA)TRUE; ?!(why TRUE, not FALSE)
+            end
+          else
+            DDE_FNOTPROCESSED   # 0 - return((HDDEDATA)NULL);// is it the same as 0 ?!
+        end
+      end
+    end
+
+    def start_service( name='excel', init_flags=nil, &dde_callback)
+      super name, init_flags, &dde_callback || default_callback
+    end
+
+  end
 end