dde 0.2.2 → 0.2.8

data/Rakefile

@@ -10,7 +10,7 @@ begin
     gem.email = "arvitallian@gmail.com"
     gem.homepage = "http://github.com/arvicco/dde"
     gem.authors = ["arvicco"]
-    gem.add_dependency "win_gui", ">= 0.1.0"
+    gem.add_dependency "win", ">= 0.1.26"
     gem.add_development_dependency "rspec", ">= 1.2.9"
     gem.add_development_dependency "cucumber", ">= 0"
     gem.files.reject! { |fn| fn.include? "misc" }

data/VERSION

@@ -1 +1 @@
-0.2.2
+0.2.8

data/bin/dde_main

@@ -4,103 +4,21 @@ lib = File.join(File.dirname(__FILE__), '..', 'lib')
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include? lib
 
 require 'dde'
+require 'win/gui/message'
+
+include Win::DDE
+include Win::GUI::Message
 
 # console output redirection (may need to wrap it in synchronization code, etc)
 def cout *args
   print *args
 end
 
-cout "Starting script\n"
-
-require 'win/gui/message'
-
-include Win::GUI::Message
-include Win::DDE
-
-server = DDE::XlServer.new  # create server
-
 # std::queue<XlTable> q;				// Queue contains the tables to output
 
-#  HDDEDATA CALLBACK DdeCallback(UINT uType, UINT uFmt, HCONV hConv, HSZ hsz1, HSZ hsz2,
-#                                      HDDEDATA hData, DWORD dwData1, DWORD dwData2)
-
-dde_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
-      #             hsz1:: Handle to the topic name.
-      #             hsz2:: Handle to the service name.
-      #             dwData1:: Pointer to a CONVCONTEXT structure that contains context information for the conversation.
-      #                       If the client is not a Dynamic Data Exchange Management Library (DDEML) application,
-      #                       this parameter is 0.
-      #             dwData2:: Specifies whether the client is the same application instance as the server. If the
-      #                       parameter is 1, the client is the same instance. If the parameter is 0, the client
-      #                       is a different instance.
-      #             *Returns*:: A server callback function should return TRUE(1) 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(1)
-      #                         and a conversation is successfully established, the system passes the conversation
-      #              todo:      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 == server.service.handle
-        1 # instead of true     # Yes, this server supports requested (name) handle
-      else
-        cout "Unable to process connection request for #{hsz2}, service handle is #{server.service}\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.
-      #
-      #              # CHAR buf[200];
-
-      flag = server.table.get_data(data_handle) # extract client's DDE data into server's xltable
-      if flag
-        # Converting hsz1 into "[topic]item" string and
-        server.table.topic_item = dde_query_string(server.id, hsz1)
-        server.table.draw # Simply printing it for now, no queues
-        #                  // Placing table into print queue
-        #                  WaitForSingleObject(hMutex1,INFINITE);
-        #                      q.push(server.xltable);
-        #                  ReleaseMutex(hMutex1);
-        #                  // Allowing the table output thread to start...
-        #                  ReleaseSemaphore(hSemaphore,1,NULL);
-        #
-        cout "Transaction finished"
-        DDE_FACK  # Transaction successful
-      else
-        cout "Unable to receive dataprocess connection request for #{hsz2}, server handle is #{server.handle}\n"
-        DDE_FNOTPROCESSED   # 0 Transaction NOT successful - return (HDDEDATA)TRUE; ?!(why TRUE, not FALSE)
-      end
-
-    when XTYP_DISCONNECT # DDE client disconnects
-      #              server.xltable.Delete();
-      #              break;
-      DDE_FNOTPROCESSED   # 0 - return((HDDEDATA)NULL);// is it the same as 0 ?!
-
-    when XTYP_ERROR # DDE Error
-      #              WaitForSingleObject(hMutex, INFINITE);
-      #                  std::cerr<<"DDE error.\n";
-      #              ReleaseMutex(hMutex);
-      #              break;
-      DDE_FNOTPROCESSED   # 0 - return((HDDEDATA)NULL);// is it the same as 0 ?!
-
-    else
-      DDE_FNOTPROCESSED   # 0 - return((HDDEDATA)NULL);// is it the same as 0 ?!
-  end
-end
-
-# Staring service with default name 'excel'
-cout "Starting DDE service 'excel'\n"
-server.start_service &dde_callback
+# Creating DDE server and staring service with default name 'excel' and default callback
+cout "Starting DDE server with service 'excel'\n"
+server = DDE::XlServer.new.start_service
 
 msg = Msg.new  # pointer to Msg FFI struct
 

data/dde.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{dde}
-  s.version = "0.2.2"
+  s.version = "0.2.8"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["arvicco"]
-  s.date = %q{2010-02-26}
+  s.date = %q{2010-03-17}
   s.default_executable = %q{dde_main}
   s.description = %q{Server that mimics Excel receiving XLTable data via DDE protocol}
   s.email = %q{arvitallian@gmail.com}
@@ -31,8 +31,11 @@ Gem::Specification.new do |s|
      "doc/dde_formats.doc",
      "doc/ddeml.d.txt",
      "doc/types.txt",
-     "doc/~$Table_format.doc",
-     "doc/~$e_formats.doc",
+     "exp/exp_client.rb",
+     "exp/exp_dde_monitor.rb",
+     "exp/exp_dde_server.rb",
+     "exp/exp_lib.rb",
+     "exp/exp_server.rb",
      "features/dde.feature",
      "features/step_definitions/dde_steps.rb",
      "features/support/env.rb",
@@ -44,6 +47,7 @@ Gem::Specification.new do |s|
      "lib/dde/server.rb",
      "lib/dde/xl_server.rb",
      "lib/dde/xl_table.rb",
+     "spec/dde/app_shared.rb",
      "spec/dde/app_spec.rb",
      "spec/dde/client_spec.rb",
      "spec/dde/dde_string_spec.rb",
@@ -61,7 +65,8 @@ Gem::Specification.new do |s|
   s.rubygems_version = %q{1.3.5}
   s.summary = %q{DDE server for Ruby}
   s.test_files = [
-    "spec/dde/app_spec.rb",
+    "spec/dde/app_shared.rb",
+     "spec/dde/app_spec.rb",
      "spec/dde/client_spec.rb",
      "spec/dde/dde_string_spec.rb",
      "spec/dde/monitor_spec.rb",
@@ -77,16 +82,16 @@ Gem::Specification.new do |s|
     s.specification_version = 3
 
     if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<win_gui>, [">= 0.1.0"])
+      s.add_runtime_dependency(%q<win>, [">= 0.1.26"])
       s.add_development_dependency(%q<rspec>, [">= 1.2.9"])
       s.add_development_dependency(%q<cucumber>, [">= 0"])
     else
-      s.add_dependency(%q<win_gui>, [">= 0.1.0"])
+      s.add_dependency(%q<win>, [">= 0.1.26"])
       s.add_dependency(%q<rspec>, [">= 1.2.9"])
       s.add_dependency(%q<cucumber>, [">= 0"])
     end
   else
-    s.add_dependency(%q<win_gui>, [">= 0.1.0"])
+    s.add_dependency(%q<win>, [">= 0.1.26"])
     s.add_dependency(%q<rspec>, [">= 1.2.9"])
     s.add_dependency(%q<cucumber>, [">= 0"])
   end

data/exp/exp_client.rb

@@ -0,0 +1,44 @@
+# Quick and dirty DDE Client (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]
+  DDE_FACK
+end
+
+p status = DdeInitialize(buffer, callback, APPCLASS_STANDARD, 0)
+p id = buffer.read_long
+
+service = FFI::MemoryPointer.from_string('test_service')
+
+p handle = DdeCreateStringHandle(id, service, CP_WINANSI)
+
+p conv_handle = DdeConnect(id, handle, handle, nil)
+
+str = FFI::MemoryPointer.from_string("Poke_string\n\x00\x00")
+
+p DdeClientTransaction(str, str.size, conv_handle, handle, CF_TEXT, XTYP_POKE, 1000, nil)
+p Win::DDE::ERRORS[DdeGetLastError(id)]
+p DdeClientTransaction(str, str.size, conv_handle, handle, CF_TEXT, XTYP_EXECUTE, 1000, nil)
+p Win::DDE::ERRORS[DdeGetLastError(id)]
+sleep 0.01
+p DdeClientTransaction(str, str.size, conv_handle, handle, CF_TEXT, XTYP_EXECUTE, TIMEOUT_ASYNC, nil)
+p Win::DDE::ERRORS[DdeGetLastError(id)]
+
+p DdeDisconnect(conv_handle)
+
+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/exp/exp_dde_monitor.rb

@@ -0,0 +1,18 @@
+# Objective DDE Server (for experimentation)
+
+require 'win/gui/message'
+include Win::GUI::Message
+
+require 'dde'
+include Win::DDE
+
+calls = []
+$monitor = DDE::Monitor.new
+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

data/exp/exp_dde_server.rb

@@ -0,0 +1,36 @@
+# Objective DDE Server (for experimentation)
+
+require 'win/gui/message'
+include Win::GUI::Message
+
+require 'dde'
+include Win::DDE
+
+calls = []
+@server = DDE::Server.new do |*args|
+  calls << extract_values(*args)  #[Win::DDE::TYPES[args.shift]]+args; 1}
+  puts "#{Time.now.strftime('%T.%6N')} #{extract_values(*args)}"
+  args.first == XTYP_CONNECT ? 1 : DDE_FACK
+end
+sleep 0.05
+@server.start_service('test_service')
+
+def extract_values(type, format, conv, hsz1, hsz2, data, data1, data2)
+  [Win::DDE::TYPES[type], format, conv,
+   dde_query_string(@server.id, hsz1),
+   dde_query_string(@server.id, hsz2),
+   data, data1, data2]
+end
+
+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(@server.id)]

data/exp/exp_lib.rb

@@ -0,0 +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
+

data/exp/exp_server.rb

@@ -0,0 +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)]

data/lib/dde.rb

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

data/lib/dde/app.rb

@@ -24,16 +24,22 @@ module DDE
 
     attr_reader :id, :init_flags
 
-    # Creates new DDE application and starts DDE instance
-    # if dde_callback block is attached
+    # 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
 
-      # todo: Destructor to ensure Dde instance is uninitialized and string handles freed (is it even working?)
-      #ObjectSpace.define_finalizer self, ->(id) { stop_dde }
     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
@@ -49,7 +55,8 @@ module DDE
     # (Re)Initialize application with DDEML library, providing attached dde callback
     def stop_dde
       try "Stopping DDE" do
-        error unless @id && dde_uninitialize(@id) # Uninitialize app with DDEML library
+        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

data/lib/dde/monitor.rb

@@ -3,6 +3,8 @@ 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, &callback)
       init_flags ||=
@@ -15,12 +17,77 @@ module DDE
               MF_POSTMSGS      |  # monitor posted DDE messages
               MF_SENDMSGS         # monitor sent DDE messages
 
+      @calls = []
+
       callback ||= lambda do |*args|
-        p args.unshift(Win::DDE::TYPES[args.shift]).push(Win::DDE::FLAGS[args.pop])
-        1
+        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