home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 7 / 07.iso / c / c082_122 / 2.ddi / TVINC.ZIP / STDDLG.H < prev    next >
Encoding:
C/C++ Source or Header  |  1992-06-10  |  19.2 KB  |  724 lines
  1. /* ------------------------------------------------------------------------*/
  2. /*                                                                         */
  3. /*   STDDLG.H                                                              */
  4. /*                                                                         */
  5. /*   Copyright (c) Borland International 1991                              */
  6. /*   All Rights Reserved.                                                  */
  7. /*                                                                         */
  8. /*   defines the classes TFileInputLine, TFileCollection, TSortedListBox,  */
  9. /*   TFileList, TFileInfoPane, TFileDialog, TDirCollection, TDirListBox,   */
  10. /*   and TChDirDialog                                                      */
  11. /*                                                                         */
  12. /* ------------------------------------------------------------------------*/
  13.  
  14. #pragma warn -hid
  15.  
  16. #pragma option -Vo-
  17. #if defined( __BCOPT__ )
  18. #pragma option -po-
  19. #endif
  20.  
  21. #if !defined( __FILE_CMDS )
  22. #define __FILE_CMDS
  23.  
  24. const
  25.  
  26. //  Commands
  27.  
  28.     cmFileOpen    = 1001,   // Returned from TFileDialog when Open pressed
  29.     cmFileReplace = 1002,   // Returned from TFileDialog when Replace pressed
  30.     cmFileClear   = 1003,   // Returned from TFileDialog when Clear pressed
  31.     cmFileInit    = 1004,   // Used by TFileDialog internally
  32.     cmChangeDir   = 1005,   // Used by TChDirDialog internally
  33.     cmRevert      = 1006,   // Used by TChDirDialog internally
  34.  
  35. //  Messages
  36.  
  37.     cmFileFocused = 102,    // A new file was focused in the TFileList
  38.     cmFileDoubleClicked     // A file was selected in the TFileList
  39.             = 103;
  40.  
  41. #endif  // __FILE_CMDS
  42.  
  43. #if defined( Uses_TSearchRec ) && !defined( __TSearchRec )
  44. #define __TSearchRec
  45.                 
  46. #if !defined( __DIR_H )
  47. #include <Dir.h>
  48. #endif  // __DIR_H
  49.  
  50. struct TSearchRec
  51. {
  52.     uchar attr;
  53.     long time;
  54.     long size;
  55.     char name[MAXFILE+MAXEXT-1];
  56. };
  57.  
  58. #endif  // Uses_TSearchRec
  59.  
  60. #if defined( Uses_TFileInputLine ) && !defined( __TFileInputLine )
  61. #define __TFileInputLine
  62.  
  63. class far TRect;
  64. class far TEvent;
  65.  
  66. class TFileInputLine : public TInputLine
  67. {
  68.  
  69. public:
  70.  
  71.     TFileInputLine( const TRect& bounds, short aMaxLen );
  72.  
  73.     virtual void handleEvent( TEvent& event );
  74.  
  75. private:
  76.  
  77.     virtual const char *streamableName() const
  78.         { return name; }
  79.  
  80. protected:
  81.  
  82.     TFileInputLine( StreamableInit );
  83.  
  84. public:
  85.  
  86.     static const char * const near name;
  87.     static TStreamable *build();
  88.  
  89. };
  90.  
  91. inline ipstream& operator >> ( ipstream& is, TFileInputLine& cl )
  92.     { return is >> (TStreamable&)cl; }
  93. inline ipstream& operator >> ( ipstream& is, TFileInputLine*& cl )
  94.     { return is >> (void *&)cl; }
  95.  
  96. inline opstream& operator << ( opstream& os, TFileInputLine& cl )
  97.     { return os << (TStreamable&)cl; }
  98. inline opstream& operator << ( opstream& os, TFileInputLine* cl )
  99.     { return os << (TStreamable *)cl; }
  100.  
  101. #endif  // Uses_TFileInputLine
  102.  
  103. #if defined( Uses_TFileCollection ) && !defined( __TFileCollection )
  104. #define __TFileCollection
  105.  
  106. class far TSearchRec;
  107.  
  108. class TFileCollection: public TSortedCollection
  109. {
  110.  
  111. public:
  112.  
  113.     TFileCollection( ccIndex aLimit, ccIndex aDelta) :
  114.         TSortedCollection( aLimit, aDelta ) {}
  115.  
  116.     TSearchRec *at( ccIndex index )
  117.         { return (TSearchRec *)TSortedCollection::at( index ); }
  118.     virtual ccIndex indexOf( TSearchRec *item )
  119.         { return TSortedCollection::indexOf( item ); }
  120.  
  121.     void remove( TSearchRec *item )
  122.         { TSortedCollection::remove( item ); }
  123.     void free( TSearchRec *item )
  124.         { TSortedCollection::free( item ); }
  125.     void atInsert( ccIndex index, TSearchRec *item )
  126.         { TSortedCollection::atInsert( index, item ); }
  127.     void atPut( ccIndex index, TSearchRec *item )
  128.         { TSortedCollection::atPut( index, item ); }
  129.     virtual ccIndex insert( TSearchRec *item )
  130.         { return TSortedCollection::insert( item ); }
  131.  
  132.     TSearchRec *firstThat( ccTestFunc Test, void *arg );
  133.     TSearchRec *lastThat( ccTestFunc Test, void *arg );
  134.  
  135. private:
  136.  
  137.     virtual void freeItem( void *item )
  138.         { delete (TSearchRec *)item; }
  139.  
  140.     virtual int compare( void *key1, void *key2 );
  141.  
  142.     virtual const char *streamableName() const
  143.         { return name; }
  144.  
  145.     virtual void *readItem( ipstream& );
  146.     virtual void writeItem( void *, opstream& );
  147.  
  148. protected:
  149.  
  150.     TFileCollection( StreamableInit ) : TSortedCollection ( streamableInit ) {}
  151.  
  152. public:
  153.  
  154.     static const char * const near name;
  155.     static TStreamable *build();
  156.  
  157. };
  158.  
  159. inline ipstream& operator >> ( ipstream& is, TFileCollection& cl )
  160.     { return is >> (TStreamable&)cl; }
  161. inline ipstream& operator >> ( ipstream& is, TFileCollection*& cl )
  162.     { return is >> (void *&)cl; }
  163.  
  164. inline opstream& operator << ( opstream& os, TFileCollection& cl )
  165.     { return os << (TStreamable&)cl; }
  166. inline opstream& operator << ( opstream& os, TFileCollection* cl )
  167.     { return os << (TStreamable *)cl; }
  168.  
  169. inline TSearchRec *TFileCollection::firstThat( ccTestFunc func, void *arg )
  170. {
  171.     return (TSearchRec *)TSortedCollection::firstThat( ccTestFunc(func), arg );
  172. }
  173.  
  174. inline TSearchRec *TFileCollection::lastThat( ccTestFunc func, void *arg )
  175. {
  176.     return (TSearchRec *)TSortedCollection::lastThat( ccTestFunc(func), arg );
  177. }
  178.  
  179. #endif  // Uses_TFileCollection
  180.  
  181.  
  182. #if defined( Uses_TSortedListBox ) && !defined( __TSortedListBox )
  183. #define __TSortedListBox
  184.  
  185. class far TRect;
  186. class far TScrollBar;
  187. class far TEvent;
  188. class far TSortedCollection;
  189.  
  190. class TSortedListBox: public TListBox
  191. {
  192.  
  193. public:
  194.  
  195.     TSortedListBox( const TRect& bounds,
  196.                     ushort aNumCols,
  197.                     TScrollBar *aScrollBar
  198.                   );
  199.  
  200.     virtual void handleEvent( TEvent& event );
  201.     void newList( TSortedCollection *aList );
  202.  
  203.     TSortedCollection *list();
  204.  
  205. protected:
  206.  
  207.     uchar shiftState;
  208.  
  209. private:
  210.  
  211.     virtual void *getKey( const char *s );
  212.  
  213.     ushort searchPos;
  214.  
  215.     virtual const char *streamableName() const
  216.         { return name; }
  217.  
  218. protected:
  219.  
  220.     TSortedListBox( StreamableInit ) : TListBox ( streamableInit ) {}
  221.  
  222. public:
  223.  
  224.     static const char * const near name;
  225.     static TStreamable *build();
  226.  
  227. };
  228.  
  229. inline ipstream& operator >> ( ipstream& is, TSortedListBox& cl )
  230.     { return is >> (TStreamable&)cl; }
  231. inline ipstream& operator >> ( ipstream& is, TSortedListBox*& cl )
  232.     { return is >> (void *&)cl; }
  233.  
  234. inline opstream& operator << ( opstream& os, TSortedListBox& cl )
  235.     { return os << (TStreamable&)cl; }
  236. inline opstream& operator << ( opstream& os, TSortedListBox* cl )
  237.     { return os << (TStreamable *)cl; }
  238.  
  239. inline TSortedCollection *TSortedListBox::list()
  240. {
  241.     return (TSortedCollection *)TListBox::list();
  242. }
  243.  
  244. #endif  // Uses_TSortedListBox
  245.  
  246. #if defined( Uses_TFileList ) && !defined( __TFileList )
  247. #define __TFileList
  248.  
  249. class far TRect;
  250. class far TScrollBar;
  251. class far TEvent;
  252.  
  253. class TFileList : public TSortedListBox
  254. {
  255.  
  256. public:
  257.  
  258.     TFileList( const TRect& bounds,
  259.                TScrollBar *aScrollBar
  260.              );
  261.     ~TFileList();
  262.  
  263.     virtual void focusItem( short item );
  264.     virtual void getText( char *dest, short item, short maxLen );
  265.     virtual void handleEvent( TEvent& event );
  266.     void newList( TFileCollection *aList );
  267.     void readDirectory( const char *dir, const char *wildCard );
  268.     void readDirectory( const char *wildCard );
  269.  
  270.     virtual ushort dataSize();
  271.     virtual void getData( void *rec );
  272.     virtual void setData( void *rec );
  273.  
  274.     TFileCollection *list();
  275.  
  276. private:
  277.  
  278.     virtual void *getKey( const char *s );
  279.  
  280.     static const char * near tooManyFiles;
  281.     
  282.     virtual const char *streamableName() const
  283.         { return name; }
  284.  
  285. protected:
  286.  
  287.     TFileList( StreamableInit ) : TSortedListBox ( streamableInit ) {}
  288.  
  289. public:
  290.  
  291.     static const char * const near name;
  292.     static TStreamable *build();
  293.  
  294. };
  295.  
  296. inline ipstream& operator >> ( ipstream& is, TFileList& cl )
  297.     { return is >> (TStreamable&)cl; }
  298. inline ipstream& operator >> ( ipstream& is, TFileList*& cl )
  299.     { return is >> (void *&)cl; }
  300.  
  301. inline opstream& operator << ( opstream& os, TFileList& cl )
  302.     { return os << (TStreamable&)cl; }
  303. inline opstream& operator << ( opstream& os, TFileList* cl )
  304.     { return os << (TStreamable *)cl; }
  305.  
  306. inline void TFileList::newList( TFileCollection *f )
  307. {
  308.     TSortedListBox::newList( f );
  309. }
  310.  
  311. inline TFileCollection *TFileList::list()
  312. {
  313.     return (TFileCollection *)TSortedListBox::list();
  314. }
  315.  
  316. #endif  // Uses_TFileList
  317.  
  318.  
  319. #if defined( Uses_TFileInfoPane ) && !defined( __TFileInfoPane )
  320. #define __TFileInfoPane
  321.  
  322. class far TRect;
  323. class far TEvent;
  324.  
  325. class TFileInfoPane : public TView
  326. {
  327.  
  328. public:
  329.  
  330.     TFileInfoPane( const TRect& bounds );
  331.  
  332.     virtual void draw();
  333.     virtual TPalette& getPalette() const;
  334.     virtual void handleEvent( TEvent& event );
  335.  
  336. private:
  337.  
  338.     TSearchRec file_block;
  339.  
  340.     static const char * const near months[13];
  341.     static const char * near pmText;
  342.     static const char * near amText;
  343.  
  344.     virtual const char *streamableName() const
  345.         { return name; }
  346.  
  347. protected:
  348.  
  349.     TFileInfoPane( StreamableInit ) : TView ( streamableInit ) {}
  350.  
  351. public:
  352.  
  353.     static const char * const near name;
  354.     static TStreamable *build();
  355.  
  356. };
  357.  
  358. inline ipstream& operator >> ( ipstream& is, TFileInfoPane& cl )
  359.     { return is >> (TStreamable&)cl; }
  360. inline ipstream& operator >> ( ipstream& is, TFileInfoPane*& cl )
  361.     { return is >> (void *&)cl; }
  362.  
  363. inline opstream& operator << ( opstream& os, TFileInfoPane& cl )
  364.     { return os << (TStreamable&)cl; }
  365. inline opstream& operator << ( opstream& os, TFileInfoPane* cl )
  366.     { return os << (TStreamable *)cl; }
  367.  
  368. #endif  // Uses_TFileInfoPane
  369.  
  370. #if defined( Uses_TFileDialog ) && !defined( __TFileDialog )
  371. #define __TFileDialog
  372.  
  373. const
  374.     fdOKButton      = 0x0001,      // Put an OK button in the dialog
  375.     fdOpenButton    = 0x0002,      // Put an Open button in the dialog
  376.     fdReplaceButton = 0x0004,      // Put a Replace button in the dialog
  377.     fdClearButton   = 0x0008,      // Put a Clear button in the dialog
  378.     fdHelpButton    = 0x0010,      // Put a Help button in the dialog
  379.     fdNoLoadDir     = 0x0100;      // Do not load the current directory
  380.                                    // contents into the dialog at Init.
  381.                                    // This means you intend to change the
  382.                                    // WildCard by using SetData or store
  383.                                    // the dialog on a stream.
  384.  
  385. #if !defined( __DIR_H )
  386. #include <Dir.h>
  387. #endif  // __DIR_H
  388.  
  389. class far TEvent;
  390. class far TFileInputLine;
  391. class far TFileList;
  392.  
  393. class TFileDialog : public TDialog
  394. {
  395.  
  396. public:
  397.  
  398.     TFileDialog( const char *aWildCard, const char *aTitle,
  399.                  const char *inputName, ushort aOptions, uchar histId );
  400.     ~TFileDialog();
  401.  
  402.     virtual void getData( void *rec );
  403.     void getFileName( char *s );
  404.     virtual void handleEvent( TEvent& event );
  405.     virtual void setData( void *rec );
  406.     virtual Boolean valid( ushort command );
  407.     virtual void shutDown();
  408.  
  409.     TFileInputLine *fileName;
  410.     TFileList *fileList;
  411.     char wildCard[MAXPATH];
  412.     const char *directory;
  413.  
  414. private:
  415.  
  416.     void readDirectory();
  417.  
  418.     Boolean checkDirectory( const char * );
  419.  
  420.     static const char * near filesText;
  421.     static const char * near openText;
  422.     static const char * near okText;
  423.     static const char * near replaceText;
  424.     static const char * near clearText;
  425.     static const char * near cancelText;
  426.     static const char * near helpText;
  427.     static const char * near invalidDriveText;
  428.     static const char * near invalidFileText;
  429.     
  430.     virtual const char *streamableName() const
  431.         { return name; }
  432.  
  433. protected:
  434.  
  435.     TFileDialog( StreamableInit ) : TDialog ( streamableInit ), 
  436.         TWindowInit( &TFileDialog::initFrame ) {}       
  437.     virtual void write( opstream& );
  438.     virtual void *read( ipstream& );
  439.  
  440. public:
  441.  
  442.     static const char * const near name;
  443.     static TStreamable *build();
  444.  
  445. };
  446.  
  447. inline ipstream& operator >> ( ipstream& is, TFileDialog& cl )
  448.     { return is >> (TStreamable&)cl; }
  449. inline ipstream& operator >> ( ipstream& is, TFileDialog*& cl )
  450.     { return is >> (void *&)cl; }
  451.  
  452. inline opstream& operator << ( opstream& os, TFileDialog& cl )
  453.     { return os << (TStreamable&)cl; }
  454. inline opstream& operator << ( opstream& os, TFileDialog* cl )
  455.     { return os << (TStreamable *)cl; }
  456.  
  457. #endif  // Uses_TFileDialog
  458.  
  459.  
  460. #if defined( Uses_TDirEntry ) && !defined( __TDirEntry )
  461. #define __TDirEntry
  462.  
  463. class TDirEntry
  464. {
  465.  
  466. public:
  467.  
  468.     TDirEntry( const char *, const char * );
  469.     ~TDirEntry();
  470.     char *dir() { return directory; }
  471.     char *text() { return displayText; }
  472.  
  473. private:
  474.  
  475.     char *displayText;
  476.     char *directory;
  477.  
  478. };
  479.  
  480. inline TDirEntry::TDirEntry( const char *txt, const char *dir ) :
  481.     displayText( newStr( txt ) ), directory( newStr( dir ) )
  482. {
  483. }
  484.  
  485. inline TDirEntry::~TDirEntry()
  486. {
  487.     delete displayText;
  488.     delete directory;
  489. }
  490.  
  491. #endif  // Uses_TDirEntry
  492.  
  493. #if defined( Uses_TDirCollection ) && !defined( __TDirCollection )
  494. #define __TDirCollection
  495.  
  496. class far TDirEntry;
  497.  
  498. class TDirCollection : public TCollection
  499. {
  500.  
  501. public:
  502.  
  503.     TDirCollection( ccIndex aLimit, ccIndex aDelta) :
  504.         TCollection( aLimit, aDelta ) {}
  505.  
  506.     TDirEntry *at( ccIndex index )
  507.         { return (TDirEntry *)TCollection::at( index );}
  508.     virtual ccIndex indexOf( TDirEntry *item )
  509.         { return TCollection::indexOf( item ); }
  510.  
  511.     void remove( TDirEntry *item )
  512.         { TCollection::remove( item ); }
  513.     void free( TDirEntry *item )
  514.         { TCollection::free( item ); }
  515.     void atInsert( ccIndex index, TDirEntry *item )
  516.         { TCollection::atInsert( index, item ); }
  517.     void atPut( ccIndex index, TDirEntry *item )
  518.         { TCollection::atPut( index, item ); }
  519.     virtual ccIndex insert( TDirEntry *item )
  520.         { return TCollection::insert( item ); }
  521.  
  522.     TDirEntry *firstThat( ccTestFunc Test, void *arg );
  523.     TDirEntry *lastThat( ccTestFunc Test, void *arg );
  524.  
  525. private:
  526.  
  527.     virtual void freeItem( void *item )
  528.         { delete (TDirEntry *)item; }
  529.  
  530.     virtual const char *streamableName() const
  531.         { return name; }
  532.     virtual void *readItem( ipstream& );
  533.     virtual void writeItem( void *, opstream& );
  534.  
  535. protected:
  536.  
  537.     TDirCollection( StreamableInit ) : TCollection ( streamableInit ) {}
  538.  
  539. public:
  540.  
  541.     static const char * const near name;
  542.     static TStreamable *build();
  543.  
  544. };
  545.  
  546. inline ipstream& operator >> ( ipstream& is, TDirCollection& cl )
  547.     { return is >> (TStreamable&)cl; }
  548. inline ipstream& operator >> ( ipstream& is, TDirCollection*& cl )
  549.     { return is >> (void *&)cl; }
  550.  
  551. inline opstream& operator << ( opstream& os, TDirCollection& cl )
  552.     { return os << (TStreamable&)cl; }
  553. inline opstream& operator << ( opstream& os, TDirCollection* cl )
  554.     { return os << (TStreamable *)cl; }
  555.  
  556. inline TDirEntry *TDirCollection::firstThat( ccTestFunc func, void *arg )
  557. {
  558.     return (TDirEntry *)TCollection::firstThat( ccTestFunc(func), arg );
  559. }
  560.  
  561. inline TDirEntry *TDirCollection::lastThat( ccTestFunc func, void *arg )
  562. {
  563.     return (TDirEntry *)TCollection::lastThat( ccTestFunc(func), arg );
  564. }
  565.  
  566. #endif  // Uses_TDirCollection
  567.  
  568.  
  569. #if defined( Uses_TDirListBox ) && !defined( __TDirListBox )
  570. #define __TDirListBox
  571.  
  572. #if !defined( __DIR_H )
  573. #include <Dir.h>
  574. #endif  // __DIR_H
  575.  
  576. class far TRect;
  577. class far TScrollBar;
  578. class far TEvent;
  579. class far TDirCollection;
  580.  
  581. class TDirListBox : public TListBox
  582. {
  583.  
  584. public:
  585.  
  586.     TDirListBox( const TRect& bounds, TScrollBar *aScrollBar );
  587.     ~TDirListBox();
  588.  
  589.     virtual void getText( char *, short, short );
  590.     virtual void handleEvent( TEvent& );
  591.     virtual Boolean isSelected( short );
  592.     void newDirectory( const char * );
  593.     virtual void setState( ushort aState, Boolean enable );
  594.  
  595.     TDirCollection *list();
  596.  
  597. private:
  598.  
  599.     void showDrives( TDirCollection * );
  600.     void showDirs( TDirCollection * );
  601.  
  602.     char dir[MAXPATH];
  603.     ushort cur;
  604.  
  605.     static const char * near pathDir;
  606.     static const char * near firstDir;
  607.     static const char * near middleDir;
  608.     static const char * near lastDir;
  609.     static const char * near drives;
  610.     static const char * near graphics;
  611.  
  612.     virtual const char *streamableName() const
  613.         { return name; }
  614.  
  615. protected:
  616.  
  617.     TDirListBox( StreamableInit ): TListBox( streamableInit ) {}
  618.  
  619. public:
  620.  
  621.     static const char * const near name;
  622.     static TStreamable *build();
  623.  
  624. };
  625.  
  626. inline ipstream& operator >> ( ipstream& is, TDirListBox& cl )
  627.     { return is >> (TStreamable&)cl; }
  628. inline ipstream& operator >> ( ipstream& is, TDirListBox*& cl )
  629.     { return is >> (void *&)cl; }
  630.  
  631. inline opstream& operator << ( opstream& os, TDirListBox& cl )
  632.     { return os << (TStreamable&)cl; }
  633. inline opstream& operator << ( opstream& os, TDirListBox* cl )
  634.     { return os << (TStreamable *)cl; }
  635.  
  636. inline TDirCollection *TDirListBox::list()
  637. {
  638.     return (TDirCollection *)TListBox::list();
  639. }
  640.  
  641. #endif  // Uses_TDirListBox
  642.  
  643. #if defined( Uses_TChDirDialog ) && !defined( __TChDirDialog )
  644. #define __TChDirDialog
  645.  
  646. const
  647.     cdNormal     = 0x0000, // Option to use dialog immediately
  648.     cdNoLoadDir  = 0x0001, // Option to init the dialog to store on a stream
  649.     cdHelpButton = 0x0002; // Put a help button in the dialog
  650.  
  651. class far TEvent;
  652. class far TInputLine;
  653. class far TDirListBox;
  654. class far TButton;
  655.  
  656. class TChDirDialog : public TDialog
  657. {
  658.  
  659. public:
  660.  
  661.     friend class TDirListBox;
  662.  
  663.     TChDirDialog( ushort aOptions, ushort histId );
  664.     virtual ushort dataSize();
  665.     virtual void getData( void *rec );
  666.     virtual void handleEvent( TEvent& );
  667.     virtual void setData( void *rec );
  668.     virtual Boolean valid( ushort );
  669.     virtual void shutDown();
  670.  
  671. private:
  672.  
  673.     void setUpDialog();
  674.  
  675.     TInputLine *dirInput;
  676.     TDirListBox *dirList;
  677.     TButton *okButton;
  678.     TButton *chDirButton;
  679.  
  680.     static const char * near changeDirTitle;
  681.     static const char * near dirNameText;
  682.     static const char * near dirTreeText;
  683.     static const char * near okText;
  684.     static const char * near chdirText;
  685.     static const char * near revertText;
  686.     static const char * near helpText;
  687.     static const char * near drivesText;
  688.     static const char * near invalidText;
  689.  
  690.     virtual const char *streamableName() const
  691.         { return name; }
  692.  
  693. protected:
  694.  
  695.     TChDirDialog( StreamableInit ) : TDialog( streamableInit ),
  696.         TWindowInit( &TChDirDialog::initFrame ) {}
  697.     virtual void write( opstream& );
  698.     virtual void *read( ipstream& );
  699.  
  700. public:
  701.  
  702.     static const char * const near name;
  703.     static TStreamable *build();
  704.  
  705. };
  706.  
  707. inline ipstream& operator >> ( ipstream& is, TChDirDialog& cl )
  708.     { return is >> (TStreamable&)cl; }
  709. inline ipstream& operator >> ( ipstream& is, TChDirDialog*& cl )
  710.     { return is >> (void *&)cl; }
  711.  
  712. inline opstream& operator << ( opstream& os, TChDirDialog& cl )
  713.     { return os << (TStreamable&)cl; }
  714. inline opstream& operator << ( opstream& os, TChDirDialog* cl )
  715.     { return os << (TStreamable *)cl; }
  716.  
  717. #endif  // Uses_TChDirDialog
  718.  
  719. #pragma option -Vo.
  720. #if defined( __BCOPT__ )
  721. #pragma option -po.
  722. #endif
  723.  
  724.