home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1998 May / Pcwk5b98.iso / Borland / Cplus45 / BC45 / OWL1.PAK / OWL1ALL.H < prev    next >
C/C++ Source or Header  |  1995-08-29  |  95KB  |  2,827 lines
  1. // ObjectWindows 1.0 portability
  2. // (C) Copyright 1995 by Borland International
  3.  
  4. #if !defined(__OWL1ALL_H)
  5. #define __OWL1ALL_H
  6.  
  7. #if defined(_CLASSDLL) || defined(__DLL__)
  8. #  define _RTLDLL
  9. #endif
  10.  
  11. #if !defined(BI_OLDNAMES)
  12. #define BI_OLDNAMES
  13. #endif
  14.  
  15. #include <_defs.h>
  16. #include <typeinfo.h>
  17. #include <fstream.h>
  18. #include <iostream.h>
  19. #include <stdiostr.h>
  20. #include <strstrea.h>
  21. #include <cstring.h>
  22.  
  23. //
  24. // RTTI and DDVTs don't get along, so we need to disable RTTI
  25. // for OWL 1 code. This also means that we must disable exceptions.
  26. //
  27. #pragma option -RT-
  28. #pragma option -x-
  29.  
  30. #include <owlrc.h>
  31. #include <stddef.h>
  32. #include <object.h>
  33. #include <windows.h>
  34. #include <dir.h>
  35. #include <array.h>
  36. #include <strng.h>
  37. #include <stdlib.h>
  38. #include <dos.h>
  39.  
  40. #if         defined(BUILD_OWL)
  41.  
  42. #if         !defined(WIN31) || !defined(STRICT)
  43. #error   OWL must be built with WIN31 and STRICT defined.
  44. #endif
  45.  
  46. #if         defined(__COMPACT__)
  47. #error   OWL cannot be built in Compact model.
  48. #endif
  49.  
  50. #if         defined(__TINY__)
  51. #error   OWL cannot be built in Tiny model.
  52. #endif
  53.  
  54. #else   //  !defined(BUILD_OWL)
  55.  
  56. #if         !defined(WIN31) || !defined(STRICT)
  57. #error   OWL applications must be built with WIN31 and STRICT defined.
  58. #endif
  59.  
  60. #if         defined(__COMPACT__)
  61. #error   OWL applications cannot be built in Compact model.
  62. #endif
  63.  
  64. #if         defined(__TINY__)
  65. #error   OWL applications cannot be built in Tiny model.
  66. #endif
  67.  
  68. #endif  //  !defined(BUILD_OWL)
  69.  
  70. #if defined(_BUILDOWLDLL)
  71. #define _EXPOWLFUNC _export
  72. #else
  73. #define _EXPOWLFUNC
  74. #endif
  75.  
  76. #if defined(__cplusplus)
  77. typedef int       _FAR &        Rint;
  78. typedef int       _FAR *        Pint;
  79. typedef void       _FAR *        Pvoid;
  80. typedef void       _FAR * _FAR &    RPvoid;
  81. typedef char       _FAR *        Pchar;
  82. typedef const char _FAR *        PCchar;
  83. typedef const void _FAR *        PCvoid;
  84.  
  85. // windows 3.0-compatibility types
  86.  
  87. #if  defined(WIN30)
  88.  
  89. #define            _WIN30_API           1
  90.  
  91. typedef long                            LONG_30;
  92. typedef unsigned int                    WORD_30;
  93. typedef unsigned int                    WORD_30;
  94. typedef unsigned int                    HDC_30;
  95. typedef unsigned int                    HWND_30;
  96. typedef unsigned int                    HINSTANCE_30;
  97.  
  98. #endif
  99. #endif
  100.  
  101. /* Since some resource editors strip comments from header files, some
  102.    brief comments on the contents of owlrc.h are included here:
  103.  
  104.    The SD_ constants are used for the File Open, File Save, Input,
  105.    Search and Replace dialogs.
  106.  
  107.    ID_FNAME, ID_FPATH, ID_FLIST and ID_DLIST are used for TFileDialog.
  108.  
  109.    ID_PROMPT, ID_INPUT, ID_SEARCHTEXT, ID_CASESENSITIVE, ID_REPLACETEXT,
  110.    ID_REPLACEALL and ID_PROMPTONREPLACE are used by TSearchDialog.
  111.  
  112.    ID_EDITOR is used by TEditWindow.
  113.  
  114.    ID_MDICLIENT is the default id for TMDIClient and ID_FIRSTMDICHILD
  115.    is the id of the first MDI child created by a TMDIClient.
  116.  
  117.    Note that the ID_ constants defined in OWL are all greater than or
  118.    equal to ID_RESERVED. Any ID_ constants you use should be less than
  119.    ID_RESERVED.
  120.  
  121.    Note that the CM_ constants defined in OWL are all greater than or
  122.    equal to CM_RESERVED. Any CM_ constants you use should be less than
  123.    CM_RESERVED.
  124.  
  125. */
  126.  
  127. /* Constants for application messages */
  128. #define WM_FIRST        0x0000  /* 0x0000- 0x7FFF window messages */
  129. #define WM_INTERNAL     0x7F00  /* 0x7F00- 0x7FFF reserved for internal use */
  130. #define ID_FIRST        0x8000  /* 0x8000- 0x8FFF child id messages */
  131. #define ID_INTERNAL     0x8F00  /* 0x8F00- 0x8FFF reserved for internal use */
  132. #define NF_FIRST        0x9000  /* 0x9000- 0x9FFF notification messages */
  133. #define NF_INTERNAL     0x9F00  /* 0x9F00- 0x9FFF reserved for internal use */
  134. #define CM_FIRST        0xA000  /* 0xA000- 0xFFFF command messages */
  135. #define CM_INTERNAL     0xFF00  /* 0xFF00- 0xFFFF reserved for internal use */
  136. #define WM_COUNT     0x8000    /* num of window msgs */
  137. #define ID_COUNT     0x1000    /* num of child id msgs */
  138. #define NF_COUNT     0x1000    /* num of notification msgs */
  139. #define CM_COUNT     0x6000    /* num of command msgs */
  140.  
  141. #define WM_RESERVED             WM_INTERNAL - WM_FIRST
  142.  
  143. #define ID_RESERVED             ID_INTERNAL - ID_FIRST
  144. #define ID_FIRSTMDICHILD        ID_RESERVED + 1
  145. #define ID_MDICLIENT             ID_RESERVED + 2
  146.  
  147. #define CM_RESERVED             CM_INTERNAL - CM_FIRST
  148.  
  149.  
  150.   /* Bit masks for TWindowsObject Flags */
  151. #define WB_ALIAS              0x01
  152. #define WB_AUTOCREATE         0x02
  153. #define WB_FROMRESOURCE       0x04
  154. #define WB_KBHANDLER          0x08
  155. #define WB_MDICHILD           0x10
  156. #define WB_MDIFRAME           0x20
  157. #define WB_PREDEFINEDCLASS    0x40
  158. #define WB_TRANSFER           0x80
  159.  
  160.   /* Error conditions */
  161. #define EM_INVALIDCHILD         -1
  162. #define EM_INVALIDCLIENT        -2
  163. #define EM_INVALIDMAINWINDOW    -3
  164. #define EM_INVALIDMODULE        -4
  165. #define EM_INVALIDWINDOW        -5
  166. #define EM_OUTOFMEMORY          -6
  167.  
  168.   /* Transfer function flags */
  169. #define TF_GETDATA               0
  170. #define TF_SETDATA               1
  171. #define TF_SIZEDATA              2
  172.  
  173. /* Checkbox flags indicating check state */
  174. #define BF_CHECKED      0x1
  175. #define BF_GRAYED       0x2
  176. #define BF_UNCHECKED    0x0
  177.  
  178. // define classes types for isA()
  179.  
  180. #define  moduleClass          (__firstOWLClass)
  181. #define  applicationClass     (moduleClass + 1)
  182. #define  scrollerClass        (applicationClass + 1)
  183. #define  windowClass          (scrollerClass + 1)
  184. #define  dialogClass          (windowClass + 1)
  185.  
  186. #if  defined(__DLL__)
  187. #  define _EXPORT _export
  188. #else
  189. #  define _EXPORT _CLASSTYPE
  190. #endif
  191.  
  192. const int DEFAULT_SAFETY_POOL_SIZE = 8192;
  193.  
  194. _CLASSDEF(SafetyPool)
  195.  
  196. class _EXPORT SafetyPool
  197. {
  198. public:
  199.     static  int            Allocate(size_t size
  200.                     = DEFAULT_SAFETY_POOL_SIZE);
  201.     static  int            IsExhausted()
  202.                   // returns true if safetyPool is exhausted
  203.                   { return safetyPool == NULL; };
  204.     static  int            Size;
  205.     static  Pvoid         safetyPool;
  206. };
  207.  
  208. enum Boolean { False, True };
  209.  
  210. typedef unsigned short ushort;
  211. typedef unsigned char uchar;
  212.  
  213. const char EOS = '\0';
  214.  
  215. typedef int ccIndex;
  216. typedef Boolean (_FAR *ccTestFunc)( Pvoid, Pvoid );
  217. typedef void (_FAR *ccAppFunc)( Pvoid, Pvoid );
  218.  
  219. const ccNotFound = -1;
  220. const maxCollectionSize = (int)((65536uL - 16)/sizeof( Pvoid ));
  221.  
  222. const TCOLLECTION_CLASS_HASH_VALUE = 0;
  223.  
  224. _CLASSDEF(TNSCollection)
  225. _CLASSDEF(TNSSortedCollection)
  226.  
  227. class _CLASSTYPE TNSCollection
  228. {
  229. public:
  230.  
  231.     TNSCollection( ccIndex aLimit, ccIndex aDelta );
  232.     ~TNSCollection();
  233.  
  234.     Pvoid at( ccIndex index );
  235.     virtual ccIndex indexOf( Pvoid item );
  236.  
  237.     void atFree( ccIndex index );
  238.     void atRemove( ccIndex index );
  239.     void remove( Pvoid item );
  240.     void removeAll();
  241.     void free( Pvoid item );
  242.     void freeAll();
  243.  
  244.     void atInsert( ccIndex index, Pvoid item );
  245.     void atPut( ccIndex index, Pvoid item );
  246.     virtual ccIndex insert( Pvoid item );
  247.  
  248.     static void error( ccIndex code, ccIndex info );
  249.  
  250.     Pvoid firstThat( ccTestFunc Test, Pvoid arg );
  251.     Pvoid lastThat( ccTestFunc Test, Pvoid arg );
  252.     void forEach( ccAppFunc action, Pvoid arg );
  253.  
  254.     void pack();
  255.     virtual void setLimit( ccIndex aLimit );
  256.  
  257.     ccIndex getCount()
  258.         { return count; }
  259.  
  260. protected:
  261.  
  262.     TNSCollection();
  263.  
  264.     Pvoid _FAR *items;
  265.     ccIndex count;
  266.     ccIndex limit;
  267.     ccIndex delta;
  268.     Boolean shouldDelete;
  269.  
  270. private:
  271.  
  272.     virtual void freeItem( Pvoid item );
  273. };
  274.  
  275. class _CLASSTYPE TNSSortedCollection: public virtual TNSCollection
  276. {
  277. public:
  278.  
  279.     TNSSortedCollection( ccIndex aLimit, ccIndex aDelta) :
  280.         TNSCollection( aLimit, aDelta )
  281.         { delta = aDelta; setLimit( aLimit ); }
  282.  
  283.     virtual Boolean search( Pvoid key, ccIndex _FAR & index );
  284.  
  285.     virtual ccIndex indexOf( Pvoid item );
  286.     virtual ccIndex insert( Pvoid item );
  287.  
  288.     Boolean duplicates;
  289.  
  290. protected:
  291.  
  292.     TNSSortedCollection() {};
  293.     virtual Pvoid keyOf( Pvoid item ) { return item; }
  294.  
  295. private:
  296.  
  297.     virtual int compare( Pvoid key1, Pvoid key2 ) = 0;
  298. };
  299.  
  300. #if !defined( __fLink_def )
  301. #define __fLink_def
  302. struct fLink
  303. {
  304.     fLink near *f;
  305.     class _CLASSTYPE TStreamableClass near *t;
  306. };
  307. #endif
  308.  
  309. #define __link( s )             \
  310.   extern TStreamableClass s;    \
  311.   static fLink force ## s =     \
  312.     { (fLink near *)&force ## s, (TStreamableClass near *)&s };
  313.  
  314. typedef unsigned P_id_type;
  315.  
  316. enum StreamableInit { streamableInit };
  317.  
  318. /* ------------------------------------------------------------------------*/
  319. /*                                                                         */
  320. /*   class TStreamable                                                     */
  321. /*                                                                         */
  322. /*   This is the base class for all storable objects.  It provides         */
  323. /*   three member functions, streamableName(), read(), and write(), which  */
  324. /*   must be overridden in every derived class.                            */
  325. /*                                                                         */
  326. /* ------------------------------------------------------------------------*/
  327.  
  328. _CLASSDEF(TStreamable)
  329. _CLASSDEF(TStreamableClass)
  330. _CLASSDEF(TStreamableTypes)
  331. _CLASSDEF(TPWrittenObjects)
  332. _CLASSDEF(TPWObj)
  333. _CLASSDEF(TPReadObjects)
  334. _CLASSDEF(pstream)
  335. _CLASSDEF(ipstream)
  336. _CLASSDEF(opstream)
  337. _CLASSDEF(iopstream)
  338. _CLASSDEF(fpbase)
  339. _CLASSDEF(ifpstream)
  340. _CLASSDEF(ofpstream)
  341. _CLASSDEF(fpstream)
  342.  
  343. class _CLASSTYPE TStreamable
  344. {
  345.  
  346.     friend class _CLASSTYPE opstream;
  347.     friend class _CLASSTYPE ipstream;
  348.  
  349. private:
  350.  
  351.     virtual const Pchar streamableName() const = 0;
  352.  
  353. protected:
  354.  
  355.     virtual Pvoid read(Ripstream) = 0;
  356.     virtual void write(Ropstream) = 0;
  357. };
  358.  
  359. /* ------------------------------------------------------------------------*/
  360. /*                                                                         */
  361. /*   class TStreamableClass                                                */
  362. /*                                                                         */
  363. /*   Used internally by TStreamableTypes and pstream.                      */
  364. /*                                                                         */
  365. /* ------------------------------------------------------------------------*/
  366.  
  367. typedef PTStreamable (_FAR *BUILDER)();
  368. #define __DELTA( d ) (FP_OFF((TStreamable *)(d *)1)-1)
  369.  
  370. class _CLASSTYPE TStreamableClass
  371. {
  372.     friend class _CLASSTYPE TStreamableTypes;
  373.     friend class _CLASSTYPE opstream;
  374.     friend class _CLASSTYPE ipstream;
  375.     friend class _CLASSTYPE TObjStrmRegRecord;
  376.  
  377. public:
  378.  
  379.     TStreamableClass( PCchar n, BUILDER b, int d );
  380.  
  381. protected:
  382.     PCchar name;
  383.     BUILDER build;
  384.     int delta;
  385. };
  386.  
  387. class _CLASSTYPE TObjStrmRegRecord
  388. {
  389.     friend class TStreamableClass;
  390. public:
  391.     TObjStrmRegRecord(PTStreamableClass pTStreamableClass);
  392.     int Validate();
  393.  
  394.     PTStreamableClass pTStreamableClass;
  395. private:
  396.     unsigned short SegmentLimit;
  397.     unsigned short Checksum;
  398.     Pvoid operator new (size_t s);
  399.     void operator delete(Pvoid ptr);
  400. };
  401.  
  402. /* ------------------------------------------------------------------------*/
  403. /*                                                                         */
  404. /*   class TStreamableTypes                                                */
  405. /*                                                                         */
  406. /*   Maintains a database of all registered types in the application.      */
  407. /*   Used by opstream and ipstream to find the functions to read and       */
  408. /*   write objects.                                                        */
  409. /*                                                                         */
  410. /* ------------------------------------------------------------------------*/
  411.  
  412. class _CLASSTYPE TStreamableTypes : private TNSSortedCollection
  413. {
  414.  
  415. public:
  416.  
  417.     TStreamableTypes() : TNSSortedCollection( 5, 5 )
  418.         {duplicates = True;}
  419.     ~TStreamableTypes() { shouldDelete = False; }
  420.  
  421. #if !defined(__DLL__)
  422.     void registerType( PCTStreamableClass d)
  423.         { insert( (void *)d ); }
  424. #else
  425.     void registerType(TObjStrmRegRecord *pTObjStrmRegRecord);
  426. #endif
  427.  
  428.     PCTStreamableClass lookup( PCchar );
  429.  
  430.     Pvoid operator new( size_t sz ) { return ::operator new( sz ); }
  431.     Pvoid operator new( size_t, Pvoid arena ) { return arena; }
  432.  
  433. protected:
  434.     virtual Boolean search( Pvoid key, ccIndex _FAR & index );
  435.  
  436. private:
  437.     virtual Pvoid keyOf(Pvoid d);
  438.     int compare( Pvoid, Pvoid );
  439. };
  440.  
  441.  
  442. /* ------------------------------------------------------------------------*/
  443. /*                                                                         */
  444. /*   class TPWObj                                                          */
  445. /*                                                                         */
  446. /*   Used internally by TPWrittenObjects.                                  */
  447. /*                                                                         */
  448. /* ------------------------------------------------------------------------*/
  449.  
  450. class _CLASSTYPE TPWObj
  451. {
  452.     
  453.     friend class _CLASSTYPE TPWrittenObjects;
  454.     friend class _CLASSTYPE TPReadObjects;
  455.     friend class _CLASSTYPE ipstream;
  456.     friend class _CLASSTYPE opstream;
  457.  
  458. private:
  459.  
  460.     TPWObj(PCvoid adr, P_id_type id ) : address( Pvoid(adr) ), ident( id ) {}
  461.  
  462.     Pvoid address;
  463.     P_id_type ident;
  464.  
  465. };
  466.  
  467. /* ------------------------------------------------------------------------*/
  468. /*                                                                         */
  469. /*   class TPWrittenObjects                                                */
  470. /*                                                                         */
  471. /*   Maintains a database of all objects that have been written to the     */
  472. /*   current object stream.                                                */
  473. /*                                                                         */
  474. /*   Used by opstream when it writes a pointer onto a stream to determine  */
  475. /*   whether the object pointed to has already been written to the stream. */
  476. /*                                                                         */
  477. /* ------------------------------------------------------------------------*/
  478.  
  479. class _CLASSTYPE TPWrittenObjects : public TNSSortedCollection
  480. {
  481.  
  482.     friend class _CLASSTYPE opstream;
  483.  
  484. public:
  485.  
  486.     void removeAll() { curId = 1; TNSSortedCollection::removeAll(); }
  487.  
  488. private:
  489.  
  490.     TPWrittenObjects() : TNSSortedCollection( 5, 5 ), curId( 1 ) {}
  491.     ~TPWrittenObjects() { shouldDelete = False; }
  492.  
  493.     void registerObject( PCvoid adr );
  494.     P_id_type find( PCvoid adr );
  495.  
  496.     Pvoid keyOf(Pvoid d) { return ((TPWObj *)d)->address; }
  497.     int compare( Pvoid, Pvoid );
  498.  
  499.     P_id_type curId;
  500.  
  501. };
  502.  
  503. /* ------------------------------------------------------------------------*/
  504. /*                                                                         */
  505. /*   class TPReadObjects                                                   */
  506. /*                                                                         */
  507. /*   Maintains a database of all objects that have been read from the      */
  508. /*   current persistent stream.                                            */
  509. /*                                                                         */
  510. /*   Used by ipstream when it reads a pointer from a stream to determine   */
  511. /*   the address of the object being referred to.                          */
  512. /*                                                                         */
  513. /* ------------------------------------------------------------------------*/
  514.  
  515. class _CLASSTYPE TPReadObjects : public TNSCollection
  516. {
  517.  
  518.     friend class _CLASSTYPE ipstream;
  519.  
  520. public:
  521.  
  522.     void removeAll() { curId = 1; TNSCollection::removeAll(); }
  523.  
  524. private:
  525.  
  526.     TPReadObjects() : TNSCollection( 5, 5 ), curId( 1 )
  527.         { insert( 0 ); }    // prime it, so we won't use index 0
  528.     ~TPReadObjects() { shouldDelete = False; }
  529.  
  530.     void registerObject( PCvoid adr );
  531.     PCvoid find( P_id_type id ) { return at( id ); }
  532.     P_id_type curId;
  533.  
  534. };
  535.  
  536. /* ------------------------------------------------------------------------*/
  537. /*                                                                         */
  538. /*   class pstream                                                         */
  539. /*                                                                         */
  540. /*   Base class for handling streamable objects.                           */
  541. /*                                                                         */
  542. /* ------------------------------------------------------------------------*/
  543.  
  544. class _CLASSTYPE pstream
  545. {
  546.  
  547.     friend class _CLASSTYPE TStreamableTypes;
  548.  
  549. public:
  550.  
  551.     enum StreamableError { peNotRegistered = 0x1000, peInvalidType = 0x2000 };
  552.     enum PointerTypes { ptNull, ptIndexed, ptObject };
  553.  
  554.     _Cdecl pstream( Pstreambuf sb ) { init( sb ); }
  555.     virtual _Cdecl ~pstream() {}
  556.  
  557.     int _Cdecl rdstate() const { return state; }
  558.     int _Cdecl eof() const { return state & ios::eofbit; }
  559.     int _Cdecl fail() const
  560.         { return state & (ios::failbit | ios::badbit | ios::hardfail); }
  561.     int _Cdecl bad() const { return state & (ios::badbit | ios::hardfail); }
  562.     int _Cdecl good() const { return state == 0; }
  563.  
  564.     void _Cdecl clear( int i = 0 )
  565.         { state = (i & 0xFF) | (state & ios::hardfail); }
  566.  
  567.     _Cdecl operator Pvoid() const { return fail() ? 0 : (void *)this; }
  568.     int _Cdecl operator ! () const { return fail(); }
  569.  
  570.     Pstreambuf _Cdecl rdbuf() const { return bp; }
  571.  
  572.     static void initTypes();
  573.     static PTStreamableTypes types;
  574.  
  575. protected:
  576.  
  577.     _Cdecl pstream() {}
  578.  
  579.     void _Cdecl error( StreamableError );
  580.     void _Cdecl error( StreamableError, RCTStreamable );
  581.  
  582.     Pstreambuf bp;
  583.     int state;
  584.     
  585.     void _Cdecl init( Pstreambuf sbp) { state = 0; bp = sbp; }
  586.     void _Cdecl setstate( int b) { state |= (b&0x00FF); }
  587. };
  588.  
  589. /* ------------------------------------------------------------------------*/
  590. /*                                                                         */
  591. /*   class ipstream                                                        */
  592. /*                                                                         */
  593. /*   Base class for reading streamable objects                             */
  594. /*                                                                         */
  595. /* ------------------------------------------------------------------------*/
  596.  
  597. class _CLASSTYPE ipstream : virtual public pstream
  598. {
  599.  
  600. public:
  601.  
  602.     _Cdecl  ipstream( Pstreambuf sb) { pstream::init( sb ); }
  603.     _Cdecl ~ipstream() {}
  604.  
  605.     streampos _Cdecl tellg()
  606.         { return bp->seekoff( 0, ios::cur, ios::in ); }
  607.  
  608.     Ripstream _Cdecl seekg( streampos );
  609.     Ripstream _Cdecl seekg( streamoff, ios::seek_dir );
  610.  
  611.     uchar _Cdecl readByte() { return bp->sbumpc(); }
  612.     void _Cdecl readBytes( Pvoid data, size_t sz)
  613.         { bp->sgetn( (char *)data, sz ); }
  614.     void _Cdecl freadBytes( void far *data, size_t sz );
  615.  
  616.     ushort _Cdecl readWord();
  617.     Pchar _Cdecl readString();
  618.     Pchar _Cdecl readString( Pchar, unsigned );
  619.     char far *freadString();
  620.     char far *freadString( char far *buf, unsigned maxLen );
  621.  
  622.     friend Ripstream _Cdecl _EXPOWLFUNC operator >> ( Ripstream,
  623.         signed char _FAR & );
  624.     friend Ripstream _Cdecl _EXPOWLFUNC operator >> ( Ripstream,
  625.         unsigned char _FAR & );
  626.     friend Ripstream _Cdecl _EXPOWLFUNC operator >> ( Ripstream,
  627.         signed short _FAR & );
  628.     friend Ripstream _Cdecl _EXPOWLFUNC operator >> ( Ripstream,
  629.         unsigned short _FAR & );
  630.     friend Ripstream _Cdecl _EXPOWLFUNC operator >> ( Ripstream,
  631.         signed int _FAR & );
  632.     friend Ripstream _Cdecl _EXPOWLFUNC operator >> ( Ripstream,
  633.         unsigned int _FAR & );
  634.     friend Ripstream _Cdecl _EXPOWLFUNC operator >> ( Ripstream,
  635.         signed long _FAR & );
  636.     friend Ripstream _Cdecl _EXPOWLFUNC operator >> ( Ripstream,
  637.         unsigned long _FAR & );
  638.     friend Ripstream _Cdecl _EXPOWLFUNC operator >> ( Ripstream,
  639.         float _FAR & );
  640.     friend Ripstream _Cdecl _EXPOWLFUNC operator >> ( Ripstream,
  641.         double _FAR & );
  642.     friend Ripstream _Cdecl _EXPOWLFUNC operator >> ( Ripstream,
  643.         long double _FAR & );
  644.  
  645.     friend Ripstream _Cdecl _EXPOWLFUNC operator >> ( Ripstream, RTStreamable );
  646.     friend Ripstream _Cdecl _EXPOWLFUNC operator >> ( Ripstream, RPvoid);
  647.  
  648. protected:
  649.  
  650.     _Cdecl ipstream() {}
  651.  
  652.     PCTStreamableClass _Cdecl readPrefix();
  653.     Pvoid _Cdecl readData( PCTStreamableClass, PTStreamable );
  654.     void _Cdecl readSuffix();
  655.  
  656.     PCvoid _Cdecl find( P_id_type id) { return objs.find( id ); }
  657.     void _Cdecl registerObject( PCvoid adr ) { objs.registerObject( adr ); }
  658.  
  659. private:
  660.  
  661.     TPReadObjects objs;
  662.  
  663. };
  664.  
  665. /* ------------------------------------------------------------------------*/
  666. /*                                                                         */
  667. /*   class opstream                                                        */
  668. /*                                                                         */
  669. /*   Base class for writing streamable objects                             */
  670. /*                                                                         */
  671. /* ------------------------------------------------------------------------*/
  672.  
  673. class _CLASSTYPE opstream : virtual public pstream
  674. {
  675.  
  676. public:
  677.  
  678.     _Cdecl opstream( Pstreambuf sb) { pstream::init( sb ); }
  679.     _Cdecl ~opstream() {}
  680.  
  681.     streampos _Cdecl tellp() { return bp->seekoff( 0, ios::cur, ios::out ); }
  682.     Ropstream _Cdecl seekp( streampos pos);
  683.     Ropstream _Cdecl seekp( streamoff off, ios::seek_dir dir);
  684.     Ropstream _Cdecl flush();
  685.  
  686.     void _Cdecl writeByte( uchar ch) { bp->sputc( ch ); }
  687.     void _Cdecl writeBytes( PCvoid data, size_t sz)
  688.         { bp->sputn( (char *)data, sz ); }
  689.     void _Cdecl fwriteBytes( const void far *data, size_t sz );
  690.  
  691.     void _Cdecl writeWord( ushort sh)
  692.         { bp->sputn( (char *)&sh, sizeof( ushort ) ); }
  693.  
  694.     void _Cdecl writeString( PCchar );
  695.     void _Cdecl fwriteString( const char far * str );
  696.  
  697.     friend Ropstream _Cdecl _EXPOWLFUNC operator << ( Ropstream, signed char );
  698.     friend Ropstream _Cdecl _EXPOWLFUNC operator << ( Ropstream, unsigned char );
  699.     friend Ropstream _Cdecl _EXPOWLFUNC operator << ( Ropstream, signed short );
  700.     friend Ropstream _Cdecl _EXPOWLFUNC operator << ( Ropstream, unsigned short );
  701.     friend Ropstream _Cdecl _EXPOWLFUNC operator << ( Ropstream, signed int );
  702.     friend Ropstream _Cdecl _EXPOWLFUNC operator << ( Ropstream, unsigned int );
  703.     friend Ropstream _Cdecl _EXPOWLFUNC operator << ( Ropstream, signed long );
  704.     friend Ropstream _Cdecl _EXPOWLFUNC operator << ( Ropstream, unsigned long );
  705.     friend Ropstream _Cdecl _EXPOWLFUNC operator << ( Ropstream, float );
  706.     friend Ropstream _Cdecl _EXPOWLFUNC operator << ( Ropstream, double );
  707.     friend Ropstream _Cdecl _EXPOWLFUNC operator << ( Ropstream, long double );
  708.  
  709.     friend Ropstream _Cdecl _EXPOWLFUNC operator << ( Ropstream, RTStreamable );
  710.     friend Ropstream _Cdecl _EXPOWLFUNC operator << ( Ropstream, PTStreamable );
  711.  
  712. protected:
  713.  
  714.     _Cdecl opstream() {}
  715.  
  716.     void _Cdecl writePrefix( RCTStreamable );
  717.     void _Cdecl writeData( RTStreamable );
  718.     void _Cdecl writeSuffix( RCTStreamable )
  719.         { writeByte( ']' ); }
  720.  
  721.     P_id_type _Cdecl find( PCvoid adr ) { return objs.find( adr ); }
  722.     void _Cdecl registerObject( PCvoid adr ) { objs.registerObject( adr ); }
  723.  
  724. private:
  725.     TPWrittenObjects objs;
  726.  
  727. };
  728.  
  729. /* ------------------------------------------------------------------------*/
  730. /*                                                                         */
  731. /*   class iopstream                                                       */
  732. /*                                                                         */
  733. /*   Base class for reading and writing streamable objects                 */
  734. /*                                                                         */
  735. /* ------------------------------------------------------------------------*/
  736.  
  737. class _CLASSTYPE iopstream : public ipstream, public opstream
  738. {
  739.  
  740. public:
  741.  
  742.     _Cdecl iopstream( Pstreambuf sb) { pstream::init( sb ); }
  743.     _Cdecl ~iopstream() {}
  744.  
  745. protected:
  746.  
  747.     _Cdecl iopstream() {}
  748. };
  749.  
  750. /* ------------------------------------------------------------------------*/
  751. /*                                                                         */
  752. /*   class fpbase                                                          */
  753. /*                                                                         */
  754. /*   Base class for handling streamable objects on file streams            */
  755. /*                                                                         */
  756. /* ------------------------------------------------------------------------*/
  757.  
  758. class _CLASSTYPE fpbase : virtual public pstream
  759. {
  760.     
  761. public:
  762.  
  763.     _Cdecl fpbase() { pstream::init( &buf ); }
  764.     _Cdecl fpbase( PCchar, int, int = filebuf::openprot );
  765.     _Cdecl fpbase( int f ) : buf (f) { pstream::init( &buf ); }
  766.     _Cdecl fpbase( int f, Pchar b, int len) : buf( f, b, len )
  767.         { pstream::init( &buf ); }
  768.     _Cdecl ~fpbase() {}
  769.  
  770.     void _Cdecl open( PCchar, int, int = filebuf::openprot );
  771.     void _Cdecl attach( int );
  772.     void _Cdecl close();
  773.     void _Cdecl setbuf( Pchar, int );
  774.     Pfilebuf _Cdecl rdbuf() { return &buf; }
  775.     
  776. private:
  777.  
  778.     filebuf buf;
  779.  
  780. };
  781.  
  782. /* ------------------------------------------------------------------------*/
  783. /*                                                                         */
  784. /*   class ifpstream                                                       */
  785. /*                                                                         */
  786. /*   Base class for reading streamable objects from file streams           */
  787. /*                                                                         */
  788. /* ------------------------------------------------------------------------*/
  789.  
  790. class _CLASSTYPE ifpstream : public fpbase, public ipstream
  791. {
  792.  
  793. public:
  794.  
  795.     _Cdecl ifpstream() {}
  796.     _Cdecl ifpstream( PCchar name,
  797.                       int mode = ios::in,
  798.                       int prot = filebuf::openprot
  799.                     );
  800.     _Cdecl ifpstream(int f) : fpbase( f ) {}
  801.     _Cdecl ifpstream( int f, Pchar b, int len) : fpbase(f, b, len) {}
  802.     _Cdecl ~ifpstream() {}
  803.  
  804.     Pfilebuf _Cdecl rdbuf() { return fpbase::rdbuf(); }
  805.     void _Cdecl open( PCchar,
  806.                       int = ios::in,
  807.                       int = filebuf::openprot
  808.                     );
  809. };
  810.  
  811. /* ------------------------------------------------------------------------*/
  812. /*                                                                         */
  813. /*   class ofpstream                                                       */
  814. /*                                                                         */
  815. /*   Base class for writing streamable objects to file streams             */
  816. /*                                                                         */
  817. /* ------------------------------------------------------------------------*/
  818.  
  819. class _CLASSTYPE ofpstream : public fpbase, public opstream
  820. {
  821.  
  822. public:
  823.  
  824.     _Cdecl ofpstream() {}
  825.     _Cdecl ofpstream( PCchar,
  826.                       int = ios::out,
  827.                       int = filebuf::openprot
  828.                     );
  829.     _Cdecl ofpstream( int f) : fpbase( f ) {}
  830.     _Cdecl ofpstream( int f, Pchar b, int len ) : fpbase(f, b, len) {}
  831.     _Cdecl ~ofpstream() {}
  832.  
  833.     Pfilebuf _Cdecl rdbuf() { return fpbase::rdbuf(); }
  834.     void _Cdecl open( PCchar,
  835.                       int = ios::out,
  836.                       int = filebuf::openprot
  837.                     );
  838.  
  839. };
  840.  
  841. /* ------------------------------------------------------------------------*/
  842. /*                                                                         */
  843. /*   class fpstream                                                        */
  844. /*                                                                         */
  845. /*   Base class for reading and writing streamable objects to              */
  846. /*   bidirectional file streams                                            */
  847. /*                                                                         */
  848. /* ------------------------------------------------------------------------*/
  849.  
  850. class _CLASSTYPE fpstream : public fpbase, public iopstream
  851. {
  852.  
  853. public:
  854.  
  855.     _Cdecl fpstream() {}
  856.     _Cdecl fpstream( PCchar, int, int = filebuf::openprot );
  857.     _Cdecl fpstream( int f) : fpbase( f ) {}
  858.     _Cdecl fpstream( int f, Pchar b, int len ) : fpbase(f, b, len) {}
  859.     _Cdecl ~fpstream() {}
  860.  
  861.     Pfilebuf _Cdecl rdbuf() { return fpbase::rdbuf(); }
  862.     void _Cdecl open( PCchar, int, int = filebuf::openprot );
  863.  
  864. };
  865.  
  866. _CLASSDEF(TWindow)
  867. _CLASSDEF(TScroller)
  868.  
  869. #define MaxInt 32767
  870. long LongMulDiv(long Mult1, long Mult2, long Div1);
  871.  
  872.   /* TScroller object */
  873.  
  874. class _EXPORT TScroller : public Object, public TStreamable
  875. {
  876. public:
  877.     PTWindow Window;
  878.     long XPos, YPos;      // current pos in horz/vert scroll units
  879.     long XRange, YRange;  // # of scrollable horz/vert scroll units
  880.     int XUnit, YUnit;     //logical device units per horz/vert scroll unit
  881.     int XLine, YLine;        // # of horz/vert scroll units per line
  882.     int XPage, YPage;        // # of horz/vert scroll units per page
  883.     BOOL AutoMode;           // auto scrolling mode
  884.     BOOL TrackMode;          // track scroll mode
  885.     BOOL AutoOrg;            // indicates Scroller offsets origin
  886.     BOOL HasHScrollBar;
  887.     BOOL HasVScrollBar;
  888.  
  889.     TScroller(PTWindow TheWindow, int TheXUnit, int TheYUnit,
  890.               long TheXRange, long TheYRange);
  891.     ~TScroller();
  892.     void SetUnits(int TheXUnit, int TheYUnit);
  893.     virtual void SetPageSize();
  894.     virtual void SetSBarRange();
  895.     void SetRange(long TheXRange, long TheYRange);
  896. #if defined(WIN31)
  897.     // windows 3.1 interface
  898.     virtual void BeginView(HDC PaintDC, PAINTSTRUCT _FAR & PaintInfo);
  899. #endif
  900. #if defined(WIN30)
  901.     // windows 3.0 interface
  902.     virtual void BeginView(HDC_30 PaintDC, PAINTSTRUCT _FAR & PaintInfo);
  903. #endif
  904. #if (defined(WIN30) || defined(WIN31)) && !(defined(WIN30) && defined(WIN31))
  905.     // this function is never called. it is used to pad the vtable so that
  906.     // exactly two BeginView(...) definitions are always present.
  907.     virtual void BeginView(void *, void *) { };
  908. #endif
  909.     virtual void EndView();
  910.     virtual void VScroll(WORD ScrollEvent, int ThumbPos);
  911.     virtual void HScroll(WORD ScrollEvent, int ThumbPos);
  912.     virtual void ScrollTo(long X, long Y);
  913.  
  914.     /* Scrolls to a position calculated using the passed
  915.        "Delta" values. */
  916.     void ScrollBy(long Dx, long Dy)
  917.         { ScrollTo(XPos + Dx, YPos + Dy); }
  918.  
  919.     virtual void AutoScroll();
  920.  
  921.     /* Returns a BOOL value indicating whether or not the passed
  922.        area (in units) is currently visible. */
  923.     BOOL IsVisibleRect(long X, long Y, int XExt, int YExt)
  924.         { return (X + XExt >= XPos) && (Y + YExt >= YPos) &&
  925.              (X < XPos + XPage) && (Y < YPos + YPage); }
  926.  
  927.     /* Converts a horizontal range value from the scrollbar to a
  928.        horizontal scroll value. */
  929.     int XScrollValue(long ARangeUnit)
  930.         { return (int)LongMulDiv(ARangeUnit, MaxInt, XRange); }
  931.  
  932.     /* Converts a vertical range value from the scrollbar to a
  933.        vertical scroll value. */
  934.     int YScrollValue(long ARangeUnit)
  935.         { return (int)LongMulDiv(ARangeUnit, MaxInt, YRange); }
  936.  
  937.     /* Converts a horizontal scroll value from the scrollbar to
  938.        a horizontal range value. */
  939.     long XRangeValue(int AScrollUnit)
  940.         { return LongMulDiv(AScrollUnit, XRange, MaxInt); }
  941.  
  942.     /* Converts a vertical scroll value from the scrollbar to
  943.        a vertical range value. */
  944.     long YRangeValue(int AScrollUnit)
  945.         { return LongMulDiv(AScrollUnit, YRange, MaxInt); }
  946.  
  947.     // define pure virtual functions derived from Object class
  948.     virtual classType      isA() const
  949.         { return scrollerClass; }
  950.     virtual Pchar nameOf() const
  951.         { return "TScroller"; }
  952.     virtual hashValueType hashValue() const
  953.         { return InstanceHashValue; }
  954.     virtual int       isEqual(RCObject testobj)  const
  955.         { return (this ==  &(RTScroller)testobj); }
  956.     virtual void         printOn(Rostream outputStream) const
  957.         { outputStream << nameOf() << "{ Window = " << Window <<" }\n";}
  958.  
  959.     static PTStreamable build();
  960.  
  961. protected:
  962.     TScroller(StreamableInit) {};
  963.     virtual void write (Ropstream os);
  964.     virtual Pvoid read (Ripstream is);
  965.     hashValueType InstanceHashValue;
  966.     static hashValueType ClassHashValue;
  967.  
  968. private:
  969.     virtual const Pchar streamableName() const
  970.         { return "TScroller"; }
  971.     
  972.     void __BeginView(HDC PaintDC, PAINTSTRUCT _FAR & PaintInfo);    
  973. };
  974.  
  975. inline Ripstream operator >> ( Ripstream is, RTScroller cl )
  976.     { return is >> (RTStreamable )cl; }
  977. inline Ripstream operator >> ( Ripstream is, RPTScroller cl )
  978.     { return is >> (RPvoid)cl; }
  979.  
  980. inline Ropstream operator << ( Ropstream os, RTScroller cl )
  981.     { return os << (RTStreamable )cl; }
  982. inline Ropstream operator << ( Ropstream os, PTScroller cl )
  983.     { return os << (PTStreamable )cl; }
  984.  
  985. //  windows 3.1 name confict with TWindowsObject::GetFirstChild()
  986. #if defined(GetFirstChild)
  987. #undef GetFirstChild(hwnd)
  988. #endif
  989.  
  990. struct TMessage {
  991.   HWND Receiver;
  992.   WORD Message;
  993.   union {
  994.     WORD WParam;
  995.         struct tagWP {
  996.           BYTE Lo;
  997.           BYTE Hi;
  998.         } WP;
  999.   };
  1000.   union {
  1001.         DWORD LParam;
  1002.         struct tagLP {
  1003.           WORD Lo;
  1004.           WORD Hi;
  1005.         } LP;
  1006.   };
  1007.   long Result;
  1008. };
  1009.  
  1010. _CLASSDEF(TMDIClient)
  1011. _CLASSDEF(TApplication)
  1012. _CLASSDEF(TModule)
  1013. _CLASSDEF(TWindowsObject)
  1014.  
  1015.  
  1016. typedef TMessage _FAR &RTMessage;
  1017.  
  1018. typedef void ( _FAR *TActionFunc )(Pvoid Child, Pvoid ParamList);
  1019. typedef BOOL ( _FAR *TCondFunc )(Pvoid Child, Pvoid ParamList);
  1020.  
  1021. /* TWindowsObject */
  1022. class _EXPORT TWindowsObject : public Object, public TStreamable
  1023. {
  1024. public:
  1025.     int Status;
  1026.     HWND HWindow;    // handle to associated MS-Windows window
  1027.     LPSTR Title;
  1028.     PTWindowsObject Parent;
  1029.  
  1030.     TWindowsObject(PTWindowsObject AParent, PTModule AModule = NULL);
  1031.     virtual ~TWindowsObject();
  1032.     void SetFlags(WORD Mask, BOOL OnOff);
  1033.  
  1034.     /* Determines whether the flag whose mask is passed has been set,
  1035.        returning a BOOL indicator --  True = On, False = Off. */
  1036.     BOOL IsFlagSet(WORD Mask)
  1037.         { return( (Flags & Mask) == Mask); }
  1038.  
  1039.     PTWindowsObject FirstThat(TCondFunc Test, Pvoid PParamList);
  1040.     void ForEach(TActionFunc Action, Pvoid PParamList);
  1041.     PTWindowsObject FirstThat(
  1042.         BOOL (TWindowsObject::* _FAR Test)(Pvoid, Pvoid), Pvoid PParamList);
  1043.     void ForEach(
  1044.         void (TWindowsObject::* _FAR Action)(Pvoid, Pvoid), Pvoid PParamList);
  1045.  
  1046.     PTWindowsObject Next();
  1047.     PTWindowsObject GetFirstChild()
  1048.         { return ChildList->SiblingList; }
  1049.     PTWindowsObject GetLastChild()
  1050.         { return ChildList; }
  1051.     PTWindowsObject Previous();
  1052.     void EnableKBHandler();
  1053.     void EnableAutoCreate();
  1054.     void DisableAutoCreate();
  1055.     void EnableTransfer();
  1056.     void DisableTransfer();
  1057.  
  1058.     PTModule GetModule()
  1059.         { return Module; }
  1060.     PTApplication GetApplication()
  1061.         { return Application; }
  1062.     WNDPROC GetInstance()
  1063.         { return Instance; }
  1064.     virtual BOOL Register();
  1065.  
  1066. /* Pure virtual function, placeholder for derived classes to redefine to
  1067.    create an MS_Windows element to be associated with an OWL window
  1068.    object */
  1069.     virtual BOOL Create() = 0;
  1070.  
  1071.     virtual void Destroy();
  1072.  
  1073.     virtual int GetId();
  1074.     PTWindowsObject ChildWithId(int Id);
  1075.     virtual PTMDIClient GetClient();
  1076.     virtual void SetParent(PTWindowsObject NewParent);
  1077.     void Show(int ShowCmd);
  1078.     void SetCaption(LPSTR ATitle);
  1079.     virtual BOOL CanClose();
  1080.     void SetTransferBuffer(Pvoid ATransferBuffer)
  1081.         { TransferBuffer = ATransferBuffer; }
  1082.     virtual WORD Transfer(Pvoid DataPtr, WORD TransferFlag);
  1083.     virtual void TransferData(WORD Direction);
  1084.     virtual void DefWndProc(RTMessage Msg);
  1085.     virtual void BeforeDispatchHandler() {}
  1086.     virtual void AfterDispatchHandler() {}
  1087.     virtual void DispatchAMessage(WORD AMsg, RTMessage AMessage,
  1088.         void (TWindowsObject::* _FAR)(RTMessage ));
  1089.     void CloseWindow();
  1090.     void GetChildren(Ripstream is);
  1091.     void PutChildren(Ropstream os);
  1092.     BOOL CreateChildren();
  1093.     virtual void ShutDownWindow();
  1094.     virtual void DrawItem(DRAWITEMSTRUCT far & DrawInfo);
  1095.     virtual void ActivationResponse(WORD Activated, BOOL IsIconified);
  1096.  
  1097.     // define pure virtual functions derived from Object class
  1098.     virtual classType      isA() const = 0;
  1099.     virtual Pchar nameOf() const = 0;
  1100.     virtual hashValueType  hashValue() const
  1101.         { return hashValueType(HWindow); }
  1102.     virtual int              isEqual(RCObject testwin)  const
  1103.         { return this ==  &(RTWindowsObject)testwin; }
  1104.     virtual void             printOn(Rostream outputStream) const
  1105.     { outputStream << nameOf() << "{ HWindow = "
  1106.          << (void _FAR *)HWindow << " }\n"; }
  1107.  
  1108.     static PTStreamable build();
  1109.  
  1110. protected:
  1111.  
  1112.     WNDPROC DefaultProc;
  1113.     Pvoid TransferBuffer;
  1114.     virtual void GetWindowClass(WNDCLASS _FAR & AWndClass);
  1115.     virtual LPSTR GetClassName() = 0;
  1116.     void RemoveClient()
  1117.         { RemoveChild((PTWindowsObject)GetClient()); }
  1118.     void GetChildPtr(Ripstream is, RPTWindowsObject P);
  1119.     void PutChildPtr(Ropstream os, PTWindowsObject P);
  1120.     void GetSiblingPtr(Ripstream is, RPTWindowsObject P);
  1121.     void PutSiblingPtr(Ropstream os, PTWindowsObject P);
  1122.     virtual void DefCommandProc(RTMessage Msg);
  1123.     virtual void DefChildProc(RTMessage Msg);
  1124.     virtual void DefNotificationProc(RTMessage Msg);
  1125.     virtual void SetupWindow();
  1126.     virtual void WMVScroll(RTMessage Msg) =
  1127.                  [WM_FIRST + WM_VSCROLL];
  1128.     virtual void WMHScroll(RTMessage Msg) =
  1129.                  [WM_FIRST + WM_HSCROLL];
  1130.     void DispatchScroll(RTMessage Msg);
  1131.     virtual void WMCommand(RTMessage Msg) =
  1132.                  [WM_FIRST + WM_COMMAND];
  1133.     virtual void WMDrawItem(RTMessage Msg) =
  1134.                  [WM_FIRST + WM_DRAWITEM];
  1135.     virtual void WMClose(RTMessage Msg) =
  1136.                  [WM_FIRST + WM_CLOSE];
  1137.     virtual void WMDestroy(RTMessage Msg) =
  1138.                  [WM_FIRST + WM_DESTROY];
  1139.     virtual void WMNCDestroy(RTMessage Msg) =
  1140.                  [WM_FIRST + WM_NCDESTROY];
  1141.     virtual void WMActivate(RTMessage Msg) =
  1142.                  [WM_FIRST + WM_ACTIVATE];
  1143.     virtual void WMQueryEndSession(RTMessage Msg) =
  1144.                  [WM_FIRST + WM_QUERYENDSESSION];
  1145.     virtual void CMExit(RTMessage Msg) =
  1146.                  [CM_FIRST + CM_EXIT];
  1147.  
  1148.     TWindowsObject(StreamableInit) {};
  1149.     virtual void write (Ropstream os);
  1150.     virtual Pvoid read (Ripstream is);
  1151.  
  1152. private:
  1153.  
  1154.     WNDPROC Instance;
  1155.     PTApplication Application;
  1156.     PTModule Module;
  1157.     WORD Flags;
  1158.     WORD CreateOrder;
  1159.     BOOL OrderIsI(Pvoid P, Pvoid I);
  1160.     BOOL CreateZeroChild(Pvoid P, Pvoid I);
  1161.     void AssignCreateOrder();
  1162.     PTWindowsObject ChildList, SiblingList;
  1163.     void AddChild(PTWindowsObject AChild);
  1164.     void RemoveChild(PTWindowsObject AChild);
  1165.     int IndexOf(PTWindowsObject P);
  1166.     PTWindowsObject At(int APosition);
  1167.  
  1168.     virtual const Pchar streamableName() const
  1169.         { return "TWindowsObject"; }
  1170.  
  1171. };    // end of WindowsObject class
  1172.  
  1173. /* Returns the Id of the TWindowsObject, used to identify the window
  1174.    in a specified parent's ChildList.  Redefined by TControl
  1175.    descendants to return their identifier from their attributes
  1176.    structure.  0 is returned here as the default identifier. This
  1177.    precludes any window with a 0 Id from being easily found. If you
  1178.    need to address individual windows, redefine GetId to return
  1179.    something other than 0.*/
  1180. inline int TWindowsObject::GetId()
  1181.         { return 0; }
  1182.  
  1183. /* Returns a pointer to the TWindowsObject's next sibling (the next
  1184.    window in its parent's child window list.  If this was the last child
  1185.    added to the list, returns a pointer to the first child added.*/
  1186. inline PTWindowsObject TWindowsObject::Next()
  1187.         { return SiblingList; }
  1188.  
  1189. typedef void ( TWindowsObject::* _FAR TActionMemFunc )(Pvoid Child, Pvoid ParamList);
  1190. typedef BOOL ( TWindowsObject::* _FAR TCondMemFunc )(Pvoid Child, Pvoid ParamList);
  1191.  
  1192. inline Ripstream operator >> ( Ripstream is, RTWindowsObject cl )
  1193.     { return is >> (RTStreamable)cl; }
  1194. inline Ripstream operator >> ( Ripstream is, RPTWindowsObject cl )
  1195.     { return is >> (RPvoid)cl; }
  1196.  
  1197. inline Ropstream operator << ( Ropstream os, RTWindowsObject cl )
  1198.     { return os << (RTStreamable )cl; }
  1199. inline Ropstream operator << ( Ropstream os, PTWindowsObject cl )
  1200.     { return os << (PTStreamable )cl; }
  1201.  
  1202. const int BAD_DIALOG_STATUS = -2;
  1203.  
  1204. /* TDialog creation atributes */
  1205. struct _CLASSTYPE TDialogAttr { // _CLASSTYPE needed by BC++ 2.0
  1206.     LPSTR Name;
  1207.     DWORD Param;
  1208. };
  1209.  
  1210.   /* TDialog */
  1211.  
  1212. _CLASSDEF(TDialog)
  1213.  
  1214. class _EXPORT TDialog : public TWindowsObject
  1215. {
  1216. public:
  1217.     TDialogAttr Attr;
  1218.     BOOL IsModal;
  1219.  
  1220.     TDialog(PTWindowsObject AParent, LPSTR AName, PTModule AModule = NULL);
  1221.     TDialog(PTWindowsObject AParent, int ResourceId, PTModule AModule = NULL);
  1222.     virtual ~TDialog();
  1223.  
  1224.     virtual BOOL Create();
  1225.     virtual int Execute();
  1226.  
  1227.     virtual void CloseWindow(int ARetValue);
  1228.     virtual void CloseWindow();
  1229.     virtual void ShutDownWindow(int ARetValue);
  1230.     virtual void ShutDownWindow();
  1231.     virtual void Destroy(int ARetValue);
  1232.     virtual void Destroy();
  1233.  
  1234.     void SetCaption(LPSTR ATitle);
  1235.  
  1236. /* Returns the handle of the dialog's control with the passed Id.*/
  1237.     HWND GetItemHandle(int DlgItemID)
  1238.       { return GetDlgItem(HWindow, DlgItemID); }
  1239.  
  1240. /* Sends the passed message to the dialog's control which has
  1241.    the Id DlgItemID. */
  1242.     DWORD SendDlgItemMsg(int DlgItemID, WORD AMsg, WORD WParam, DWORD LParam)
  1243.       { return SendDlgItemMessage(HWindow, DlgItemID, AMsg, WParam, LParam); }
  1244.  
  1245.  
  1246.     virtual classType        isA() const
  1247.     { return dialogClass; }
  1248.     virtual Pchar nameOf() const
  1249.         { return "TDialog"; }
  1250.  
  1251.     static PTStreamable build();
  1252.  
  1253. protected:
  1254.     virtual void GetWindowClass(WNDCLASS _FAR & AWndClass);
  1255.     virtual LPSTR GetClassName();
  1256.     virtual void SetupWindow();
  1257.     virtual void Ok(RTMessage Msg) = [ID_FIRST + IDOK];
  1258.     virtual void Cancel(RTMessage Msg) = [ID_FIRST + IDCANCEL];
  1259.     virtual void WMInitDialog(RTMessage Msg) = [WM_FIRST + WM_INITDIALOG];
  1260.     virtual void WMQueryEndSession(RTMessage Msg) =
  1261.                  [WM_FIRST + WM_QUERYENDSESSION];
  1262.     virtual void WMClose(RTMessage Msg) = [WM_FIRST + WM_CLOSE];
  1263.  
  1264.     TDialog(StreamableInit) : TWindowsObject(streamableInit) {};
  1265.     virtual void write (Ropstream os);
  1266.     virtual Pvoid read (Ripstream is);
  1267.  
  1268. private:
  1269.     virtual const Pchar streamableName() const
  1270.         { return "TDialog"; }
  1271. };
  1272.  
  1273. inline Ripstream operator >> ( Ripstream is, RTDialog cl )
  1274.     { return is >> (RTStreamable)cl; }
  1275. inline Ripstream operator >> ( Ripstream is, RPTDialog cl )
  1276.     { return is >> (RPvoid)cl; }
  1277.  
  1278. inline Ropstream operator << ( Ropstream os, RTDialog cl )
  1279.     { return os << (RTStreamable )cl; }
  1280. inline Ropstream operator << ( Ropstream os, PTDialog cl )
  1281.     { return os << (PTStreamable)cl; }
  1282.  
  1283.   /* TWindow creation attributes */
  1284. struct _CLASSTYPE TWindowAttr { // _CLASSTYPE needed by BC++ 2.0
  1285.     DWORD Style;
  1286.     DWORD ExStyle;
  1287.     int X, Y, W, H;
  1288.     LPSTR Menu;  // Menu name
  1289.     int Id ;     // Child identifier
  1290.     LPSTR Param;
  1291.  };
  1292.  
  1293.  
  1294. /* Window Class */
  1295.  
  1296. _CLASSDEF(TWindow)
  1297.  
  1298. class _EXPORT TWindow : public TWindowsObject
  1299. {
  1300. public:
  1301.     TWindowAttr  Attr;
  1302.     PTScroller Scroller;
  1303.     HWND FocusChildHandle;
  1304.  
  1305.     TWindow(PTWindowsObject AParent, LPSTR ATitle, PTModule AModule = NULL);
  1306.     TWindow(HWND AnHWindow, PTModule AModule = NULL);
  1307.     virtual ~TWindow();
  1308.  
  1309.     virtual BOOL AssignMenu(LPSTR MenuName);
  1310.     virtual BOOL AssignMenu(int MenuId);
  1311.     virtual BOOL Create();
  1312.     virtual void ActivationResponse(WORD Activated, BOOL IsIconified);
  1313.  
  1314.     virtual classType        isA() const
  1315.     { return windowClass; }
  1316.     virtual Pchar nameOf() const
  1317.     { return "TWindow"; }
  1318.  
  1319.     static PTStreamable build();
  1320.  
  1321. protected:
  1322.     virtual LPSTR GetClassName()
  1323.         { return "OWLWindow31"; }
  1324.     virtual void GetWindowClass(WNDCLASS _FAR & AWndClass);
  1325.     virtual void SetupWindow();
  1326.  
  1327.     virtual void WMCreate(RTMessage Msg) = [WM_FIRST + WM_CREATE];
  1328.     virtual void WMMDIActivate(RTMessage Msg) =
  1329.                  [WM_FIRST + WM_MDIACTIVATE];
  1330.     virtual void WMHScroll(RTMessage Msg) = [WM_FIRST + WM_HSCROLL];
  1331.     virtual void WMVScroll(RTMessage Msg) = [WM_FIRST + WM_VSCROLL];
  1332.     virtual void WMPaint(RTMessage Msg) = [WM_FIRST + WM_PAINT];
  1333. #if defined(WIN31)
  1334.     // windows 3.1 interface
  1335.     virtual void Paint(HDC PaintDC, PAINTSTRUCT _FAR & PaintInfo);
  1336. #endif
  1337. #if defined(WIN30)
  1338.     // windows 3.0 interface
  1339.     virtual void Paint(HDC_30 PaintDC, PAINTSTRUCT _FAR & PaintInfo);
  1340. #endif
  1341. #if (defined(WIN30) || defined(WIN31)) && !(defined(WIN30) && defined(WIN31))
  1342.     // this function is never called. it is used to pad the vtable so that
  1343.     // exactly two Paint(...) definitions are always present.
  1344.     virtual void Paint(void *, void *) { };
  1345. #endif
  1346.     virtual void WMSize(RTMessage Msg) = [WM_FIRST + WM_SIZE];
  1347.     virtual void WMMove(RTMessage Msg) = [WM_FIRST + WM_MOVE];
  1348.     virtual void WMLButtonDown(RTMessage Msg) = [WM_FIRST + WM_LBUTTONDOWN];
  1349.  
  1350.     TWindow(StreamableInit) : TWindowsObject(streamableInit) {};
  1351.     virtual void write (Ropstream os);
  1352.     virtual Pvoid read (Ripstream is);
  1353.  
  1354. private:
  1355.     virtual const Pchar streamableName() const
  1356.         { return "TWindow"; }
  1357.  
  1358. };     // end of Window class
  1359.  
  1360. inline Ripstream operator >> ( Ripstream is, RTWindow cl )
  1361.     { return is >> (RTStreamable)cl; }
  1362. inline Ripstream operator >> ( Ripstream is, RPTWindow cl )
  1363.     { return is >> (RPvoid)cl; }
  1364.  
  1365. inline Ropstream operator << ( Ropstream os, RTWindow cl )
  1366.     { return os << (RTStreamable)cl; }
  1367. inline Ropstream operator << ( Ropstream os, PTWindow cl )
  1368.     { return os << (PTStreamable)cl; }
  1369.  
  1370. #define FILESPEC    MAXPATH + MAXEXT
  1371.  
  1372. _CLASSDEF(TFileDialog)
  1373.  
  1374.   /* TFileDialog */
  1375. class _EXPORT TFileDialog : public TDialog
  1376. {
  1377. public:
  1378.     LPSTR FilePath;
  1379.     char PathName[MAXPATH];
  1380.     char Extension[MAXEXT];
  1381.     char FileSpec[FILESPEC];
  1382.  
  1383.     TFileDialog(PTWindowsObject AParent, int ResourceId, LPSTR AFilePath,
  1384.                 PTModule AModule = NULL);
  1385.     virtual BOOL CanClose();
  1386.     void SelectFileName();
  1387.     void UpdateFileName();
  1388.     BOOL UpdateListBoxes();
  1389.  
  1390.     static PTStreamable build();
  1391.  
  1392. protected:
  1393.     virtual void SetupWindow();
  1394.     virtual void HandleFName(RTMessage Msg)
  1395.           = [ID_FIRST + ID_FNAME];
  1396.     virtual void HandleFList(RTMessage Msg)
  1397.           = [ID_FIRST + ID_FLIST];
  1398.     virtual void HandleDList(RTMessage Msg)
  1399.           = [ID_FIRST + ID_DLIST];
  1400.  
  1401.     TFileDialog(StreamableInit) : TDialog(streamableInit) {};
  1402.  
  1403. private:
  1404.     virtual const Pchar streamableName() const
  1405.         { return "TFileDialog"; }
  1406. };
  1407.  
  1408. inline Ripstream operator >> ( Ripstream is, RTFileDialog cl )
  1409.     { return is >> (RTStreamable )cl; }
  1410. inline Ripstream operator >> ( Ripstream is, RPTFileDialog cl )
  1411.     { return is >> (RPvoid)cl; }
  1412.  
  1413. inline Ropstream operator << ( Ropstream os, RTFileDialog cl )
  1414.     { return os << (RTStreamable )cl; }
  1415. inline Ropstream operator << ( Ropstream os, PTFileDialog cl )
  1416.     { return os << (PTStreamable )cl; }
  1417.  
  1418. _CLASSDEF(TInputDialog)
  1419.  
  1420.   /* TInputDialog */
  1421. class _EXPORT TInputDialog : public TDialog
  1422. {
  1423. public:
  1424.     LPSTR Prompt;
  1425.     LPSTR Buffer;
  1426.     WORD BufferSize;
  1427.  
  1428.     TInputDialog(PTWindowsObject AParent, LPSTR ATitle,
  1429.               LPSTR APrompt, LPSTR ABuffer, WORD ABufferSize,
  1430.               PTModule AModule = NULL);
  1431.     void TransferData(WORD Direction);
  1432.  
  1433.     static PTStreamable build();
  1434.  
  1435. protected:
  1436.     virtual void SetupWindow();
  1437.     TInputDialog(StreamableInit) : TDialog(streamableInit) {};
  1438.     virtual void write (Ropstream os);
  1439.     virtual Pvoid read (Ripstream is);
  1440.  
  1441. private:
  1442.     virtual const Pchar streamableName() const
  1443.         { return "TInputDialog"; }
  1444. };
  1445.  
  1446. inline Ripstream operator >> ( Ripstream is, RTInputDialog cl )
  1447.     { return is >> (RTStreamable )cl; }
  1448. inline Ripstream operator >> ( Ripstream is, RPTInputDialog cl )
  1449.     { return is >> (RPvoid)cl; }
  1450.  
  1451. inline Ropstream operator << ( Ropstream os, RTInputDialog cl )
  1452.     { return os << (RTStreamable )cl; }
  1453. inline Ropstream operator << ( Ropstream os, PTInputDialog cl )
  1454.     { return os << (PTStreamable )cl; }
  1455.  
  1456. _CLASSDEF(TBWindow)
  1457.  
  1458. /* TBWindow */
  1459.  
  1460. class _EXPORT TBWindow : public TWindow
  1461. {
  1462. public:
  1463.     TBWindow(PTWindowsObject AParent, LPSTR AName,
  1464.          PTModule AModule = NULL);
  1465.  
  1466.     static PTStreamable build();
  1467.  
  1468. protected:
  1469.     virtual LPSTR GetClassName()
  1470.         {return "TBWindow";}
  1471.     virtual void GetWindowClass(WNDCLASS _FAR & AWndClass);
  1472.  
  1473.     TBWindow(StreamableInit) : TWindow(streamableInit) {};
  1474.  
  1475. private:
  1476.     virtual const Pchar streamableName() const
  1477.         { return "TBWindow"; }
  1478. };
  1479.  
  1480. inline Ripstream operator >> ( Ripstream is, RTBWindow cl )
  1481.     { return is >> (RTStreamable)cl; }
  1482. inline Ripstream operator >> ( Ripstream is, RPTBWindow cl )
  1483.     { return is >> (RPvoid)cl; }
  1484.  
  1485. inline Ropstream operator << ( Ropstream os, RTBWindow cl )
  1486.     { return os << (RTStreamable)cl; }
  1487. inline Ropstream operator << ( Ropstream os, PTBWindow cl )
  1488.     { return os << (PTStreamable)cl; }
  1489.  
  1490.   /* TControl */
  1491.  
  1492. _CLASSDEF(TControl)
  1493.  
  1494. class _EXPORT TControl : public TWindow {
  1495. public:
  1496.     TControl(PTWindowsObject AParent, int AnId, LPSTR ATitle, int X,
  1497.              int Y, int W, int H, PTModule AModule = NULL);
  1498.     TControl(PTWindowsObject AParent, int ResourceId,
  1499.          PTModule AModule = NULL);
  1500.     virtual int GetId()
  1501.         { return Attr.Id; }
  1502.  
  1503. protected:
  1504.     TControl(StreamableInit) : TWindow(streamableInit) {};
  1505.  
  1506.     virtual void WMPaint(RTMessage Msg) = [WM_FIRST + WM_PAINT];
  1507.     virtual void WMDrawItem(RTMessage Msg) = [WM_FIRST + WM_DRAWITEM];
  1508.     virtual void ODADrawEntire(DRAWITEMSTRUCT far & DrawInfo);
  1509.     virtual void ODAFocus(DRAWITEMSTRUCT far & DrawInfo);
  1510.     virtual void ODASelect(DRAWITEMSTRUCT far & DrawInfo);
  1511. };
  1512.  
  1513. _CLASSDEF(TMDIFrame)
  1514. _CLASSDEF(TMDIClient)
  1515.  
  1516. /* --------------------------------------------------------
  1517.   TMDIClient object
  1518.   -------------------------------------------------------- */
  1519.  
  1520. class _EXPORT TMDIClient : public TWindow
  1521. {
  1522. public:
  1523.     LPCLIENTCREATESTRUCT ClientAttr;
  1524.  
  1525.     TMDIClient(PTMDIFrame AParent, PTModule AModule = NULL);
  1526.     TMDIClient(PTMDIFrame AParent, HWND AnHWindow, PTModule AModule = NULL);
  1527.     virtual ~TMDIClient();
  1528.  
  1529.     /* Arranges iconized MDI child windows. */
  1530.     virtual void ArrangeIcons()
  1531.     { SendMessage(HWindow, WM_MDIICONARRANGE, 0, 0); }
  1532.  
  1533.     /* Cascades the MDI child windows. */
  1534.     virtual void CascadeChildren()
  1535.     { SendMessage(HWindow, WM_MDICASCADE, 0, 0); }
  1536.  
  1537.     /* Tiles the MDI child windows. */
  1538.     virtual void TileChildren()
  1539.     { SendMessage(HWindow, WM_MDITILE, 0, 0); }
  1540.  
  1541.     static PTStreamable build();
  1542.  
  1543. protected:
  1544.     virtual LPSTR GetClassName()
  1545.         { return "MDICLIENT"; }
  1546.  
  1547.     /* Override TWindow::WMPaint and instead call DefWndProc */
  1548.     virtual void WMPaint(RTMessage Msg) = [WM_FIRST + WM_PAINT]
  1549.         { DefWndProc(Msg); }
  1550.  
  1551.     /* Override TWindow::WMMDIActivate, instead just call DefWndProc. */
  1552.     virtual void WMMDIActivate(RTMessage Msg) =
  1553.                  [WM_FIRST + WM_MDIACTIVATE]
  1554.         { DefWndProc(Msg); }
  1555.  
  1556.     TMDIClient(StreamableInit) : TWindow(streamableInit) {}
  1557.     virtual void write (Ropstream os);
  1558.     virtual Pvoid read (Ripstream is);
  1559.  
  1560. private:
  1561.     virtual const Pchar streamableName() const
  1562.         { return "TMDIClient"; }
  1563. };
  1564.  
  1565. inline Ripstream operator >> ( Ripstream is, RTMDIClient cl )
  1566.     { return is >> (RTStreamable)cl; }
  1567. inline Ripstream operator >> ( Ripstream is, RPTMDIClient cl )
  1568.     { return is >> (RPvoid)cl; }
  1569.  
  1570. inline Ropstream operator << ( Ropstream os, RTMDIClient cl )
  1571.     { return os << (RTStreamable)cl; }
  1572. inline Ropstream operator << ( Ropstream os, PTMDIClient cl )
  1573.     { return os << (PTStreamable)cl; }
  1574.  
  1575. /* --------------------------------------------------------
  1576.   TMDIFrame object
  1577.   -------------------------------------------------------- */
  1578.  
  1579. class _EXPORT TMDIFrame : public TWindow
  1580. {
  1581. public:
  1582.     PTMDIClient ClientWnd;     // MDI client window
  1583.     int ChildMenuPos;          // menu position for child menu
  1584.     PTWindow ActiveChild;
  1585.  
  1586.     TMDIFrame(LPSTR ATitle, LPSTR MenuName, PTModule AModule = NULL);
  1587.     TMDIFrame(LPSTR ATitle, int MenuId, PTModule AModule = NULL);
  1588.     TMDIFrame(HWND AnHWindow, HWND ClientHWnd, PTModule AModule = NULL);
  1589.     virtual ~TMDIFrame();
  1590.  
  1591.     /* Constructs the TMDIFrame's MDI client window. */
  1592.     virtual void InitClientWindow()
  1593.         { ClientWnd = new TMDIClient(this); }
  1594.  
  1595.     /* Returns a pointer to the TMDIFrame's MDI client window. */
  1596.     virtual PTMDIClient GetClient()
  1597.         { return ClientWnd; }
  1598.  
  1599.     /* Constructs a new MDI child window object.  By default,
  1600.       constructs an instance of TWindow as an MDI child window object.
  1601.       Will almost always be redefined by descendants to construct an
  1602.       instance of a user-defined TWindow descendant as an MDI child
  1603.       window object. */
  1604.     virtual PTWindowsObject InitChild()
  1605.         { return new TWindow(this, ""); }
  1606.  
  1607.     virtual PTWindowsObject CreateChild();
  1608.  
  1609.     /* Tiles the MDI child windows by calling the TileChildren method
  1610.       of the MDI client window object. */
  1611.     virtual void TileChildren()
  1612.         { ClientWnd->TileChildren(); }
  1613.  
  1614.     /* Cascades the MDI child windows by calling the CascadeChildren
  1615.       method of the MDI client window object. */
  1616.     virtual void CascadeChildren()
  1617.         { ClientWnd->CascadeChildren(); }
  1618.  
  1619.     /* Arranges iconized MDI child windows by calling the
  1620.       ArrangeIcons method of the MDI client window object. */
  1621.     virtual void ArrangeIcons()
  1622.         { ClientWnd->ArrangeIcons(); }
  1623.  
  1624.     virtual BOOL CloseChildren();
  1625.     static PTStreamable build();
  1626.  
  1627. protected:
  1628.     virtual void GetWindowClass(WNDCLASS _FAR & AWndClass);
  1629.     virtual LPSTR GetClassName()
  1630.         { return "OWLMDIFrame31"; }
  1631.     virtual void SetupWindow();
  1632.  
  1633.     /* Since an MDI child doesn't get MDIACTIVATE messages when the
  1634.        frame gets (de)activated, call its ActivationResponse here. */
  1635.     virtual void WMActivate(RTMessage Msg)
  1636.         { TWindow::WMActivate(Msg);
  1637.           if ( ActiveChild )
  1638.             ActiveChild->ActivationResponse(
  1639.                    Msg.WParam, IsIconic(ActiveChild->HWindow)); }
  1640.  
  1641.     /* Responds to an incoming "CreateChild" command (with a
  1642.       CM_CREATECHILD command identifier) by calling CreateChild to
  1643.       construct and create a new MDI child. */
  1644.     virtual void CMCreateChild(RTMessage) =
  1645.                  [CM_FIRST + CM_CREATECHILD]
  1646.         { CreateChild(); }
  1647.  
  1648.     /* Responds to an incoming "Tile" command (with a CM_TILECHILDREN
  1649.       command identifier) by calling TileChildren to tile the MDI
  1650.       child windows. */
  1651.     virtual void CMTileChildren(RTMessage) =
  1652.                  [CM_FIRST + CM_TILECHILDREN]
  1653.         { TileChildren(); }
  1654.  
  1655.     /* Responds to an incoming "Cascade" command (with a
  1656.       CM_CASCADECHILDREN command identifier) by calling
  1657.       CascadeChildren to cascade the MDI  child windows. */
  1658.     virtual void CMCascadeChildren(RTMessage) =
  1659.                  [CM_FIRST + CM_CASCADECHILDREN]
  1660.         { CascadeChildren(); }
  1661.  
  1662.     /* Responds to an incoming "Arrange" command (with a
  1663.       CM_ARRANGEICONS command identifier) by calling ArrangeIcons
  1664.       to arrange the icons of the MDI child windows. */
  1665.     virtual void CMArrangeIcons(RTMessage) =
  1666.                  [CM_FIRST + CM_ARRANGEICONS]
  1667.         { ArrangeIcons(); }
  1668.  
  1669.     /* Responds to an incoming "CloseAll" command (with a
  1670.       CM_CLOSECHILDREN command identifier) by calling CloseChildren
  1671.       to close the MDI child windows. */
  1672.     virtual void CMCloseChildren(RTMessage) =
  1673.                  [CM_FIRST + CM_CLOSECHILDREN]
  1674.         { CloseChildren(); }
  1675.  
  1676.     TMDIFrame(StreamableInit) : TWindow(streamableInit) {};
  1677.     virtual void write (Ropstream os);
  1678.     virtual Pvoid read (Ripstream is);
  1679.  
  1680. private:
  1681.     virtual const Pchar streamableName() const
  1682.         { return "TMDIFrame"; }
  1683. };
  1684.  
  1685. inline Ripstream operator >> ( Ripstream is, RTMDIFrame cl )
  1686.     { return is >> (RTStreamable)cl; }
  1687. inline Ripstream operator >> ( Ripstream is, RPTMDIFrame cl )
  1688.     { return is >> (RPvoid)cl; }
  1689.  
  1690. inline Ropstream operator << ( Ropstream os, RTMDIFrame cl )
  1691.     { return os << (RTStreamable)cl; }
  1692. inline Ropstream operator << ( Ropstream os, PTMDIFrame cl )
  1693.     { return os << (PTStreamable)cl; }
  1694.  
  1695. _CLASSDEF(TModule)
  1696.  
  1697. // Module Class
  1698.  
  1699. class _EXPORT TModule : public Object {
  1700. public:
  1701.  
  1702.     // Lib and WinMain args
  1703.     HINSTANCE        hInstance;
  1704.     LPSTR        lpCmdLine;
  1705.  
  1706.     int Status;
  1707.     LPSTR Name;
  1708.  
  1709. #if defined(WIN31)
  1710.     TModule(LPSTR AName, HINSTANCE AnInstance, LPSTR ACmdLine);
  1711. #endif
  1712. #if defined(WIN30)
  1713.     TModule(LPSTR AName, HINSTANCE_30 AnInstance, LPSTR ACmdLine);
  1714. #endif
  1715.     virtual ~TModule();
  1716.  
  1717.     BOOL LowMemory();
  1718.     void RestoreMemory();
  1719.     virtual PTWindowsObject ValidWindow(PTWindowsObject AWindowsObject);
  1720.     virtual PTWindowsObject MakeWindow(PTWindowsObject AWindowsObject);
  1721.     virtual int ExecDialog(PTWindowsObject ADialog);
  1722.     HWND GetClientHandle(HWND AnHWindow);
  1723.  
  1724. #if defined(WIN31)
  1725.     // windows 3.1 interface
  1726.     virtual PTWindowsObject GetParentObject(HWND ParentHandle);
  1727. #endif
  1728. #if defined(WIN30)
  1729.     // windows 3.0 interface
  1730.     virtual PTWindowsObject GetParentObject(HWND_30 ParentHandle);
  1731. #endif
  1732. #if (defined(WIN30) || defined(WIN31)) && !(defined(WIN30) && defined(WIN31))
  1733.     // this function is never called. it is used to pad the vtable so that
  1734.     // exactly two GetParentObject(...) definitions are always present.
  1735.     virtual PTWindowsObject GetParentObject(void *)
  1736.             { return NULL; }
  1737. #endif
  1738.     virtual void Error(int ErrorCode);
  1739.  
  1740.     // define pure virtual functions derived from Object class
  1741.     virtual classType        isA() const
  1742.         { return moduleClass; }
  1743.     virtual Pchar nameOf() const
  1744.         { return "TModule"; }
  1745.     virtual hashValueType hashValue() const
  1746.         {  return hashValueType(hInstance); }
  1747.     virtual int       isEqual(RCObject module)  const
  1748.             { return (hInstance == ((RTModule)module).hInstance); }
  1749.     virtual void      printOn(Rostream outputStream) const
  1750.             { outputStream << nameOf() << "{ hInstance = "
  1751.               << (void _FAR *)hInstance << " }\n"; }
  1752. private:
  1753.  
  1754.     PTWindowsObject __GetParentObject(HWND ParentHandle);
  1755.     void __TModule(LPSTR AName, HINSTANCE AnInstance, LPSTR ACmdLine);
  1756.  
  1757. };    // end of Module class
  1758.  
  1759. extern PTModule Module;
  1760.  
  1761. _CLASSDEF(TBDivider)
  1762.  
  1763. /* --------------------------------------------------------
  1764.   TBDivider object
  1765.   -------------------------------------------------------- */
  1766. class _EXPORT TBDivider : public TControl
  1767. {
  1768. public:
  1769.     TBDivider(PTWindowsObject AParent, int AnId, LPSTR AText,
  1770.             int X, int Y, int W, int H, BOOL IsVertical,
  1771.         BOOL IsBump, PTModule AModule = NULL);
  1772.     TBDivider(PTWindowsObject AParent, int ResourceId,
  1773.         PTModule AModule = NULL);
  1774.     static PTStreamable build();
  1775.  
  1776. protected:
  1777.     virtual LPSTR GetClassName()
  1778.         {return "BORSHADE";}
  1779.     TBDivider(StreamableInit) : TControl(streamableInit) {};
  1780.  
  1781. private:
  1782.     virtual const Pchar streamableName() const
  1783.         { return "TBDivider"; }
  1784. };
  1785.  
  1786. inline Ripstream operator >> ( Ripstream is, RTBDivider cl )
  1787.     { return is >> (RTStreamable)cl; }
  1788. inline Ripstream operator >> ( Ripstream is, RPTBDivider cl )
  1789.     { return is >> (RPvoid)cl; }
  1790.  
  1791. inline Ropstream operator << ( Ropstream os, RTBDivider cl )
  1792.     { return os << (RTStreamable)cl; }
  1793. inline Ropstream operator << ( Ropstream os, PTBDivider cl )
  1794.     { return os << (PTStreamable)cl; }
  1795.  
  1796. _CLASSDEF(TBStaticBmp)
  1797.  
  1798. /* --------------------------------------------------------
  1799.   TBStaticBmp object
  1800.   -------------------------------------------------------- */
  1801. class _EXPORT TBStaticBmp : public TControl
  1802. {
  1803. public:
  1804.     TBStaticBmp(PTWindowsObject AParent, int AnId, LPSTR AText,
  1805.             int X, int Y, int W, int H, PTModule AModule = NULL);
  1806.     TBStaticBmp(PTWindowsObject AParent, int ResourceId,
  1807.          PTModule AModule = NULL);
  1808.  
  1809.     static PTStreamable build();
  1810.  
  1811. protected:
  1812.     virtual LPSTR GetClassName()
  1813.         {return "BORBTN";}
  1814.     TBStaticBmp(StreamableInit) : TControl(streamableInit) {};
  1815.  
  1816. private:
  1817.     virtual const Pchar streamableName() const
  1818.         { return "TBStaticBmp"; }
  1819. };
  1820.  
  1821. inline Ripstream operator >> ( Ripstream is, RTBStaticBmp cl )
  1822.     { return is >> (RTStreamable)cl; }
  1823. inline Ripstream operator >> ( Ripstream is, RPTBStaticBmp cl )
  1824.     { return is >> (RPvoid)cl; }
  1825.  
  1826. inline Ropstream operator << ( Ropstream os, RTBStaticBmp cl )
  1827.     { return os << (RTStreamable)cl; }
  1828. inline Ropstream operator << ( Ropstream os, PTBStaticBmp cl )
  1829.     { return os << (PTStreamable)cl; }
  1830.  
  1831. /* --------------------------------------------------------
  1832.   TButton object
  1833.   -------------------------------------------------------- */
  1834.  
  1835. _CLASSDEF(TButton)
  1836.  
  1837. class _EXPORT TButton : public TControl
  1838. {
  1839. public:
  1840.     BOOL IsDefPB;
  1841.  
  1842.     TButton(PTWindowsObject AParent, int AnId, LPSTR AText,
  1843.             int X, int Y, int W, int H, BOOL IsDefault,
  1844.         PTModule AModule = NULL);
  1845.     TButton(PTWindowsObject AParent, int ResourceId,
  1846.         PTModule AModule = NULL);
  1847.  
  1848.     static PTStreamable build();
  1849.     virtual void write (Ropstream os);
  1850.     virtual Pvoid read (Ripstream is);
  1851.  
  1852. protected:
  1853.     BOOL IsCurrentDefPB;
  1854.  
  1855.     virtual LPSTR GetClassName()
  1856.         { return "BUTTON"; }
  1857.     virtual void SetupWindow();
  1858.  
  1859.     virtual void WMGetDlgCode(RTMessage Msg) =
  1860.                          [WM_FIRST + WM_GETDLGCODE];
  1861.     virtual void BMSetStyle(RTMessage Msg) = [WM_FIRST + BM_SETSTYLE];
  1862.  
  1863.     TButton(StreamableInit) : TControl(streamableInit) {};
  1864.  
  1865. private:
  1866.     virtual const Pchar streamableName() const
  1867.         { return "TButton"; }
  1868. };
  1869.  
  1870. inline Ripstream operator >> ( Ripstream is, RTButton cl )
  1871.     { return is >> (RTStreamable)cl; }
  1872. inline Ripstream operator >> ( Ripstream is, RPTButton cl )
  1873.     { return is >> (RPvoid)cl; }
  1874.  
  1875. inline Ropstream operator << ( Ropstream os, RTButton cl )
  1876.     { return os << (RTStreamable)cl; }
  1877. inline Ropstream operator << ( Ropstream os, PTButton cl )
  1878.     { return os << (PTStreamable)cl; }
  1879.  
  1880. /* --------------------------------------------------------
  1881.   TBButton object
  1882.   -------------------------------------------------------- */
  1883.  
  1884. _CLASSDEF(TBButton)
  1885.  
  1886. class _EXPORT TBButton : public TButton
  1887. {
  1888. public:
  1889.     TBButton(PTWindowsObject AParent, int AnId, LPSTR AText,
  1890.             int X, int Y, int W, int H, BOOL IsDefault,
  1891.         PTModule AModule = NULL);
  1892.     TBButton(PTWindowsObject AParent, int ResourceId,
  1893.         PTModule AModule = NULL);
  1894.     static PTStreamable build();
  1895.  
  1896. protected:
  1897.     virtual LPSTR GetClassName()
  1898.         {return "BORBTN";}
  1899.     TBButton(StreamableInit) : TButton(streamableInit) {};
  1900.  
  1901. private:
  1902.     virtual const Pchar streamableName() const
  1903.         { return "TBButton"; }
  1904. };
  1905.  
  1906. inline Ripstream operator >> ( Ripstream is, RTBButton cl )
  1907.     { return is >> (RTStreamable)cl; }
  1908. inline Ripstream operator >> ( Ripstream is, RPTBButton cl )
  1909.     { return is >> (RPvoid)cl; }
  1910.  
  1911. inline Ropstream operator << ( Ropstream os, RTBButton cl )
  1912.     { return os << (RTStreamable)cl; }
  1913. inline Ropstream operator << ( Ropstream os, PTBButton cl )
  1914.     { return os << (PTStreamable)cl; }
  1915.  
  1916. _CLASSDEF(TGroupBox)
  1917.  
  1918. /* --------------------------------------------------------
  1919.   TGroupBox object
  1920.   -------------------------------------------------------- */
  1921. class _EXPORT TGroupBox : public TControl
  1922. {
  1923. public:
  1924.     BOOL NotifyParent;
  1925.  
  1926.     TGroupBox(PTWindowsObject AParent, int AnId, LPSTR AText, int X,
  1927.               int Y, int W, int H, PTModule AModule = NULL);
  1928.     TGroupBox(PTWindowsObject AParent, int ResourceId,
  1929.               PTModule AModule = NULL);
  1930.     virtual void SelectionChanged(int ControlId);
  1931.  
  1932.     static PTStreamable build();
  1933.  
  1934. protected:
  1935.     virtual LPSTR GetClassName()
  1936.         { return "BUTTON"; }
  1937.  
  1938.     TGroupBox(StreamableInit) : TControl(streamableInit) {};
  1939.     virtual void write (Ropstream os);
  1940.     virtual Pvoid read (Ripstream is);
  1941.  
  1942. private:
  1943.     virtual const Pchar streamableName() const
  1944.         { return "TGroupBox"; }
  1945. };
  1946.  
  1947. inline Ripstream operator >> ( Ripstream is, RTGroupBox cl )
  1948.     { return is >> (RTStreamable )cl; }
  1949. inline Ripstream operator >> ( Ripstream is, RPTGroupBox cl )
  1950.     { return is >> (RPvoid)cl; }
  1951.  
  1952. inline Ropstream operator << ( Ropstream os, RTGroupBox cl )
  1953.     { return os << (RTStreamable )cl; }
  1954. inline Ropstream operator << ( Ropstream os, PTGroupBox cl )
  1955.     { return os << (PTStreamable )cl; }
  1956.  
  1957. _CLASSDEF(TBGroupBox)
  1958.  
  1959. /* --------------------------------------------------------
  1960.   TBGroupBox object
  1961.   -------------------------------------------------------- */
  1962. class _EXPORT TBGroupBox : public TGroupBox
  1963. {
  1964. public:
  1965.     TBGroupBox(PTWindowsObject AParent, int AnId, LPSTR AText, int X,
  1966.               int Y, int W, int H, PTModule AModule = NULL);
  1967.     TBGroupBox(PTWindowsObject AParent, int ResourceId,
  1968.             PTModule AModule = NULL);
  1969.  
  1970.     static PTStreamable build();
  1971.  
  1972. protected:
  1973.     virtual LPSTR GetClassName()
  1974.         {return "BORSHADE";}
  1975.     TBGroupBox(StreamableInit) : TGroupBox(streamableInit) {};
  1976.  
  1977. private:
  1978.     virtual const Pchar streamableName() const
  1979.         { return "TBGroupBox"; }
  1980. };
  1981.  
  1982. inline Ripstream operator >> ( Ripstream is, RTBGroupBox cl )
  1983.     { return is >> (RTStreamable )cl; }
  1984. inline Ripstream operator >> ( Ripstream is, RPTBGroupBox cl )
  1985.     { return is >> (RPvoid)cl; }
  1986.  
  1987. inline Ropstream operator << ( Ropstream os, RTBGroupBox cl )
  1988.     { return os << (RTStreamable )cl; }
  1989. inline Ropstream operator << ( Ropstream os, PTBGroupBox cl )
  1990.     { return os << (PTStreamable )cl; }
  1991.  
  1992. _CLASSDEF(TListBox)
  1993. _CLASSDEF(TListBoxData)
  1994.  
  1995. /* --------------------------------------------------------
  1996.   TListBox object
  1997.   -------------------------------------------------------- */
  1998.  
  1999. class _EXPORT TListBox : public TControl
  2000. {
  2001. public:
  2002.     TListBox(PTWindowsObject AParent, int AnId, int X, int Y,
  2003.              int W, int H, PTModule AModule = NULL);
  2004.     TListBox(PTWindowsObject AParent, int ResourceId, PTModule AModule = NULL)
  2005.              : TControl(AParent, ResourceId, AModule){};
  2006.  
  2007.     int AddString(LPSTR AString);
  2008.     int InsertString(LPSTR AString, int Index);
  2009.     int DeleteString(int Index);
  2010.     void ClearList();
  2011.     virtual WORD Transfer(Pvoid DataPtr, WORD TransferFlag);
  2012.     int GetCount();
  2013.     int FindString(LPSTR AString, int SearchIndex);
  2014.     int FindExactString(LPSTR AString, int SearchIndex);
  2015.     int GetString(LPSTR AString, int Index);
  2016.     int GetStringLen(int Index);
  2017.  
  2018.     // next four functions only for single-selection
  2019.     // list boxes (and combo boxes).
  2020.     int GetSelString(LPSTR AString, int MaxChars);
  2021.     int SetSelString(LPSTR AString, int SearchIndex);
  2022.     int GetSelIndex();
  2023.     int SetSelIndex(int Index);
  2024.  
  2025.     int GetSelCount();
  2026.  
  2027.     // next four functions only for multiple-selection list boxes.
  2028.     int GetSelStrings(LPSTR *Strings, int MaxCount, int MaxChars);
  2029.     int SetSelStrings(LPSTR *Prefixes, int NumSelections,
  2030.                       BOOL ShouldSet);
  2031.     int GetSelIndexes(Pint Indexes, int MaxCount);
  2032.     int SetSelIndexes(Pint Indexes, int NumSelections,
  2033.                       BOOL ShouldSet);
  2034.  
  2035.     static PTStreamable build();
  2036.  
  2037. protected:
  2038.     virtual LPSTR GetClassName()
  2039.         { return "LISTBOX"; }
  2040.     virtual WORD GetMsgID(WORD AMsg);
  2041.  
  2042.     TListBox(StreamableInit) : TControl(streamableInit) {};
  2043.  
  2044. private:
  2045.     virtual const Pchar streamableName() const
  2046.         { return "TListBox"; }
  2047. };
  2048.  
  2049. inline Ripstream operator >> ( Ripstream is, RTListBox cl )
  2050.     { return is >> (RTStreamable )cl; }
  2051. inline Ripstream operator >> ( Ripstream is, RPTListBox cl )
  2052.     { return is >> (RPvoid)cl; }
  2053.  
  2054. inline Ropstream operator << ( Ropstream os, RTListBox cl )
  2055.     { return os << (RTStreamable )cl; }
  2056. inline Ropstream operator << ( Ropstream os, PTListBox cl )
  2057.     { return os << (PTStreamable )cl; }
  2058.  
  2059. enum msgname {MN_ADDSTRING,    MN_INSERTSTRING, MN_DELETESTRING,
  2060.               MN_RESETCONTENT, MN_GETCOUNT,     MN_GETTEXT,
  2061.               MN_GETTEXTLEN,   MN_SELECTSTRING, MN_SETCURSEL,
  2062.               MN_GETCURSEL,    MN_FINDSTRING };
  2063.  
  2064. class _EXPORT TListBoxData
  2065. {
  2066. public:
  2067.     PArray Strings;
  2068.     PArray SelStrings;
  2069.     int SelCount;
  2070.  
  2071.     TListBoxData();
  2072.     ~TListBoxData();
  2073.     void AddString(Pchar AString, BOOL IsSelected = FALSE);
  2074.     void SelectString(LPSTR AString);
  2075.     void ResetSelections();
  2076.     int GetSelStringLength(int Index = 0);
  2077.     void GetSelString(LPSTR Buffer, int BufferSize, int Index = 0);
  2078. };
  2079.  
  2080. // TScrollBar transfer structure
  2081. struct TScrollBarData {
  2082.   int LowValue;
  2083.   int HighValue;
  2084.   int Position;
  2085. };
  2086.  
  2087. _CLASSDEF(TScrollBar)
  2088.  
  2089. /* --------------------------------------------------------
  2090.   TScrollBar object
  2091.   -------------------------------------------------------- */
  2092.  
  2093. class _EXPORT TScrollBar : public TControl
  2094. {
  2095. public:
  2096.     int LineMagnitude, PageMagnitude;
  2097.  
  2098.     TScrollBar(PTWindowsObject AParent, int AnId, int X, int Y, int W,
  2099.                int H, BOOL IsHScrollBar, PTModule AModule = NULL);
  2100.     TScrollBar(PTWindowsObject AParent, int ResourceId,
  2101.                PTModule AModule = NULL);
  2102.  
  2103.     void GetRange(Rint LoVal, Rint HiVal);
  2104.     int GetPosition();
  2105.     void SetRange(int LoVal, int HiVal);
  2106.     void SetPosition(int ThumbPos);
  2107.     int DeltaPos(int Delta);
  2108.     virtual WORD Transfer(Pvoid DataPtr, WORD TransferFlag);
  2109.  
  2110.     static PTStreamable build();
  2111.  
  2112. protected:
  2113.     virtual LPSTR GetClassName()
  2114.         { return "SCROLLBAR"; }
  2115.     virtual void SetupWindow();
  2116.  
  2117.     virtual void SBLineUp(RTMessage Msg) = [NF_FIRST + SB_LINEUP];
  2118.     virtual void SBLineDown(RTMessage Msg) = [NF_FIRST + SB_LINEDOWN];
  2119.     virtual void SBPageUp(RTMessage Msg) = [NF_FIRST + SB_PAGEUP];
  2120.     virtual void SBPageDown(RTMessage Msg) = [NF_FIRST + SB_PAGEDOWN];
  2121.     virtual void SBThumbPosition(RTMessage Msg) =
  2122.                                       [NF_FIRST + SB_THUMBPOSITION];
  2123.     virtual void SBThumbTrack(RTMessage Msg) = [NF_FIRST + SB_THUMBTRACK];
  2124.     virtual void SBTop(RTMessage Msg) = [NF_FIRST + SB_TOP];
  2125.     virtual void SBBottom(RTMessage Msg) = [NF_FIRST + SB_BOTTOM];
  2126.  
  2127.     TScrollBar(StreamableInit) : TControl(streamableInit) {};
  2128.     virtual void write (Ropstream os);
  2129.     virtual Pvoid read (Ripstream is);
  2130.  
  2131. private:
  2132.     virtual const Pchar streamableName() const
  2133.         { return "TScrollBar"; }
  2134. };
  2135.  
  2136. inline Ripstream operator >> ( Ripstream is, RTScrollBar cl )
  2137.     { return is >> (RTStreamable )cl; }
  2138. inline Ripstream operator >> ( Ripstream is, RPTScrollBar cl )
  2139.     { return is >> (RPvoid)cl; }
  2140.  
  2141. inline Ropstream operator << ( Ropstream os, RTScrollBar cl )
  2142.     { return os << (RTStreamable )cl; }
  2143. inline Ropstream operator << ( Ropstream os, PTScrollBar cl )
  2144.     { return os << (PTStreamable )cl; }
  2145.  
  2146.   /* TStatic */
  2147.  
  2148. _CLASSDEF(TStatic)
  2149.  
  2150. class _EXPORT TStatic : public TControl
  2151. {
  2152. public:
  2153.     WORD TextLen;
  2154.  
  2155.     TStatic(PTWindowsObject AParent, int AnId, LPSTR ATitle, int X,
  2156.             int Y, int W, int H, WORD ATextLen, PTModule AModule = NULL);
  2157.     TStatic(PTWindowsObject AParent, int ResourceId, WORD ATextLen,
  2158.             PTModule AModule = NULL);
  2159.  
  2160.     /* Returns the length of the control's text. */
  2161.     int GetTextLen()
  2162.         { return GetWindowTextLength(HWindow); }
  2163.  
  2164.     /* Fills the passed string with the text of the associated text
  2165.        control.  Returns the number of characters copied. */
  2166.     int GetText(LPSTR ATextString, int MaxChars)
  2167.         { return GetWindowText(HWindow, ATextString, MaxChars); }
  2168.  
  2169.     /* Sets the contents of the associated static text control to
  2170.        the passed string. */
  2171.     void SetText(LPSTR ATextString)
  2172.         { SetWindowText(HWindow, ATextString); }
  2173.  
  2174.     /* Clears the text of the associated static text control. */
  2175.     void Clear()
  2176.         { SetText(""); }
  2177.  
  2178.     virtual WORD Transfer(Pvoid DataPtr, WORD TransferFlag);
  2179.  
  2180.     virtual Pchar nameOf() const
  2181.         { return "TStatic"; }
  2182.  
  2183.     static PTStreamable build();
  2184.  
  2185. protected:
  2186.     virtual LPSTR GetClassName()
  2187.         { return "STATIC"; }
  2188.  
  2189.     TStatic(StreamableInit) : TControl(streamableInit) {};
  2190.     virtual void write (Ropstream os);
  2191.     virtual Pvoid read (Ripstream is);
  2192. private:
  2193.     virtual const Pchar streamableName() const
  2194.         { return "TStatic"; }
  2195. };
  2196.  
  2197. inline Ripstream operator >> ( Ripstream is, RTStatic cl )
  2198.     { return is >> (RTStreamable)cl; }
  2199. inline Ripstream operator >> ( Ripstream is, RPTStatic cl )
  2200.     { return is >> (RPvoid)cl; }
  2201.  
  2202. inline Ropstream operator << ( Ropstream os, RTStatic cl )
  2203.     { return os << (RTStreamable)cl; }
  2204. inline Ropstream operator << ( Ropstream os, PTStatic cl )
  2205.     { return os << (PTStreamable)cl; }
  2206.  
  2207. _CLASSDEF(TComboBox)
  2208. _CLASSDEF(TComboBoxData)
  2209.  
  2210. /* --------------------------------------------------------
  2211.   TComboBox object
  2212.   -------------------------------------------------------- */
  2213.  
  2214. class _EXPORT TComboBox : public TListBox
  2215. {
  2216. public:
  2217.     WORD TextLen;
  2218.  
  2219.     TComboBox(PTWindowsObject AParent, int AnId, int X, int Y, int W,
  2220.               int H, DWORD AStyle, WORD ATextLen, PTModule AModule = NULL);
  2221.     TComboBox(PTWindowsObject AParent, int ResourceId, WORD ATextLen,
  2222.               PTModule AModule = NULL);
  2223.  
  2224.     /* Returns the length of the associated edit control's text. */
  2225.     int GetTextLen()
  2226.         { return GetWindowTextLength(HWindow); }
  2227.  
  2228.     /* Fills the supplied string with the text of the associated
  2229.        edit control. Returns the number of characters copied. */
  2230.     int GetText(LPSTR AString, int MaxChars)
  2231.         { return GetWindowText(HWindow, AString, MaxChars); }
  2232.  
  2233.     void SetText(LPSTR AString);
  2234.  
  2235.     /* Selects characters in the edit control of the combo box
  2236.        which are between StartPos and EndPos. Returns CB_ERR if
  2237.        the combo box does not have an edit control. */
  2238.     int SetEditSel(int StartPos, int EndPos)
  2239.         { return (int)SendMessage(HWindow, CB_SETEDITSEL,
  2240.                       0, MAKELONG(StartPos, EndPos)); }
  2241.  
  2242.     int GetEditSel(Rint StartPos, Rint EndPos);
  2243.  
  2244.     /* Clears the text of the associated edit control. */
  2245.     void Clear()
  2246.         { SetText(""); }
  2247.  
  2248.     void ShowList();
  2249.     void HideList();
  2250.     virtual WORD Transfer(Pvoid DataPtr, WORD TransferFlag);
  2251.     virtual Pchar nameOf() const
  2252.         { return "TComboBox"; }
  2253.  
  2254.     static PTStreamable build();
  2255.  
  2256. protected:
  2257.     virtual LPSTR GetClassName()
  2258.         {return "COMBOBOX";}
  2259.     virtual WORD GetMsgID(WORD AnId);
  2260.     virtual void SetupWindow();
  2261.  
  2262.     TComboBox(StreamableInit) : TListBox(streamableInit) {};
  2263.     virtual void write (Ropstream os);
  2264.     virtual Pvoid read (Ripstream is);
  2265.  
  2266. private:
  2267.     virtual const Pchar streamableName() const
  2268.         { return "TComboBox"; }
  2269. };
  2270.  
  2271. inline Ripstream operator >> ( Ripstream is, RTComboBox cl )
  2272.     { return is >> (RTStreamable )cl; }
  2273. inline Ripstream operator >> ( Ripstream is, RPTComboBox cl )
  2274.     { return is >> (RPvoid)cl; }
  2275.  
  2276. inline Ropstream operator << ( Ropstream os, RTComboBox cl )
  2277.     { return os << (RTStreamable )cl; }
  2278. inline Ropstream operator << ( Ropstream os, PTComboBox cl )
  2279.     { return os << (PTStreamable )cl; }
  2280.  
  2281. class _EXPORT TComboBoxData
  2282. {
  2283. public:
  2284.     PArray Strings;
  2285.     Pchar Selection;
  2286.  
  2287.     TComboBoxData();
  2288.     ~TComboBoxData();
  2289.     void AddString(Pchar AString, BOOL IsSelected = FALSE);
  2290. };
  2291.  
  2292. /* --------------------------------------------------------
  2293.   TCheckBox object
  2294.   -------------------------------------------------------- */
  2295.  
  2296. _CLASSDEF(TCheckBox)
  2297.  
  2298. class _EXPORT TCheckBox : public TButton
  2299. {
  2300. public:
  2301.     PTGroupBox Group;
  2302.  
  2303.     TCheckBox(PTWindowsObject AParent,int AnId, LPSTR ATitle, int X,
  2304.               int Y ,int W, int H, PTGroupBox AGroup,
  2305.           PTModule AModule = NULL);
  2306.     TCheckBox(PTWindowsObject AParent, int ResourceId,
  2307.               PTGroupBox AGroup, PTModule AModule = NULL);
  2308.     void Check();
  2309.     void Uncheck();
  2310.     void Toggle();
  2311.     WORD GetCheck();
  2312.     void SetCheck(WORD CheckFlag);
  2313.     virtual WORD Transfer(Pvoid DataPtr, WORD TransferFlag);
  2314.  
  2315.     static PTStreamable build();
  2316.  
  2317. protected:
  2318.     virtual void BNClicked(RTMessage Msg) = [NF_FIRST + BN_CLICKED];
  2319.  
  2320.     /* Override TButton's processing so drawable check boxes and radio
  2321.        buttons work properly. */
  2322.     virtual void WMGetDlgCode(RTMessage Msg) =
  2323.                          [WM_FIRST + WM_GETDLGCODE]
  2324.         { DefWndProc(Msg); }
  2325.  
  2326.     TCheckBox(StreamableInit) : TButton(streamableInit) {};
  2327.     virtual void write (Ropstream os);
  2328.     virtual Pvoid read (Ripstream is);
  2329.  
  2330. private:
  2331.     virtual const Pchar streamableName() const
  2332.         { return "TCheckBox"; }
  2333. };
  2334.  
  2335. inline Ripstream operator >> ( Ripstream is, RTCheckBox cl )
  2336.     { return is >> (RTStreamable )cl; }
  2337. inline Ripstream operator >> ( Ripstream is, RPTCheckBox cl )
  2338.     { return is >> (RPvoid)cl; }
  2339.  
  2340. inline Ropstream operator << ( Ropstream os, RTCheckBox cl )
  2341.     { return os << (RTStreamable )cl; }
  2342. inline Ropstream operator << ( Ropstream os, PTCheckBox cl )
  2343.     { return os << (PTStreamable )cl; }
  2344.  
  2345. _CLASSDEF(TBCheckBox)
  2346.  
  2347. /* --------------------------------------------------------
  2348.   TBCheckBox object
  2349.   -------------------------------------------------------- */
  2350.  
  2351. class _EXPORT TBCheckBox : public TCheckBox
  2352. {
  2353. public:
  2354.     TBCheckBox(PTWindowsObject AParent,int AnId, LPSTR ATitle, int X,
  2355.         int Y ,int W, int H, PTGroupBox AGroup,
  2356.         PTModule AModule = NULL);
  2357.     TBCheckBox(PTWindowsObject AParent, int ResourceId,
  2358.             PTGroupBox AGroup, PTModule AModule = NULL);
  2359.     static PTStreamable build();
  2360.  
  2361. protected:
  2362.     virtual LPSTR GetClassName()
  2363.         {return "BORCHECK";}
  2364.     TBCheckBox(StreamableInit) : TCheckBox(streamableInit) {};
  2365.  
  2366. private:
  2367.     virtual const Pchar streamableName() const
  2368.         { return "TBCheckBox"; }
  2369. };
  2370.  
  2371. inline Ripstream operator >> ( Ripstream is, RTBCheckBox cl )
  2372.     { return is >> (RTStreamable)cl; }
  2373. inline Ripstream operator >> ( Ripstream is, RPTBCheckBox cl )
  2374.     { return is >> (RPvoid)cl; }
  2375.  
  2376. inline Ropstream operator << ( Ropstream os, RTBCheckBox cl )
  2377.     { return os << (RTStreamable)cl; }
  2378. inline Ropstream operator << ( Ropstream os, PTBCheckBox cl )
  2379.     { return os << (PTStreamable)cl; }
  2380.  
  2381. _CLASSDEF(TRadioButton)
  2382.  
  2383. /* --------------------------------------------------------
  2384.   TRadioButton object
  2385.   -------------------------------------------------------- */
  2386. class _EXPORT TRadioButton : public TCheckBox
  2387. {
  2388. public:
  2389.     TRadioButton(PTWindowsObject AParent, int AnId, LPSTR ATitle,
  2390.                int X, int Y, int W, int H, PTGroupBox AGroup,
  2391.                PTModule AModule = NULL);
  2392.  
  2393.     TRadioButton(PTWindowsObject AParent, int ResourceId, PTGroupBox AGroup,
  2394.                PTModule AModule = NULL)
  2395.               : TCheckBox(AParent, ResourceId, AGroup, AModule){};
  2396.  
  2397.     static PTStreamable build();
  2398.  
  2399. protected:
  2400.     virtual void BNClicked(RTMessage Msg) = [NF_FIRST + BN_CLICKED];
  2401.  
  2402.     TRadioButton(StreamableInit) : TCheckBox(streamableInit) {};
  2403.  
  2404. private:
  2405.     virtual const Pchar streamableName() const
  2406.         { return "TRadioButton"; }
  2407. };
  2408.  
  2409. inline Ripstream operator >> ( Ripstream is, RTRadioButton cl )
  2410.     { return is >> (RTStreamable)cl; }
  2411. inline Ripstream operator >> ( Ripstream is, RPTRadioButton cl )
  2412.     { return is >> (RPvoid)cl; }
  2413.  
  2414. inline Ropstream operator << ( Ropstream os, RTRadioButton cl )
  2415.     { return os << (RTStreamable)cl; }
  2416. inline Ropstream operator << ( Ropstream os, PTRadioButton cl )
  2417.     { return os << (PTStreamable)cl; }
  2418.  
  2419. _CLASSDEF(TBRadioButton)
  2420.  
  2421. /* --------------------------------------------------------
  2422.   TBRadioButton object
  2423.   -------------------------------------------------------- */
  2424.  
  2425. class _EXPORT TBRadioButton : public TRadioButton
  2426. {
  2427. public:
  2428.   TBRadioButton(PTWindowsObject AParent, int AnId, LPSTR ATitle,
  2429.                  int X, int Y, int W, int H, PTGroupBox AGroup,
  2430.          PTModule AModule = NULL);
  2431.   TBRadioButton(PTWindowsObject AParent, int ResourceId, PTGroupBox AGroup,
  2432.          PTModule AModule = NULL)
  2433.               : TRadioButton(AParent, ResourceId, AGroup, AModule){};
  2434.   static PTStreamable build();
  2435.  
  2436. protected:
  2437.   virtual LPSTR GetClassName()
  2438.       {return "BORRADIO";}
  2439.   TBRadioButton(StreamableInit) : TRadioButton(streamableInit) {};
  2440.  
  2441. private:
  2442.     virtual const Pchar streamableName() const
  2443.         { return "TBRadioButton"; }
  2444. };
  2445.  
  2446. inline Ripstream operator >> ( Ripstream is, RTBRadioButton cl )
  2447.     { return is >> (RTStreamable)cl; }
  2448. inline Ripstream operator >> ( Ripstream is, RPTBRadioButton cl )
  2449.     { return is >> (RPvoid)cl; }
  2450.  
  2451. inline Ropstream operator << ( Ropstream os, RTBRadioButton cl )
  2452.     { return os << (RTStreamable)cl; }
  2453. inline Ropstream operator << ( Ropstream os, PTBRadioButton cl )
  2454.     { return os << (PTStreamable)cl; }
  2455.  
  2456. _CLASSDEF(TBStatic)
  2457.  
  2458. /* TBStatic */
  2459.  
  2460. class _EXPORT TBStatic : public TStatic
  2461. {
  2462. public:
  2463.     TBStatic(PTWindowsObject AParent, int AnId, LPSTR ATitle, int X,
  2464.             int Y, int W, int H, WORD ATextLen, PTModule AModule = NULL);
  2465.     TBStatic(PTWindowsObject AParent, int ResourceId, WORD ATextLen,
  2466.           PTModule AModule = NULL);
  2467.     virtual Pchar nameOf() const
  2468.         { return "TBStatic"; }
  2469.  
  2470.     static PTStreamable build();
  2471.  
  2472. protected:
  2473.     virtual LPSTR GetClassName()
  2474.         {return "BORSTATIC";}
  2475.     TBStatic(StreamableInit) : TStatic(streamableInit) {};
  2476.  
  2477. private:
  2478.     virtual const Pchar streamableName() const
  2479.         { return "TBStatic"; }
  2480. };
  2481.  
  2482. inline Ripstream operator >> ( Ripstream is, RTBStatic cl )
  2483.     { return is >> (RTStreamable)cl; }
  2484. inline Ripstream operator >> ( Ripstream is, RPTBStatic cl )
  2485.     { return is >> (RPvoid)cl; }
  2486.  
  2487. inline Ropstream operator << ( Ropstream os, RTBStatic cl )
  2488.     { return os << (RTStreamable)cl; }
  2489. inline Ropstream operator << ( Ropstream os, PTBStatic cl )
  2490.     { return os << (PTStreamable)cl; }
  2491.  
  2492. _CLASSDEF(TEdit)
  2493.  
  2494.   /* TEdit */
  2495. class _EXPORT TEdit : public TStatic
  2496. {
  2497. public:
  2498.     TEdit(PTWindowsObject AParent, int AnId, LPSTR AText, int X,
  2499.           int Y, int W, int H, WORD ATextLen, BOOL Multiline,
  2500.           PTModule AModule = NULL);
  2501.     TEdit(PTWindowsObject AParent, int ResourceId, WORD ATextLen,
  2502.           PTModule AModule = NULL);
  2503.  
  2504.     void Undo();
  2505.     BOOL CanUndo();
  2506.     void Paste();
  2507.     void Copy();
  2508.     void Cut();
  2509.     int GetNumLines();
  2510.     int GetLineLength(int LineNumber);
  2511.     BOOL GetLine(LPSTR ATextString, int StrSize, int LineNumber);
  2512.     void GetSubText(LPSTR ATextString, int StartPos, int EndPos);
  2513.     BOOL DeleteSubText(int StartPos, int EndPos);
  2514.     BOOL DeleteLine(int LineNumber);
  2515.     void GetSelection(Rint StartPos, Rint EndPos);
  2516.     BOOL DeleteSelection();
  2517.     BOOL IsModified();
  2518.     void ClearModify();
  2519.     int GetLineFromPos(int CharPos);
  2520.     int GetLineIndex(int LineNumber);
  2521.     void Scroll(int HorizontalUnit, int VerticalUnit);
  2522.     BOOL SetSelection(int StartPos, int EndPos);
  2523.     void Insert(LPSTR ATextString);
  2524.     int Search(int StartPos, LPSTR AText, BOOL CaseSensitive);
  2525.  
  2526.     static PTStreamable build();
  2527.  
  2528. protected:
  2529.     virtual LPSTR GetClassName()
  2530.     { return "EDIT"; }
  2531.     virtual void SetupWindow();
  2532.     virtual void CMEditCut(RTMessage Msg) = [CM_FIRST + CM_EDITCUT];
  2533.     virtual void CMEditCopy(RTMessage Msg) = [CM_FIRST + CM_EDITCOPY];
  2534.     virtual void CMEditPaste(RTMessage Msg) = [CM_FIRST + CM_EDITPASTE];
  2535.     virtual void CMEditDelete(RTMessage Msg) =
  2536.                                         [CM_FIRST + CM_EDITDELETE];
  2537.     virtual void CMEditClear(RTMessage Msg) = [CM_FIRST + CM_EDITCLEAR];
  2538.     virtual void CMEditUndo(RTMessage Msg) = [CM_FIRST + CM_EDITUNDO];
  2539.     virtual void ENErrSpace(RTMessage Msg) = [NF_FIRST + EN_ERRSPACE];
  2540.  
  2541.     TEdit(StreamableInit) : TStatic(streamableInit) {};
  2542.  
  2543. private:
  2544.     virtual const Pchar streamableName() const
  2545.         { return "TEdit"; }
  2546. };
  2547.  
  2548. inline Ripstream operator >> ( Ripstream is, RTEdit cl )
  2549.     { return is >> (RTStreamable )cl; }
  2550. inline Ripstream operator >> ( Ripstream is, RPTEdit cl )
  2551.     { return is >> (RPvoid)cl; }
  2552.  
  2553. inline Ropstream operator << ( Ropstream os, RTEdit cl )
  2554.     { return os << (RTStreamable )cl; }
  2555. inline Ropstream operator << ( Ropstream os, PTEdit cl )
  2556.     { return os << (PTStreamable )cl; }
  2557.  
  2558. struct _CLASSTYPE TSearchStruct { // _CLASSTYPE needed for BC++ 2.0
  2559.   char SearchText[81];
  2560.   BOOL CaseSensitive;
  2561.   char ReplaceText[81];
  2562.   BOOL ReplaceAll;
  2563.   BOOL PromptOnReplace;
  2564. };
  2565.  
  2566. _CLASSDEF(TEditWindow)
  2567. _CLASSDEF(TSearchDialog)
  2568.  
  2569. /* TEditWindow declaration */
  2570.  
  2571. class _EXPORT TEditWindow : public TWindow
  2572. {
  2573. public:
  2574.     PTEdit Editor;
  2575.     TSearchStruct SearchStruct;
  2576.     BOOL IsReplaceOp; // True if the search is a search and replace.
  2577.  
  2578.     TEditWindow(PTWindowsObject AParent, LPSTR ATitle,
  2579.         PTModule AModule = NULL);
  2580.     void DoSearch();
  2581.  
  2582.     static PTStreamable build();
  2583.  
  2584. protected:
  2585.     virtual void WMSize(RTMessage Msg) = [WM_FIRST + WM_SIZE];
  2586.     virtual void WMSetFocus(RTMessage Msg) = [WM_FIRST + WM_SETFOCUS];
  2587.     virtual void CMEditFind(RTMessage Msg) = [CM_FIRST + CM_EDITFIND];
  2588.     virtual void CMEditFindNext(RTMessage Msg) =
  2589.                                [CM_FIRST + CM_EDITFINDNEXT];
  2590.     virtual void CMEditReplace(RTMessage Msg) =
  2591.                                [CM_FIRST + CM_EDITREPLACE];
  2592.  
  2593.     TEditWindow(StreamableInit) : TWindow(streamableInit) {};
  2594.     virtual void write (Ropstream os);
  2595.     virtual Pvoid read (Ripstream is);
  2596.  
  2597. private:
  2598.     virtual const Pchar streamableName() const
  2599.         { return "TEditWindow"; }
  2600. };
  2601.  
  2602. inline Ripstream operator >> ( Ripstream is, RTEditWindow cl )
  2603.     { return is >> (RTStreamable )cl; }
  2604. inline Ripstream operator >> ( Ripstream is, RPTEditWindow cl )
  2605.     { return is >> (RPvoid)cl; }
  2606.  
  2607. inline Ropstream operator << ( Ropstream os, RTEditWindow cl )
  2608.     { return os << (RTStreamable )cl; }
  2609. inline Ropstream operator << ( Ropstream os, PTEditWindow cl )
  2610.     { return os << (PTStreamable )cl; }
  2611.  
  2612. class _EXPORT TSearchDialog : public TDialog
  2613. {
  2614. public:
  2615.   TSearchDialog(PTWindowsObject AParent, int ResourceId,
  2616.                 TSearchStruct _FAR &SearchStruct,
  2617.                 PTModule AModule = NULL);
  2618. };
  2619.  
  2620.  /* TFileWindow */
  2621.  
  2622. _CLASSDEF(TFileWindow)
  2623.  
  2624. class _EXPORT TFileWindow : public TEditWindow
  2625. {
  2626. public:
  2627.     LPSTR FileName;
  2628.     BOOL IsNewFile;
  2629.  
  2630.     TFileWindow(PTWindowsObject AParent, LPSTR ATitle, LPSTR AFileName,
  2631.                 PTModule AModule = NULL);
  2632.     virtual ~TFileWindow();
  2633.  
  2634.     virtual BOOL CanClear();
  2635.     virtual BOOL CanClose();
  2636.     void NewFile();
  2637.     void Open();
  2638.     BOOL Read();
  2639.     void ReplaceWith(LPSTR AFileName);
  2640.     BOOL Save();
  2641.     BOOL SaveAs();
  2642.     void SetFileName(LPSTR AFileName);
  2643.     BOOL Write();
  2644.  
  2645.     static PTStreamable build();
  2646.  
  2647. protected:
  2648.     virtual void SetupWindow();
  2649.     virtual void CMFileNew(RTMessage Msg) = [CM_FIRST + CM_FILENEW];
  2650.     virtual void CMFileOpen(RTMessage Msg) = [CM_FIRST + CM_FILEOPEN];
  2651.     virtual void CMFileSave(RTMessage Msg) = [CM_FIRST + CM_FILESAVE];
  2652.     virtual void CMFileSaveAs(RTMessage Msg) =
  2653.                                          [CM_FIRST + CM_FILESAVEAS];
  2654.  
  2655.     TFileWindow(StreamableInit) : TEditWindow(streamableInit) {};
  2656.     virtual void write (Ropstream os);
  2657.     virtual Pvoid read (Ripstream is);
  2658.  
  2659. private:
  2660.     virtual const Pchar streamableName() const
  2661.         { return "TFileWindow"; }
  2662. };
  2663.  
  2664. inline Ripstream operator >> ( Ripstream is, RTFileWindow cl )
  2665.     { return is >> (RTStreamable)cl; }
  2666. inline Ripstream operator >> ( Ripstream is, RPTFileWindow cl )
  2667.     { return is >> (RPvoid)cl; }
  2668.  
  2669. inline Ropstream operator << ( Ropstream os, RTFileWindow cl )
  2670.     { return os << (RTStreamable)cl; }
  2671. inline Ropstream operator << ( Ropstream os, PTFileWindow cl )
  2672.     { return os << (PTStreamable)cl; }
  2673.  
  2674. // Application Class
  2675.  
  2676. _CLASSDEF(TApplication)
  2677.  
  2678. class _EXPORT TApplication : public TModule {
  2679. public:
  2680.  
  2681.     // WinMain arguments
  2682.     HINSTANCE         hPrevInstance;
  2683.     int            nCmdShow;
  2684.  
  2685.     PTWindowsObject MainWindow;
  2686.     HACCEL HAccTable;
  2687.     PTWindowsObject KBHandlerWnd;
  2688.  
  2689. #if defined(WIN31)
  2690.     // windows 3.1 interface
  2691.     TApplication(LPSTR AName, HINSTANCE AnInstance,
  2692.               HINSTANCE APrevInstance, LPSTR ACmdLine, int ACmdShow);
  2693. #endif
  2694. #if defined(WIN30)
  2695.     // windows 3.0 interface
  2696.     TApplication(LPSTR AName, HINSTANCE_30 AnInstance,
  2697.               HINSTANCE_30 APrevInstance, LPSTR ACmdLine, int ACmdShow);
  2698. #endif
  2699.  
  2700.     ~TApplication();
  2701.     virtual void Run();
  2702.     virtual BOOL CanClose();
  2703.     void SetKBHandler(PTWindowsObject AWindowsObject);
  2704.  
  2705.     // define pure virtual functions derived from Object class
  2706.     virtual classType        isA() const
  2707.          { return applicationClass; }
  2708.     virtual Pchar nameOf() const
  2709.          {return "TApplication";}
  2710. protected:
  2711.     virtual void InitApplication();  // "first"-instance initialization
  2712.     virtual void InitInstance();     // each-instance initialization
  2713.     virtual void InitMainWindow();   // init application main window
  2714.  
  2715.     virtual void MessageLoop();
  2716.     /* IdleAction may be redefined in derived classes to do some action when
  2717.        there are no messages pending. */
  2718.     virtual void IdleAction() {}
  2719.     virtual BOOL ProcessAppMsg(LPMSG PMessage);
  2720.     virtual BOOL ProcessDlgMsg(LPMSG PMessage);
  2721.     virtual BOOL ProcessAccels(LPMSG PMessage);
  2722.     virtual BOOL ProcessMDIAccels(LPMSG PMessage);
  2723.  
  2724. private:
  2725.  
  2726.     void __TApplication(LPSTR AName, HINSTANCE AnInstance,
  2727.                     HINSTANCE APrevInstance, LPSTR ACmdLine, int ACmdShow);
  2728.  
  2729. };    // end of Application class
  2730.  
  2731. /* Performs special handling for the message last retrieved.
  2732.    Translates keyboard input messages into control selections or
  2733.    command messages, when appropriate.  Dispatches message, if
  2734.    translated. */
  2735. inline BOOL TApplication::ProcessAppMsg(LPMSG PMessage)
  2736.        { if ( KBHandlerWnd )
  2737.            if ( KBHandlerWnd->IsFlagSet(WB_MDICHILD) )
  2738.              return ProcessMDIAccels(PMessage) ||
  2739.                     ProcessDlgMsg(PMessage) ||
  2740.                     ProcessAccels(PMessage);
  2741.            else
  2742.             return ProcessDlgMsg(PMessage) ||
  2743.                    ProcessMDIAccels(PMessage) ||
  2744.                    ProcessAccels(PMessage);
  2745.          else
  2746.            return ProcessMDIAccels(PMessage) ||
  2747.                   ProcessAccels(PMessage); }
  2748.  
  2749. /* Attempts to translate a message into a control selection if the
  2750.    currently active OWL window has requested "keyboard handling".
  2751.    (Some keyboard input messages are translated into control
  2752.    selection messages). Dispatches message, if translated. */
  2753. inline BOOL TApplication::ProcessDlgMsg(LPMSG PMessage)
  2754.     { if (KBHandlerWnd && KBHandlerWnd->HWindow)
  2755.            return IsDialogMessage(KBHandlerWnd->HWindow, PMessage);
  2756.          else
  2757.            return FALSE; }
  2758.  
  2759. /* Attempts to translate a message into a command message if the
  2760.    TApplication has loaded an accelerator table. (Keyboard input
  2761.    messages for which an entry exists in the accelerator table are
  2762.    translated into command messages.)  Dispatches message, if
  2763.    translated.  (Translation of MDI accelerator messages is performed
  2764.    in ProcessMDIAccels function.) */
  2765. inline BOOL TApplication::ProcessAccels(LPMSG PMessage)
  2766.        { return HAccTable &&
  2767.          TranslateAccelerator(
  2768.                  MainWindow->HWindow, HAccTable, PMessage); }
  2769.  
  2770. /* Attempts to translate a message into a system command message
  2771.    for MDI TApplications (whose main window is a TMDIFrame). (Some
  2772.    keyboard input messages are translated into system commands for
  2773.    MDI applications). Dispatches message, if translated. */
  2774. inline BOOL TApplication::ProcessMDIAccels(LPMSG PMessage)
  2775.        { return (PTWindowsObject)(MainWindow->GetClient()) &&
  2776.            TranslateMDISysAccel(
  2777.             ((PTWindowsObject)(MainWindow->GetClient()))->HWindow, PMessage); }
  2778.  
  2779. /* Activates and deactivates "keyboard handling" (translation of
  2780.    keyboard input into control selections) for the currently active
  2781.    TWindowsObject by setting the KBHandlerWnd to the parameter passed.
  2782.    This function is called internally by the OWL whenever a OWL window
  2783.    is activated.  If "keyboard handling" has been requested for the
  2784.    TWindowsObject, the parameter passed is non-NULL, else NULL is
  2785.    passed.  "Keyboard handling" is requested, by default, for all
  2786.    modeless dialogs and may be requested for a TWindow via a call to
  2787.    its EnableKBHandler function. */
  2788. inline void TApplication::SetKBHandler(PTWindowsObject AWindowsObject)
  2789.        { KBHandlerWnd = AWindowsObject; }
  2790.  
  2791. extern PTApplication _EXPOWLFUNC GetApplicationObject();
  2792.  
  2793. const int DEFAULT_DICTIONARY_SIZE = 10;
  2794. const int DEFAULT_DICTIONARY_INCREMENT = 10;
  2795.  
  2796. class _CLASSTYPE TAppDictionaryEntry
  2797. {
  2798. public:
  2799.     HANDLE hTask;
  2800.     PTApplication pApplication;
  2801. };
  2802.  
  2803. class _CLASSTYPE TAppDictionary
  2804. {
  2805.     int NumEntries;
  2806.     TAppDictionaryEntry * Table;
  2807. public:
  2808.     TAppDictionary(int InitialCount = DEFAULT_DICTIONARY_SIZE);
  2809.     ~TAppDictionary();
  2810.  
  2811.     static TAppDictionaryEntry * AllocTable(int Count);
  2812.     static void FreeTable(TAppDictionaryEntry *pTable);
  2813.  
  2814.     TAppDictionaryEntry *GrowTable(int Increment =
  2815.                                    DEFAULT_DICTIONARY_INCREMENT);
  2816.     void Add(PTApplication pApplication);
  2817.     void Delete();
  2818.     PTApplication Lookup();
  2819. };
  2820.  
  2821. extern unsigned short far  _EXPOWLFUNC OWLGetVersion();
  2822.  
  2823. const unsigned short OWLVersion = 0x0110; // Version 1.1
  2824.  
  2825. #endif  // __OWL1ALL_H
  2826.  
  2827.