dde 0.2.2

data/doc/ddeml.d.txt

@@ -0,0 +1,374 @@
+/***********************************************************************\
+*                                ddeml.d                                *
+*                                                                       *
+*                       Windows API header module                       *
+*                                                                       *
+*                 Translated from MinGW Windows headers                 *
+*                           by Stewart Gordon                           *
+*                                                                       *
+*                       Placed into public domain                       *
+\***********************************************************************/
+module win32.ddeml;
+pragma(lib, "user32.lib");
+
+private import win32.basetsd, win32.windef, win32.winnt;
+
+enum : int {
+	CP_WINANSI    = 1004,
+	CP_WINUNICODE = 1200
+}
+
+enum : UINT {
+	XTYPF_NOBLOCK = 2,
+	XTYPF_NODATA  = 4,
+	XTYPF_ACKREQ  = 8
+}
+
+enum : UINT {
+	XCLASS_MASK         = 0xFC00,
+	XCLASS_BOOL         = 0x1000,
+	XCLASS_DATA         = 0x2000,
+	XCLASS_FLAGS        = 0x4000,
+	XCLASS_NOTIFICATION = 0x8000
+}
+
+enum : UINT {
+	XST_NULL,
+	XST_INCOMPLETE,
+	XST_CONNECTED,
+	XST_INIT1,
+	XST_INIT2,
+	XST_REQSENT,
+	XST_DATARCVD,
+	XST_POKESENT,
+	XST_POKEACKRCVD,
+	XST_EXECSENT,
+	XST_EXECACKRCVD,
+	XST_ADVSENT,
+	XST_UNADVSENT,
+	XST_ADVACKRCVD,
+	XST_UNADVACKRCVD,
+	XST_ADVDATASENT,
+	XST_ADVDATAACKRCVD // = 16
+}
+
+enum : UINT {
+	XTYP_ERROR           = XCLASS_NOTIFICATION | XTYPF_NOBLOCK,
+	XTYP_ADVDATA         = 0x0010 | XCLASS_FLAGS,
+	XTYP_ADVREQ          = 0x0020 | XCLASS_DATA | XTYPF_NOBLOCK,
+	XTYP_ADVSTART        = 0x0030 | XCLASS_BOOL,
+	XTYP_ADVSTOP         = 0x0040 | XCLASS_NOTIFICATION,
+	XTYP_EXECUTE         = 0x0050 | XCLASS_FLAGS,
+	XTYP_CONNECT         = 0x0060 | XCLASS_BOOL | XTYPF_NOBLOCK,
+	XTYP_CONNECT_CONFIRM = 0x0070 | XCLASS_NOTIFICATION | XTYPF_NOBLOCK,
+	XTYP_XACT_COMPLETE   = 0x0080 | XCLASS_NOTIFICATION,
+	XTYP_POKE            = 0x0090 | XCLASS_FLAGS,
+	XTYP_REGISTER        = 0x00A0 | XCLASS_NOTIFICATION | XTYPF_NOBLOCK,
+	XTYP_REQUEST         = 0x00B0 | XCLASS_DATA,
+	XTYP_DISCONNECT      = 0x00C0 | XCLASS_NOTIFICATION | XTYPF_NOBLOCK,
+	XTYP_UNREGISTER      = 0x00D0 | XCLASS_NOTIFICATION | XTYPF_NOBLOCK,
+	XTYP_WILDCONNECT     = 0x00E0 | XCLASS_DATA | XTYPF_NOBLOCK,
+	XTYP_MONITOR         = 0X00F0 | XCLASS_NOTIFICATION | XTYPF_NOBLOCK,
+	XTYP_MASK            = 0x00F0,
+	XTYP_SHIFT           = 4
+}
+
+/+
+#define TIMEOUT_ASYNC  0xFFFFFFFF
+#define QID_SYNC       0xFFFFFFFF
++/
+
+enum : UINT {
+	ST_CONNECTED  =   1,
+	ST_ADVISE     =   2,
+	ST_ISLOCAL    =   4,
+	ST_BLOCKED    =   8,
+	ST_CLIENT     =  16,
+	ST_TERMINATED =  32,
+	ST_INLIST     =  64,
+	ST_BLOCKNEXT  = 128,
+	ST_ISSELF     = 256
+}
+
+/+
+#define CADV_LATEACK 0xFFFF
++/
+
+enum : UINT {
+	DMLERR_NO_ERROR      = 0,
+	DMLERR_FIRST         = 0x4000,
+	DMLERR_ADVACKTIMEOUT = DMLERR_FIRST,
+	DMLERR_BUSY,
+	DMLERR_DATAACKTIMEOUT,
+	DMLERR_DLL_NOT_INITIALIZED,
+	DMLERR_DLL_USAGE,
+	DMLERR_EXECACKTIMEOUT,
+	DMLERR_INVALIDPARAMETER,
+	DMLERR_LOW_MEMORY,
+	DMLERR_MEMORY_ERROR,
+	DMLERR_NOTPROCESSED,
+	DMLERR_NO_CONV_ESTABLISHED,
+	DMLERR_POKEACKTIMEOUT,
+	DMLERR_POSTMSG_FAILED,
+	DMLERR_REENTRANCY,
+	DMLERR_SERVER_DIED,
+	DMLERR_SYS_ERROR,
+	DMLERR_UNADVACKTIMEOUT,
+	DMLERR_UNFOUND_QUEUE_ID, // = 0x4011
+	DMLERR_LAST          = DMLERR_UNFOUND_QUEUE_ID
+}
+
+/+
+#define DDE_FACK	0x8000
+#define DDE_FBUSY	0x4000
+#define DDE_FDEFERUPD	0x4000
+#define DDE_FACKREQ	0x8000
+#define DDE_FRELEASE	0x2000
+#define DDE_FREQUESTED	0x1000
+#define DDE_FAPPSTATUS	0x00ff
+#define DDE_FNOTPROCESSED	0
+#define DDE_FACKRESERVED	(~(DDE_FACK|DDE_FBUSY|DDE_FAPPSTATUS))
+#define DDE_FADVRESERVED	(~(DDE_FACKREQ|DDE_FDEFERUPD))
+#define DDE_FDATRESERVED	(~(DDE_FACKREQ|DDE_FRELEASE|DDE_FREQUESTED))
+#define DDE_FPOKRESERVED	(~DDE_FRELEASE)
+#define MSGF_DDEMGR	0x8001
+#define CBR_BLOCK	((HDDEDATA)0xffffffff)
++/
+
+const DWORD
+	APPCLASS_STANDARD         = 0,
+	APPCLASS_MONITOR          = 0x00000001,
+	APPCLASS_MASK             = 0x0000000F,
+	APPCMD_CLIENTONLY         = 0x00000010,
+	APPCMD_FILTERINITS        = 0x00000020,
+	APPCMD_MASK               = 0x00000FF0,
+	CBF_FAIL_SELFCONNECTIONS  = 0x00001000,
+	CBF_FAIL_CONNECTIONS      = 0x00002000,
+	CBF_FAIL_ADVISES          = 0x00004000,
+	CBF_FAIL_EXECUTES         = 0x00008000,
+	CBF_FAIL_POKES            = 0x00010000,
+	CBF_FAIL_REQUESTS         = 0x00020000,
+	CBF_FAIL_ALLSVRXACTIONS   = 0x0003f000,
+	CBF_SKIP_CONNECT_CONFIRMS = 0x00040000,
+	CBF_SKIP_REGISTRATIONS    = 0x00080000,
+	CBF_SKIP_UNREGISTRATIONS  = 0x00100000,
+	CBF_SKIP_DISCONNECTS      = 0x00200000,
+	CBF_SKIP_ALLNOTIFICATIONS = 0x003c0000,
+	MF_HSZ_INFO               = 0x01000000,
+	MF_SENDMSGS               = 0x02000000,
+	MF_POSTMSGS               = 0x04000000,
+	MF_CALLBACKS              = 0x08000000,
+	MF_ERRORS                 = 0x10000000,
+	MF_LINKS                  = 0x20000000,
+	MF_CONV                   = 0x40000000,
+	MF_MASK                   = 0xFF000000;
+
+enum : UINT {
+	EC_ENABLEALL    = 0,
+	EC_ENABLEONE    = ST_BLOCKNEXT,
+	EC_DISABLE      = ST_BLOCKED,
+	EC_QUERYWAITING = 2
+}
+
+enum : UINT {
+	DNS_REGISTER   = 1,
+	DNS_UNREGISTER = 2,
+	DNS_FILTERON   = 4,
+	DNS_FILTEROFF  = 8
+}
+
+/+
+#define HDATA_APPOWNED	1
+#define MAX_MONITORS	4
++/
+
+enum : int {
+	MH_CREATE  = 1,
+	MH_KEEP    = 2,
+	MH_DELETE  = 3,
+	MH_CLEANUP = 4
+}
+
+alias HANDLE HCONVLIST, HCONV, HSZ, HDDEDATA;
+
+extern (Windows) alias HDDEDATA
+  function(UINT, UINT, HCONV, HSZ, HSZ, HDDEDATA, DWORD, DWORD) PFNCALLBACK;
+
+struct HSZPAIR {
+	HSZ hszSvc;
+	HSZ hszTopic;
+}
+alias HSZPAIR* PHSZPAIR;
+
+struct CONVCONTEXT {
+	UINT                        cb = CONVCONTEXT.sizeof;
+	UINT                        wFlags;
+	UINT                        wCountryID;
+	int                         iCodePage;
+	DWORD                       dwLangID;
+	DWORD                       dwSecurity;
+	SECURITY_QUALITY_OF_SERVICE qos;
+}
+alias CONVCONTEXT* PCONVCONTEXT;
+
+struct CONVINFO {
+	DWORD       cb = CONVINFO.sizeof;
+	DWORD       hUser;
+	HCONV       hConvPartner;
+	HSZ         hszSvcPartner;
+	HSZ         hszServiceReq;
+	HSZ         hszTopic;
+	HSZ         hszItem;
+	UINT        wFmt;
+	UINT        wType;
+	UINT        wStatus;
+	UINT        wConvst;
+	UINT        wLastError;
+	HCONVLIST   hConvList;
+	CONVCONTEXT ConvCtxt;
+	HWND        hwnd;
+	HWND        hwndPartner;
+}
+alias CONVINFO* PCONVINFO;
+
+struct DDEML_MSG_HOOK_DATA {
+	UINT     uiLo;
+	UINT     uiHi;
+	DWORD    cbData;
+	DWORD[8] Data;
+}
+
+struct MONHSZSTRUCT {
+	UINT     cb = MONHSZSTRUCT.sizeof;
+	int      fsAction;
+	DWORD    dwTime;
+	HSZ      hsz;
+	HANDLE   hTask;
+	TCHAR[1] _str;
+
+	TCHAR* str() { return _str.ptr; }
+}
+alias MONHSZSTRUCT* PMONHSZSTRUCT;
+
+struct MONLINKSTRUCT {
+	UINT   cb = MONLINKSTRUCT.sizeof;
+	DWORD  dwTime;
+	HANDLE hTask;
+	BOOL   fEstablished;
+	BOOL   fNoData;
+	HSZ    hszSvc;
+	HSZ    hszTopic;
+	HSZ    hszItem;
+	UINT   wFmt;
+	BOOL   fServer;
+	HCONV  hConvServer;
+	HCONV  hConvClient;
+}
+alias MONLINKSTRUCT* PMONLINKSTRUCT;
+
+struct MONCONVSTRUCT {
+	UINT   cb = MONCONVSTRUCT.sizeof;
+	BOOL   fConnect;
+	DWORD  dwTime;
+	HANDLE hTask;
+	HSZ    hszSvc;
+	HSZ    hszTopic;
+	HCONV  hConvClient;
+	HCONV  hConvServer;
+}
+alias MONCONVSTRUCT* PMONCONVSTRUCT;
+
+struct MONCBSTRUCT {
+	UINT        cb = MONCBSTRUCT.sizeof;
+	DWORD       dwTime;
+	HANDLE      hTask;
+	DWORD       dwRet;
+	UINT        wType;
+	UINT        wFmt;
+	HCONV       hConv;
+	HSZ         hsz1;
+	HSZ         hsz2;
+	HDDEDATA    hData;
+	ULONG_PTR   dwData1;
+	ULONG_PTR   dwData2;
+	CONVCONTEXT cc;
+	DWORD       cbData;
+	DWORD[8]    Data;
+}
+alias MONCBSTRUCT* PMONCBSTRUCT;
+
+struct MONERRSTRUCT {
+	UINT   cb = MONERRSTRUCT.sizeof;
+	UINT   wLastError;
+	DWORD  dwTime;
+	HANDLE hTask;
+}
+alias MONERRSTRUCT* PMONERRSTRUCT;
+
+struct MONMSGSTRUCT {
+	UINT   cb = MONMSGSTRUCT.sizeof;
+	HWND   hwndTo;
+	DWORD  dwTime;
+	HANDLE hTask;
+	UINT   wMsg;
+	WPARAM wParam;
+	LPARAM lParam;
+	DDEML_MSG_HOOK_DATA dmhd;
+}
+alias MONMSGSTRUCT* PMONMSGSTRUCT;
+
+extern (Windows) {
+	BOOL DdeAbandonTransaction(DWORD, HCONV, DWORD);
+	PBYTE DdeAccessData(HDDEDATA, PDWORD);
+	HDDEDATA DdeAddData(HDDEDATA, PBYTE, DWORD, DWORD);
+	HDDEDATA DdeClientTransaction(PBYTE, DWORD, HCONV, HSZ, UINT, UINT,
+	  DWORD, PDWORD);
+	int DdeCmpStringHandles(HSZ, HSZ);
+	HCONV DdeConnect(DWORD, HSZ, HSZ, PCONVCONTEXT);
+	HCONVLIST DdeConnectList(DWORD, HSZ, HSZ, HCONVLIST, PCONVCONTEXT);
+	HDDEDATA DdeCreateDataHandle(DWORD, PBYTE, DWORD, DWORD, HSZ, UINT,
+	  UINT);
+	HSZ DdeCreateStringHandleA(DWORD, LPSTR, int);
+	HSZ DdeCreateStringHandleW(DWORD, LPWSTR, int);
+	BOOL DdeDisconnect(HCONV);
+	BOOL DdeDisconnectList(HCONVLIST);
+	BOOL DdeEnableCallback(DWORD, HCONV, UINT);
+	BOOL DdeFreeDataHandle(HDDEDATA);
+	BOOL DdeFreeStringHandle(DWORD, HSZ);
+	DWORD DdeGetData(HDDEDATA, PBYTE, DWORD, DWORD);
+	UINT DdeGetLastError(DWORD);
+	BOOL DdeImpersonateClient(HCONV);
+	UINT DdeInitializeA(PDWORD, PFNCALLBACK, DWORD, DWORD);
+	UINT DdeInitializeW(PDWORD, PFNCALLBACK, DWORD, DWORD);
+	BOOL DdeKeepStringHandle(DWORD, HSZ);
+	HDDEDATA DdeNameService(DWORD, HSZ, HSZ, UINT);
+	BOOL DdePostAdvise(DWORD, HSZ, HSZ);
+	UINT DdeQueryConvInfo(HCONV, DWORD, PCONVINFO);
+	HCONV DdeQueryNextServer(HCONVLIST, HCONV);
+	DWORD DdeQueryStringA(DWORD, HSZ, LPSTR, DWORD, int);
+	DWORD DdeQueryStringW(DWORD, HSZ, LPWSTR, DWORD, int);
+	HCONV DdeReconnect(HCONV);
+	BOOL DdeSetUserHandle(HCONV, DWORD, DWORD);
+	BOOL DdeUnaccessData(HDDEDATA);
+	BOOL DdeUninitialize(DWORD);
+}
+
+const TCHAR[]
+	SZDDESYS_TOPIC         = "System",
+	SZDDESYS_ITEM_TOPICS   = "Topics",
+	SZDDESYS_ITEM_SYSITEMS = "SysItems",
+	SZDDESYS_ITEM_RTNMSG   = "ReturnMessage",
+	SZDDESYS_ITEM_STATUS   = "Status",
+	SZDDESYS_ITEM_FORMATS  = "Formats",
+	SZDDESYS_ITEM_HELP     = "Help",
+	SZDDE_ITEM_ITEMLIST    = "TopicItemList";
+
+version (Unicode) {
+	alias DdeCreateStringHandleW DdeCreateStringHandle;
+	alias DdeInitializeW DdeInitialize;
+	alias DdeQueryStringW DdeQueryString;
+} else {
+	alias DdeCreateStringHandleA DdeCreateStringHandle;
+	alias DdeInitializeA DdeInitialize;
+	alias DdeQueryStringA DdeQueryString;
+}

data/doc/types.txt

@@ -0,0 +1,159 @@
+== Parameters ( win32-api )
+Long:     'L'
+Integer:  'I'
+Pointer:  'P'
+Void:     'V'
+String:   'S'
+Callback: 'K' # win32-api only
+
+== Windows Data Types
+BOOL  		=> 'I' (or 'B', win32-api only)
+DWORD 		=> 'L'
+HANDLE		=> 'L'
+LPDWORD		=> 'P' (or 'L')
+LPTSTR 		=> 'P'
+LPCTSTR     => 'S'
+UINT  		=> 'L'
+VOID        => 'V'
+WORD        => 'I'
+LPVOID      => 'L' (or 'P')
+CALLBACK    => 'K'
+
+== C Data Types
+void     	=> 'V'
+void*    	=> 'P'
+char*    	=> 'P'
+const char* => 'L'
+int			=> 'I'
+long        => 'L'
+struct      => 'P'
+struct*     => 'P'
+
+== Notes
+In practice most LPVOID types should be designated as 'L' because this
+usually means the function is looking for an address. Check the documentation
+for details.
+
+If using the windows-api library, you can use 'B' instead of 'I' for the return
+type for functions that return a BOOL.
+
+===== Definitions from windows-api (api.rb)
+      # Verbose data types that can be used instead of single letters
+      DATA_TYPES = {
+         'ATOM'         => 'I',
+         'BOOL'         => 'B',
+         'BOOLEAN'      => 'B',
+         'BYTE'         => 'I',
+         'CALLBACK'     => 'K',
+         'CHAR'         => 'I',
+         'COLORREF'     => 'L',
+         'DWORD'        => 'L',
+         'DWORDLONG'    => 'L',
+         'DWORD_PTR'    => 'P',
+         'DWORD32'      => 'I',
+         'DWORD64'      => 'L',
+         'HACCEL'       => 'L',
+         'HANDLE'       => 'L',
+         'HBITMAP'      => 'L',
+         'HBRUSH'       => 'L',
+         'HCOLORSPACE'  => 'L',
+         'HCONV'        => 'L',
+         'HDC'          => 'L',
+         'HFILE'        => 'I',
+         'HKEY'         => 'L',
+         'HFONT'        => 'L',
+         'HINSTANCE'    => 'L',
+         'HKEY'         => 'L',
+         'HLOCAL'       => 'L',
+         'HMENU'        => 'L',
+         'HMODULE'      => 'L',
+         'HRESULT'      => 'L',
+         'HWND'         => 'L',
+         'INT'          => 'I',
+         'INT_PTR'      => 'P',
+         'INT32'        => 'I',
+         'INT64'        => 'L',
+         'LANGID'       => 'I',
+         'LCID'         => 'L',
+         'LCTYPE'       => 'L',
+         'LONG'         => 'L',
+         'LONGLONG'     => 'L',
+         'LONG_PTR'     => 'P',
+         'LONG32'       => 'L',
+         'LONG64'       => 'L',
+         'LPARAM'       => 'P',
+         'LPBOOL'       => 'P',
+         'LPBYTE'       => 'P',
+         'LPCOLORREF'   => 'P',
+         'LPCSTR'       => 'P',
+         'LPCTSTR'      => 'P',
+         'LPCVOID'      => 'L',
+         'LPCWSTR'      => 'P',
+         'LPDWORD'      => 'P',
+         'LPHANDLE'     => 'P',
+         'LPINT'        => 'P',
+         'LPLONG'       => 'P',
+         'LPSTR'        => 'P',
+         'LPTSTR'       => 'P',
+         'LPVOID'       => 'L',
+         'LPWORD'       => 'P',
+         'LPWSTR'       => 'P',
+         'LRESULT'      => 'P',
+         'PBOOL'        => 'P',
+         'PBOOLEAN'     => 'P',
+         'PBYTE'        => 'P',
+         'PHKEY'        => 'P',
+         'SC_HANDLE'    => 'L',
+         'SC_LOCK'      => 'L',
+         'SERVICE_STATUS_HANDLE' => 'L',
+         'SHORT'        => 'I',
+         'SIZE_T'       => 'P',
+         'TCHAR'        => 'L',
+         'UINT'         => 'I',
+         'UINT_PTR'     => 'P',
+         'UINT32'       => 'I',
+         'UINT64'       => 'L',
+         'ULONG'        => 'L',
+         'ULONGLONG'    => 'L',
+         'ULONG_PTR'    => 'P',
+         'ULONG32'      => 'L',
+         'ULONG64'      => 'L',
+         'USHORT'       => 'I',
+         'USN'          => 'L',
+         'WINAPI'       => 'L',
+         'WORD'         => 'I'
+      }
+
+Win::Library shortcuts (Mostly in line with Array#pack)
+    TYPES = {
+            V: :void, # For functions that return nothing (return type void).
+            v: :void, # For functions that return nothing (return type void).
+            C: :uchar, #– 8-bit unsigned character (byte)
+            c: :char, # 8-bit character (byte)
+            # :int8 – 8-bit signed integer
+            # :uint8 – 8-bit unsigned integer
+            S: :ushort, # – 16-bit unsigned integer (Win32API: used for string)
+            s: :short, # – 16-bit signed integer
+            # :uint16 – 16-bit unsigned integer
+            # :int16 – 16-bit signed integer
+            I: :uint, # 32-bit unsigned integer
+            i: :int, # 32-bit signed integer
+            # :uint32 – 32-bit unsigned integer
+            # :int32 – 32-bit signed integer
+            L: :ulong, # unsigned long int – platform-specific size
+            l: :long, # long int – platform-specific size (http://groups.google.com/group/ruby-ffi/browse_thread/thread/4762fc77130339b1)
+            # :int64 – 64-bit signed integer
+            # :uint64 – 64-bit unsigned integer
+            # :long_long – 64-bit signed integer
+            # :ulong_long – 64-bit unsigned integer
+            F: :float, # 32-bit floating point
+            D: :double, # 64-bit floating point (double-precision)
+            P: :pointer, # pointer – platform-specific size
+            p: :string, # C-style (NULL-terminated) character string (Win32API: S)
+            B: :bool # (?? 1 byte in C++)
+#For function argument type only:
+# :buffer_in – Similar to :pointer, but optimized for Buffers that the function can only read (not write).
+# :buffer_out – Similar to :pointer, but optimized for Buffers that the function can only write (not read).
+# :buffer_inout – Similar to :pointer, but may be optimized for Buffers.
+# :varargs – Variable arguments
+    }

data/features/dde.feature

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

data/features/support/env.rb

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

data/lib/dde/app.rb

@@ -0,0 +1,85 @@
+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
+
+      # todo: Destructor to ensure Dde instance is uninitialized and string handles freed (is it even working?)
+      #ObjectSpace.define_finalizer self, ->(id) { stop_dde }
+    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 unless @id && 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

@@ -0,0 +1,53 @@
+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
+
+    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
+
+    def conversation_active?
+      !!@conversation
+    end
+
+  end
+end