dde 0.2.2 → 0.2.8

data/lib/dde/xl_server.rb

@@ -22,9 +22,90 @@ module DDE
       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, 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 to DDE data. Meaning of this parameter 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 Dynamic Data Exchange Management Library (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 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 == @service.handle
+              cout "Service #{@service}: connect requested by client\n"
+              1 # 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.
+
+            if @table.get_data(data) # Extract incoming DDE data from client into server's table
+              # Converting hsz1 into "[topic]item" string and
+              @table.topic = dde_query_string(@id, hsz1)
+              # @table.draw # Simply printing it for now, no queues
+              @table.timer
+              #                  // 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);
+              #
+              DDE_FACK  # Transaction successful
+            else
+              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
+
+          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
+    end
+
     # Make 'excel' the default name for named service
     alias_method :__start_service, :start_service
-    def start_service( name='excel', init_flags=nil, &dde_callback )
+
+    def start_service( name='excel', init_flags=nil, &dde_callback)
+      dde_callback ||= default_callback
       __start_service( name, init_flags, &dde_callback )
     end
 

data/lib/dde/xl_table.rb

@@ -1,11 +1,11 @@
 module DDE
   extend FFI::Library  # todo: < Array ?
-  class Conv < FFI::Union
-    layout( :w, :ushort, # word should be 2 bytes, not 8
-            :d, :double, # it is 8 bytes
-            :b, [:char, 8]) # it is 8 bytes
-  end
-
+#  class Conv < FFI::Union
+#    layout( :w, :ushort, # word should be 2 bytes, not 8
+#            :d, :double, # it is 8 bytes
+#            :b, [:char, 8]) # it is 8 bytes
+#  end
+#
 
   # XLTable class represents a single chunk of DDE data formatted as an Excel table
   class XlTable
@@ -32,21 +32,26 @@ module DDE
             TDT_TABLE => 'TDT_TABLE'
     }
 
-    attr_accessor :topic_item # topic_item
+    attr_accessor :topic, # topic prefix
+                  :time, # time spent parsing last transaction data
+                  :total_time, # total time spent parsing data
+                  :num_trans # number of data transactions
 
     def initialize
-      @table_data = []    # Array contains Arrays of Strings
+      @table = []    # Array contains Arrays of Strings
       @col = 0
       @row = 0
+      @total_time = 0
+      @total_records = 0
       # omitting separators for now
     end
 
     # tests if table data is empty or contains data in inconsistent state
     def empty?
-      @table_data.empty? ||
+      @table.empty? ||
               @row == 0 || @col == 0 ||
-              @row != @table_data.size ||
-              @col != @table_data.first.size  # assumes first element is also an Array
+              @row != @table.size ||
+              @col != @table.first.size  # assumes first element is also an Array
     end
 
     def data?;
@@ -55,118 +60,111 @@ module DDE
 
     def draw
       return false if empty?
-
+      Encoding.default_external = 'cp866'
       # omitting separator gymnastics for now
       cout "-----\n"
-      @table_data.each{|row| row.each {|col| cout col, " "}; cout "\n"}
+      @table.each{|row| cout @topic; row.each {|col| cout " #{col}"}; cout "\n"}
     end
 
     def get_data(dde_handle)
-#      conv = DDE::Conv.new  # Union for data conversion
+      start = Time.now
 
-      # Copy DDE data from dde_handle (FFI::MemoryPointer is returned)
-      return nil unless data = dde_get_data(dde_handle) # raise 'DDE data not extracted'
-      offset = 0
+      @offset = 0
+      @pos = 0 #; @c=0; @r=0
 
-      # Make sure that the first block is tdtTable
-      return nil unless data.get_int16(offset) == TDT_TABLE # raise 'DDE data not TDT_TABLE'
-      offset += 2
+      @data, size = dde_get_data(dde_handle)
+      return nil unless @data &&  # DDE data is present at given dde_handle
+      read_int == TDT_TABLE &&    # and, first data block is tdtTable
+      read_int == 4               # and, its length is 4 bytes
 
-      # Make sure cb == 4
-      return nil unless data.get_int16(offset) == 4 # raise 'TDT_TABLE data length wrong'
-      offset += 2
+      @row = read_int
+      @col = read_int
+      return nil unless @row != 0 && @col != 0  # Make sure nonzero row and col
 
-      @row = data.get_int16(offset)
-      @col = data.get_int16(offset+2)
-      offset += 4
-#p "row, col", @row, @col
+      @table = Array.new(@row){||Array.new}
 
-      # Make sure nonzero row and col
-      return nil if @row == 0 || @col == 0   # raise 'col or row zero in TDT_TABLE'
+      while @offset < @data.size
+        type = read_int         # Next data field(s) type
+        byte_size = read_int    # Next data field(s) length in bytes
 
-      @table_data = Array.new(@row){||Array.new}
-
-      r = 0
-      c = 0
-      while offset < data.size
-        type = data.get_int16(offset)   # Next data field(s) type
-        cb = data.get_int16(offset+2)   # Next data field(s) length in bytes
-        offset += 4
-
-#p "type #{TDT_TYPES[type]}, cb #{cb}, row #{r}, col #{c}"
+#p "type #{TDT_TYPES[type]}, cb #{byte_size}, row #{@pos/@col}, col #{@pos%@col}"
         case type
-          when TDT_FLOAT       # Float, 8 bytes per field
-            (cb/8).times do
-              @table_data[r][c] = data.get_float64(offset)
-              offset += 8
-              c += 1
-              if c == @col # end of row
-                c = 0
-                r += 1
-              end
-            end
-          when TDT_STRING
-            end_field = offset + cb
-            while offset < end_field do
-              length = data.get_int8(offset)
-              offset += 1
-               @table_data[r][c] = data.get_bytes(offset, length)
-              offset += length
-              c += 1
-              if c == @col # end of row
-                c = 0
-                r += 1
-              end
+          when TDT_STRING       # Strings, length byte followed by chars, no zero termination
+            field_end = @offset + byte_size
+            while @offset < field_end do
+              length = read_char
+              self.table = @data.get_bytes(@offset, length) #read_bytes(length)#.force_encoding('CP1251').encode('CP866')
+              @offset += length
             end
-          when TDT_BOOL        # Bool, 2 bytes per field
-            (cb/2).times do
-              @table_data[r][c] = data.get_int16(offset) == 0
-              offset += 2
-              c += 1
-              if c == @col # end of row
-                c = 0
-                r += 1
-              end
-            end
-          when TDT_ERROR        # Error enum, 2 bytes per field
-            (cb/2).times do
-              @table_data[r][c] = "Error:#{data.get_int16(offset)}"
-              offset += 2
-              c += 1
-              if c == @col # end of row
-                c = 0
-                r += 1
-              end
-            end
-          when TDT_BLANK        # Number of blank cells, 2 bytes per field
-            (cb/2).times do
-              blanks = data.get_int16(offset)
-              offset += 2
-              blanks.times do
-                @table_data[r][c] = ""
-                c += 1
-                if c == @col # end of row
-                  c = 0
-                  r += 1
-                end
-              end
-            end
-          when TDT_INT        # Int, 2 bytes per field
-            (cb/2).times do
-              @table_data[r][c] = data.get_int16(offset) == 0
-              offset += 2
-              c += 1
-              if c == @col # end of row
-                c = 0
-                r += 1
-              end
+          when TDT_FLOAT        # Float, 8 bytes (used to represent Integers too in Quik!)
+            (byte_size/8).times do
+#              self.table = read_double
+#            end
+              float_or_int = @data.get_float64(@offset)
+              @offset += 8
+              int = float_or_int.round
+              self.table = float_or_int == int ? int : float_or_int
             end
+          when TDT_BLANK        # Number of blank cells, 2 bytes
+            (byte_size/2).times { read_int.times { self.table = "" } }
+          when TDT_SKIP         # Number of cells to skip, 2 bytes - in Quik, it means that these cells contain 0
+            (byte_size/2).times { read_int.times { self.table = 0 } }
+          when TDT_INT          # Int, 2 bytes
+            (byte_size/2).times { self.table = read_int }
+          when TDT_BOOL         # Bool, 2 bytes 0/1
+            (byte_size/2).times { self.table = read_int == 0 }
+          when TDT_ERROR        # Error enum, 2 bytes
+            (byte_size/2).times { self.table = "Error:#{read_int}" }
           else
+            cout "Type: #{type}, #{TDT_TYPES[type]}"
             return nil
         end
       end
-#TODO:	free FFI::Pointer ?  delete []data;                          // Free memory
+#TODO:	free FFI::Pointer ?  delete []data;  // Free memory
+      @time = Time.now - start
+      @total_time += @time
+      @total_records += @row
       true      # Data acquisition successful
     end
+
+    def timer
+      cout "Last: #{@row} in #{@time} s(#{@time/@row} s/rec), total: #{@total_records} in  #{
+              @total_time} s(#{@total_time/@total_records} s/rec)\n"
+    end
+
+    def read_char
+      @offset += 1
+      @data.get_int8(@offset-1)
+    end
+
+    def read_int
+      @offset += 2
+      @data.get_int16(@offset-2)
+    end
+
+    def read_double
+      @offset += 8
+      @data.get_float64(@offset-8)
+    end
+
+    def read_bytes(length=1)
+      @offset += length
+      @data.get_bytes(@offset-length, length)
+    end
+
+    def table=(value)
+#      @table[@r][@c] = value
+#      todo: Add code for adding value to data row here (pack?)
+#      @c+=1
+#      if @c == @col
+#        @c =0
+#        @r+=1
+#      end
+#      todo: Add code for (sync!) publishing of assembled data row here (bunny? rosetta_queue?)     
+
+      @table[@pos/@col][@pos%@col] = value
+      @pos += 1
+    end
+
   end
 end

data/spec/dde/app_shared.rb

@@ -0,0 +1,85 @@
+module DDETest
+  shared_examples_for "DDE App" do
+    before(:each ){ @app = described_class.new }
+    after(:each ){ @app.stop_dde if @app.dde_active?}
+
+      it 'starts with nil id and flags if no arguments given' do
+        @app.id.should == nil
+        @app.init_flags.should == nil
+        @app.dde_active?.should == false
+      end unless described_class == DDE::Monitor
+
+      it 'starts DDE (initializes as STANDARD DDE app) with given callback block' do
+        @app = described_class.new {|*args|}
+        @app.id.should be_an Integer
+        @app.id.should_not == 0
+        @app.init_flags.should == APPCLASS_STANDARD
+        @app.dde_active?.should == true
+      end unless described_class == DDE::Monitor
+    
+    describe '#start_dde' do
+      it 'starts DDE with callback and default init_flags' do
+        res = @app.start_dde {|*args|}
+        res.should be_true
+        @app.id.should be_an Integer
+        @app.id.should_not == 0
+        @app.init_flags.should == APPCLASS_STANDARD
+        @app.dde_active?.should == true
+      end unless described_class == DDE::Monitor
+
+      it 'returns self if success (allows method chain)' do
+        @app.start_dde {|*args|}.should == @app
+      end
+
+      it 'starts DDE with callback and given init_flags' do
+        res = @app.start_dde( APPCLASS_STANDARD | CBF_FAIL_CONNECTIONS ){|*args|}
+        res.should be_true
+        @app.id.should be_an Integer
+        @app.id.should_not == 0
+        @app.init_flags.should == APPCLASS_STANDARD | CBF_FAIL_CONNECTIONS
+        @app.dde_active?.should == true
+      end
+
+      it 'raises InitError if no callback was given' do
+        lambda{ @app.start_dde}.should raise_error DDE::Errors::InitError
+      end
+
+      it 'reinitializes with new flags and callback if it was already initialized' do
+        @app.start_dde {|*args| 1}
+        old_id = @app.id
+        res = @app.start_dde( APPCLASS_STANDARD | CBF_FAIL_CONNECTIONS ){|*args| 2}
+        res.should be_true
+        @app.id.should == old_id
+        @app.init_flags.should == APPCLASS_STANDARD | CBF_FAIL_CONNECTIONS
+        @app.dde_active?.should == true
+      end
+    end
+
+    describe '#stop_dde' do
+      it 'stops DDE that was active' do
+        @app.start_dde {|*args| 1}
+
+        @app.stop_dde
+        @app.id.should == nil
+        @app.dde_active?.should == false
+      end
+
+      it 'preserves init_flags after DDE is stopped (for reinitialization)' do
+        @app.start_dde(APPCLASS_STANDARD | CBF_FAIL_CONNECTIONS) {|*args| 1}
+
+        @app.stop_dde
+        @app.init_flags.should == APPCLASS_STANDARD | CBF_FAIL_CONNECTIONS
+      end
+
+      it 'returns self if success (allows method chain)' do
+        @app.start_dde{|*args|}.stop_dde.should == @app
+      end
+
+      it 'raises InitError if dde was not active first' do
+        lambda{ @app.stop_dde}.should raise_error DDE::Errors::InitError
+      end
+    end unless described_class == DDE::Monitor
+
+
+  end
+end  

data/spec/dde/app_spec.rb

@@ -1,85 +1,9 @@
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require File.expand_path(File.dirname(__FILE__) + '/app_shared')
 
 module DDETest
   describe DDE::App do
-    before(:each ){ @app = DDE::App.new }
-
-    it 'starts with nil id and flags if no arguments given' do
-      @app.id.should == nil
-      @app.init_flags.should == nil
-      @app.dde_active?.should == false
-    end
-
-    it 'starts DDE (initializes as STANDARD DDE app) with given callback block' do
-      app = DDE::App.new {|*args|}
-      app.id.should be_an Integer
-      app.id.should_not == 0
-      app.init_flags.should == APPCLASS_STANDARD
-      app.dde_active?.should == true
-    end
-
-    describe '#start_dde' do
-      it 'starts DDE with callback and default init_flags' do
-        res = @app.start_dde {|*args|}
-        res.should be_true
-        @app.id.should be_an Integer
-        @app.id.should_not == 0
-        @app.init_flags.should == APPCLASS_STANDARD
-        @app.dde_active?.should == true
-      end
-
-      it 'returns self if success (allows method chain)' do
-        @app.start_dde {|*args|}.should == @app
-      end
-
-      it 'starts DDE with callback and given init_flags' do
-        res = @app.start_dde( APPCLASS_STANDARD | CBF_FAIL_CONNECTIONS ){|*args|}
-        res.should be_true
-        @app.id.should be_an Integer
-        @app.id.should_not == 0
-        @app.init_flags.should == APPCLASS_STANDARD | CBF_FAIL_CONNECTIONS
-        @app.dde_active?.should == true
-      end
-
-      it 'raises InitError if no callback was given' do
-        lambda{ @app.start_dde}.should raise_error DDE::Errors::InitError
-      end
-
-      it 'reinitializes with new flags and callback if it was already initialized' do
-        @app.start_dde {|*args| 1}
-        old_id = @app.id
-        res = @app.start_dde( APPCLASS_STANDARD | CBF_FAIL_CONNECTIONS ){|*args| 2}
-        res.should be_true
-        @app.id.should == old_id
-        @app.init_flags.should == APPCLASS_STANDARD | CBF_FAIL_CONNECTIONS
-        @app.dde_active?.should == true
-      end
-    end
-
-    describe '#stop_dde' do
-      it 'stops DDE that was active' do
-        @app.start_dde {|*args| 1}
-
-        @app.stop_dde
-        @app.id.should == nil
-        @app.dde_active?.should == false
-      end
-
-      it 'preserves init_flags after DDE is stopped (for reinitialization)' do
-        @app.start_dde(APPCLASS_STANDARD | CBF_FAIL_CONNECTIONS) {|*args| 1}
-
-        @app.stop_dde
-        @app.init_flags.should == APPCLASS_STANDARD | CBF_FAIL_CONNECTIONS
-      end
-
-      it 'returns self if success (allows method chain)' do
-        @app.start_dde{|*args|}.stop_dde.should == @app
-      end
-
-      it 'raises InitError if dde was not active first' do
-        lambda{ @app.stop_dde}.should raise_error DDE::Errors::InitError
-      end
-    end
+    it_should_behave_like "DDE App"
 
   end
 end