home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / Libraries / DCLAP 6d / dclap6d / DClap / DChildApp.cpp < prev    next >
Encoding:
Text File  |  1996-07-05  |  19.8 KB  |  857 lines  |  [TEXT/R*ch]
  1. // DChildApp.cpp
  2.  
  3.  
  4. #include "DClap.h"
  5. #include "DChildApp.h"
  6.  
  7.  
  8. // for DChildDlogDoc
  9. #include "Dvibrant.h"
  10. #include "DWindow.h"
  11. #include "DNetObject.h"
  12. #include "DURL.h"
  13. #include "DRichMoreStyle.h"
  14. #include "DBOPclient.h"
  15.  
  16.  
  17. #undef DEBUG
  18.  
  19.  
  20.  
  21. #ifdef WIN_MAC
  22.     // undef some conflicts b/n Types.h && NlmTypes
  23. #undef Handle
  24. //#undef true
  25. //#undef false
  26. //#undef Boolean
  27. #include <AppleEvents.h>
  28. #include <Processes.h>
  29. //#define Boolean  Nlm_Boolean
  30. #endif
  31.  
  32. #ifdef WIN_MSWIN
  33. #include <windows.h>
  34. #include <windowsx.h>
  35. #endif
  36.  
  37. //class DChildFile : public DFile
  38.  
  39.  
  40. DChildFile::DChildFile( const char* filename, short kind,
  41.     Boolean deleteWhenDone,
  42.     short doneAction, const char* openmode, 
  43.     const char* ftype, const char* fcreator) :
  44.     DFile( filename, openmode, ftype, fcreator),
  45.     fAction(doneAction), fKind(kind), fDelete( deleteWhenDone)
  46. {
  47.     //fName2= StrDup(filename); // fix probs w/ fName getting corrupted !!!!???
  48.     if (!openmode) switch (fKind) {
  49.         case kInput: 
  50.         case kStdin:  fMode= StrDup("r"); break;    //?? we really open "w" not "r" ??
  51.         default:
  52.         case kOutput: fMode= StrDup("r"); break;  //?? we really open "r" not "w" !? 
  53.         case kStdout: fMode= StrDup("r"); break;  // was "a", ??? "w" or "a"
  54.         case kStderr: fMode= StrDup("r"); break;  // was "a", ??? "w" or "a"
  55.         }
  56. }
  57.  
  58. DChildFile::~DChildFile()
  59. {
  60.     MemFree(fName2);
  61. #ifndef DEBUG
  62.     if (fDelete) this->Delete();
  63. #endif
  64. }
  65.  
  66. void DChildFile::ClearStorage()
  67. {
  68.     this->Close();
  69. #ifndef DEBUG
  70.     if (fDelete) this->Delete();
  71. #endif
  72. }
  73.  
  74.  
  75.  
  76.  
  77.  
  78. //class DChildApp : public DTaskMaster
  79.     
  80. DChildApp::DChildApp() :     
  81.     DTaskMaster(0),
  82.     fName(NULL), fCmdline(NULL), 
  83.     fStdin(NULL), fStdout(NULL), fStderr(NULL),
  84.     fLaunched(0), fResult(0), fReusable(false), fCallMethod(kNone),
  85.     fProcessNum(0), fFiles(NULL), fNob(NULL), fBopper(NULL)
  86. {
  87.   if (!DChildAppManager::gChildList) DChildAppManager::gChildList= new DList();
  88.     DChildAppManager::gChildList->InsertLast( this); // do this here so caller doesn't forget
  89. }
  90.  
  91.  
  92. DChildApp::DChildApp( char* appname, char* cmdline, 
  93.     Boolean showStdout, char* Stdinfile, Boolean showStderr)  :  
  94.     DTaskMaster(0),
  95.     fName(NULL), fCmdline(NULL), 
  96.     fStdin(NULL), fStdout(NULL), fStderr(NULL),
  97.     fLaunched(0), fResult(0), fReusable(false), fCallMethod(kNone),
  98.     fProcessNum(0), fFiles(NULL), fNob(NULL), fBopper(NULL)
  99. {
  100.     fName= StrDup( appname);
  101.     fCmdline= StrDup( cmdline);
  102.     
  103.     //fFiles= new DList();
  104.  
  105.     // this is called for launching docs as well as apps,
  106.     // don't do the stdout/stderr stuff if this is doc
  107.     if (showStdout) AddFile( DChildFile::kStdout, NULL);
  108.     if (showStderr) AddFile( DChildFile::kStderr, NULL);
  109.     if (Stdinfile) AddFile( DChildFile::kStdin, Stdinfile);
  110.     
  111.   if (!DChildAppManager::gChildList) DChildAppManager::gChildList= new DList();
  112.     DChildAppManager::gChildList->InsertLast( this); // do this here so caller doesn't forget
  113. }
  114.  
  115.  
  116. DChildApp::~DChildApp()
  117. {
  118.     ClearFiles();
  119.     if (fFiles) delete fFiles; fFiles= NULL;
  120.     MemFree( fName);
  121.     MemFree( fCmdline);
  122.     if (fNob) delete fNob;
  123.     if (fBopper) delete fBopper;
  124.     DChildAppManager::gChildList->Delete( this); //need here to balance constructor Insert()
  125. }
  126.  
  127. void DChildApp::ClearFiles()
  128. {
  129.     if (fFiles) {
  130.         short i, n= fFiles->GetSize();
  131. #if 0
  132.             // ?? is this causing trashed DChildFiles ??
  133.         for (i=n-1; i>=0; i--) {
  134.             DChildFile* afile= (DChildFile*) fFiles->At(i);
  135.             delete afile;
  136.             }
  137. #endif
  138. #if 1
  139.         fFiles->DeleteItemsAt(0,n);
  140. #else
  141.         delete fFiles; fFiles= NULL;
  142. #endif
  143.         }
  144. }
  145.  
  146.  
  147. void DChildApp::AddInputBuffer( short filekind, char* buffer, ulong buflen)
  148. {
  149.     char    namestore[512], *name;
  150.     DChildFile* aFile;
  151.     name= gFileManager->TempFilename(namestore);
  152.     switch (filekind) {
  153.         case DChildFile::kInput: 
  154.         case DChildFile::kStdin:  
  155.             aFile= new DChildFile( name, filekind, true, DChildFile::kNoAction);
  156.             break;
  157.         default:
  158.             return;
  159.         }
  160.     if (aFile) {
  161.         aFile->Open("w");
  162.         aFile->WriteData( buffer, buflen);
  163.         aFile->Close();
  164.         aFile->SetMode("r");
  165.         this->AddFile( aFile);
  166.         }
  167. }
  168.  
  169. void DChildApp::AddFile( DChildFile* aFile)
  170. {
  171.         // ?? need to check if fFiles already has one of stdio types ??
  172.     if (!fFiles)     fFiles= new DList();
  173.     fFiles->InsertLast( aFile);
  174.     switch (aFile->fKind) {
  175.         case DChildFile::kStdin:  
  176.             fStdin= aFile->GetName();
  177.             break;
  178.         case DChildFile::kStdout:  
  179.             fStdout= aFile->GetName();
  180.             break;
  181.         case DChildFile::kStderr:  
  182.             fStderr= aFile->GetName();
  183.             break;
  184.         }
  185. }
  186.  
  187. void DChildApp::AddFile( short filekind, char* name)
  188. {
  189.     char    namestore[512];
  190.     DChildFile* aFile;
  191.     if (!name) {
  192.         if (filekind == DChildFile::kStdin || filekind == DChildFile::kInput) return;
  193.         name= gFileManager->TempFilename(namestore);
  194.       }
  195.       
  196.     switch (filekind) {
  197.         case DChildFile::kInput: 
  198.         case DChildFile::kStdin:  
  199.             aFile= new DChildFile( name, filekind, false, DChildFile::kNoAction);
  200.             break;
  201.         
  202.         default:
  203.         case DChildFile::kOutput:   
  204.         case DChildFile::kStdout:  
  205.             aFile= new DChildFile( name, filekind, false);
  206.             break;
  207.         case DChildFile::kStderr:  
  208.             aFile= new DChildFile( name, filekind, true);
  209.             break;
  210.         }
  211.     this->AddFile( aFile);
  212. } 
  213.  
  214.  
  215.  
  216. #ifdef WIN_MAC
  217. extern "C" ProcessSerialNumber  gChildProcessSN;
  218. #else
  219. extern "C" long gChildProcessSN;
  220. #endif
  221.  
  222. enum { kChildTask = 3245, kStatusTask = 34382 };
  223.  
  224. class DBurialTask : public DTask {
  225. public:
  226.     DBurialTask( long processnum, DTaskMaster* itsSource) :
  227.         DTask( processnum, kChildTask, itsSource) {}
  228.     virtual void DoIt() { DChildAppManager::BuryDeadChildApp(fNumber); }
  229. };
  230.  
  231. class DStatusTask : public DTask {
  232. public:
  233.     DStatusTask() :
  234.         DTask( DChildAppManager::kStatusTask, DChildAppManager::kChildManagerTask, 
  235.                     gChildAppManager) 
  236.         {
  237.         if (!gTaskCentral->FindTask(this)) fRepeat= true;
  238.         }
  239.     virtual void DoIt() { 
  240.         //if (!DChildAppManager::CheckStatus()) fRepeat= false;
  241.         }
  242. };
  243.  
  244.  
  245. Boolean DChildApp::Launch()
  246. {
  247.     fResult= 0;
  248.     gCursor->watch();
  249.     switch (fCallMethod) {
  250.         case kLocalexec:
  251.             (void) LaunchLocal();
  252.             break;
  253.         case kBOPexec:
  254.             (void) LaunchBop();
  255.             break;
  256.         case kHTTPget:
  257.         case kHTTPpost:
  258.         default:
  259.             break;
  260.         }    
  261.     gCursor->arrow();
  262.     return  fResult;
  263. }
  264.  
  265.  
  266. Boolean DChildApp::LaunchBop()
  267. {
  268.     char * aHost, * aUser, * aPass, * aPath;
  269.     long    aPort;
  270.     fResult= 0;
  271.     
  272.     if (!fNob) fNob = new DNetOb();
  273.     if (!DURL::ParseURL( fNob, fName)) ; // ?? error
  274.     aHost= (char *)fNob->GetHost(); if (!aHost||!*aHost) aHost= DBOP::gHost;
  275.     aPort= fNob->fPort;  if (!aPort) aPort= DBOP::gPort;
  276.     aPath= (char *)fNob->GetPath();
  277.  
  278.     //if (!aHost || (!aPath && !fCmdline)) return fResult;
  279.     if ((!aPath && !fCmdline)) return fResult;
  280.  
  281.     aUser= (char *)fNob->GetUser(); if (!aUser||!*aUser) aUser= DBOP::gUsername;
  282.     aPass= (char *)fNob->GetPass(); if (!aPass||!*aPass) aPass= DBOP::gPassword;
  283.     
  284.     if (!fBopper) fBopper= new DBOP( aUser, aPass, aHost, aPort);
  285.     else fBopper->ResetHost( aUser, aPass, aHost, aPort);
  286.  
  287.     if (*aPath == '/') aPath++; // default / is leftover from URL syntax
  288.     long len= 2 + StrLen(aPath) + StrLen(fCmdline);
  289.     char* cmdline = (char*) MemNew( len);
  290.     *cmdline= 0;
  291.     if (aPath) { 
  292.         StrCat( cmdline, aPath);
  293.         StrCat( cmdline, " ");
  294.         }
  295.     if (fCmdline) StrCat( cmdline, fCmdline);
  296.     fLaunched++;
  297.     fResult= fBopper->Execute( cmdline, fFiles);
  298.     fProcessNum= fBopper->ProcessNum();
  299.     MemFree( cmdline);
  300.     
  301.     if (fProcessNum) {
  302.         // ?? save user/pass from fBopper (which can ask for new)??
  303.         if (!StrCmp(fBopper->GetUser(),fNob->GetUser()))
  304.             fNob->StoreUser( (char*)fBopper->GetUser());
  305.         if (!StrCmp(fBopper->GetPass(),fNob->GetPass()))
  306.             fNob->StorePass( (char*)fBopper->GetPass());
  307.         if (!StrCmp(fBopper->GetHost(),fNob->GetHost()))
  308.             fNob->StoreHost( (char*)fBopper->GetHost());
  309.         if ( fBopper->gPort != fNob->fPort)
  310.             fNob->fPort= fBopper->gPort;
  311.         }
  312.     
  313.     DStatusTask* statme = new DStatusTask();
  314.     PostTask( statme);
  315.          
  316.     return fResult;
  317. }
  318.     
  319.  
  320. Boolean DChildApp::LaunchLocal()
  321. {
  322.         // ?? want special handling for stdin/stdout/stderr files !!
  323.         // !! must assume OtherFiles are already handled, either in cmdline or by child app !!
  324.     fResult= 0;
  325.     
  326.     if (fName || fCmdline) {
  327.         fLaunched++;
  328.         fResult= Dgg_LaunchApp( fName, fCmdline, (char*)fStdin, 
  329.                                     (char*)fStdout, (char*)fStderr);
  330.  
  331.         if (fResult) {
  332. #ifdef WIN_MAC
  333.             fProcessNum= (long) MemNew(sizeof(ProcessSerialNumber));
  334.             *((ProcessSerialNumberPtr) fProcessNum)= gChildProcessSN;
  335. #else
  336.             fProcessNum= gChildProcessSN;
  337. #endif
  338.  
  339. #ifdef WIN_MSWIN
  340. #ifdef WIN16
  341.             // assume no multiprocessing?? 
  342.             DBurialTask* buryMe = new DBurialTask( gChildProcessSN, this);
  343.             PostTask( buryMe);
  344. #else
  345.             DStatusTask* statme = new DStatusTask();
  346.             PostTask( statme);
  347. #endif
  348. #endif
  349.             //gChildList->InsertLast( this); // done in constructor;
  350.             // can we assume only one copy of this in list ??
  351.             } 
  352.         }
  353.     return fResult;
  354. }
  355.  
  356.  
  357.  
  358. void DChildApp::FileAction(DChildFile* aFile)
  359. {
  360.     switch (aFile->fAction) {
  361.       case DChildFile::kOpenPict:
  362.         case DChildFile::kOpenText: 
  363.             gApplication->OpenDocument( aFile);
  364.             if (aFile->fDelete) {
  365.                 DWindow* win= gWindowManager->CurrentWindow();
  366.                 if (win && win->fSaveHandler) win->fSaveHandler->Dirty();
  367.                 }
  368.             break;
  369.             
  370.         default:
  371.             break;
  372.         }
  373. }
  374.  
  375. void DChildApp::Finished()
  376. {
  377.     fLaunched--; // ?? or use this as counter?
  378.     gCursor->watch();
  379.     if (fCallMethod == kBOPexec && fBopper) {
  380.         fBopper->GetOutput( fProcessNum, fFiles);
  381.         fBopper->Delete( fProcessNum);
  382.         fBopper->Quit(); // ??
  383.         }
  384.     if (fFiles) {
  385.         DChildFile* aFile;
  386.         short i, n= fFiles->GetSize();
  387.         for (i=n-1; i>=0; i--) {
  388.             aFile= (DChildFile*) fFiles->At(i);
  389.             if (aFile->Exists() && aFile->LengthF()>0) 
  390.                 FileAction( aFile);
  391.             aFile->ClearStorage();
  392.             }
  393.         ClearFiles();
  394.         }
  395.     gCursor->arrow();
  396. }
  397.  
  398.  
  399.  
  400. // class DExternalHandler : public DChildApp
  401.  
  402. DExternalHandler::DExternalHandler( char* cmdlineOrDocname) :
  403.     DChildApp( cmdlineOrDocname, NULL, false, NULL, false)
  404. {
  405. }
  406.  
  407. Boolean DExternalHandler::Launch()
  408. {
  409.     return DChildApp::Launch();
  410. }
  411.  
  412. void DExternalHandler::Finished()
  413. {
  414.     DChildApp::Finished();
  415. }
  416.             
  417.  
  418.  
  419.  
  420.  
  421. // class DChildAppManager : public DObject
  422.  
  423.  
  424. //static
  425. DList* DChildAppManager::gChildList = NULL; // new DList(); << bad on SGI // of DChildApp
  426. long DChildAppManager::gLastTime = 0;
  427.  
  428. DChildAppManager* gChildAppManager = new DChildAppManager();
  429.  
  430. enum { 
  431. #ifdef WIN_MAC
  432.     kStatDelay = 1200 // 60ths of second to minutes
  433. #endif
  434. #ifdef WIN_MSWIN
  435.     kStatDelay = 10000 // milliseconds to minutes 
  436. #endif
  437. #ifdef WIN_MOTIF
  438.     kStatDelay = 1200 //  60ths of second to minutes 
  439. #endif
  440.     };
  441.  
  442. DChildAppManager::DChildAppManager() :
  443.     DTaskMaster( kChildManagerTask)
  444. {
  445. }
  446.  
  447.  
  448. Boolean DChildAppManager::IsMyTask(DTask* theTask)
  449. {
  450.   if (theTask && theTask->fNumber == kStatusTask) { 
  451.     short stat= CheckStatus();
  452.     theTask->fRepeat= (stat != 0);
  453.    }
  454.   return true;
  455. }
  456.  
  457.  
  458. //static
  459. short DChildAppManager::BuryDeadChildApp( long theEvent)
  460. {
  461. #ifdef WIN_MAC
  462.     short         err;
  463.     long             appErr;
  464.     Size            actualSize;
  465.     ProcessSerialNumber appSN;
  466.     DescType     returnedType;
  467.      AppleEvent* theAppleEvent;
  468.      
  469.      if (theEvent) {
  470.      theAppleEvent = (AppleEvent*) theEvent;
  471.  
  472.     err= ::AEGetParamPtr( theAppleEvent, keyErrorNumber, typeLongInteger, 
  473.                                                 &returnedType, &appErr, sizeof(appErr), &actualSize);
  474.     if (appErr == 0) { 
  475.         err = AEGetParamPtr( theAppleEvent, keyProcessSerialNumber, typeProcessSerialNumber, 
  476.                                                     &returnedType, &appSN, sizeof(appSN), &actualSize);
  477.         Boolean match;
  478.         DChildApp* child= NULL;
  479.         short i, n= gChildList->GetSize();
  480.         for (i=0, match= false; !match && i<n; i++) {
  481.             child= (DChildApp*) gChildList->At(i);
  482.             err= ::SameProcess( (ProcessSerialNumberPtr)child->fProcessNum, &appSN, &match);
  483.             }
  484.             
  485.         if (match) {
  486.             child->Finished();
  487.             //gChildList->Delete(child); // done by child destructor
  488.             if (!child->fReusable) delete child; 
  489.             }
  490.      }
  491.      }
  492. #endif
  493.  
  494. #if defined(WIN_MOTIF) || defined(WIN_MSWIN)
  495.     // use unix(?) signals
  496.     Boolean match;
  497.     DChildApp* child= NULL;
  498.     short i, n= gChildList->GetSize();
  499.     for (i=0, match= false; !match && i<n; i++) {
  500.         child= (DChildApp*) gChildList->At(i);
  501.         match= (child->fProcessNum == theEvent);
  502.         }
  503.     if (match) {
  504.         child->Finished();
  505.         //gChildList->Delete(child); // done by child destructor
  506.         if (!child->fReusable) delete child; 
  507.         }
  508. #endif
  509.     return 0;
  510. }
  511.  
  512.  
  513. //static
  514. Boolean DChildAppManager::CheckStatus()
  515. {    
  516.     short i, n = gChildList->GetSize();
  517.     long now= gUtil->time();
  518.     if (now - gLastTime > kStatDelay) {
  519.         gLastTime= now;
  520.         for (i=n-1; i>=0; i--) {
  521.             DChildApp* child= (DChildApp*) gChildList->At(i);
  522.             if (child && child->fProcessNum) {
  523.             
  524.                 if (child->fCallMethod == DChildApp::kLocalexec) {
  525. #ifdef WIN_MSWIN
  526. #ifndef WIN16
  527.               long waitresult= ! WAIT_TIMEOUT;
  528.               HANDLE hobj= OpenProcess( SYNCHRONIZE, false, child->fProcessNum);
  529.               if (hobj) waitresult= WaitForSingleObject( hobj, 0);
  530.               if (waitresult != WAIT_TIMEOUT) {
  531.                   child->Finished();
  532.                     if (!child->fReusable) delete child; 
  533.                   n--;
  534.                 }
  535. #endif
  536. #endif
  537.                     }
  538.                 else if (child->fCallMethod == DChildApp::kBOPexec && child->fBopper) {
  539.                     if (child->fBopper->CheckStatus(child->fProcessNum)
  540.                                 >= DBOP::kProcDone) {
  541.                   child->Finished();
  542.                     if (!child->fReusable) delete child; 
  543.                   n--;
  544.                         }
  545.                     }
  546.           }
  547.             else n--; //??
  548.             }
  549.         }
  550.     return (n > 0);
  551. }
  552.  
  553.  
  554.  
  555.  
  556.  
  557.  
  558. #include "DChildDlogDoc.h"
  559. #include "DRichViewNu.h"
  560. #include "DRichMoreStyle.h"
  561. #include "DHTMLHandler.h"
  562.  
  563. class    DChildDlogView : public DRichView {
  564. public:
  565.     Boolean fhasVscroll;
  566.     short fPixwidth, fPixheight;
  567.     
  568.     DChildDlogView(long id, DView* itsSuperior, short pixwidth, short pixheight, 
  569.                                     Boolean hasVscroll = true);
  570.     virtual void ReadyToOpen();
  571.     virtual void ShowFile( char* filename, Nlm_FonT font);
  572.     virtual void ShowDoc( char* doctext, ulong doclength = 0);
  573.     virtual void Click( Nlm_PoinT mouse);
  574.     virtual DList* GetControlObjects();
  575. };
  576.  
  577.  
  578.  
  579. DChildDlogView::DChildDlogView(long id, DView* itsSuperior, short pixwidth, short pixheight, 
  580.                                                     Boolean hasVscroll) :
  581.         DRichView( id, itsSuperior, pixwidth, pixheight, hasVscroll )
  582. {
  583.     fhasVscroll= hasVscroll;
  584.     fPixwidth= pixwidth;
  585.     fPixheight= pixheight;
  586. }
  587.  
  588. void DChildDlogView::Click( Nlm_PoinT mouse)
  589. {
  590.     // eat dlog richtext clicks other than to controls !
  591. }
  592.  
  593.  
  594. void  DChildDlogView::ShowFile( char* filename, Nlm_FonT font) 
  595. {
  596.     fDocFormat= DRichHandler::kUnknownformat;
  597.   DHTMLHandler htmlhandler( this, NULL);
  598.   if ( htmlhandler.ProcessFile( filename) ) 
  599.       fDocFormat= htmlhandler.Format(); 
  600.   else {
  601.       DRichHandler texthandler( this, NULL);
  602.       if ( texthandler.ProcessFile( filename) ) 
  603.           fDocFormat= texthandler.Format(); 
  604.       }
  605. }
  606.  
  607.  
  608. void  DChildDlogView::ShowDoc( char* doctext, ulong doclength) 
  609. {
  610.     if (!doctext) return;
  611.     if (!doclength) doclength= StrLen( doctext);
  612.     char*    docend= doctext + doclength;
  613.     
  614.     fDocFormat= DRichHandler::kUnknownformat;
  615.   DHTMLHandler htmlhandler( this, NULL);
  616.      if (htmlhandler.ProcessData( doctext, docend, true, doclength))
  617.       fDocFormat= htmlhandler.Format(); 
  618.   else {
  619.       DRichHandler texthandler( this, NULL);
  620.          if ( texthandler.ProcessData( doctext, docend, true, doclength))
  621.           fDocFormat= texthandler.Format(); 
  622.       }
  623. }
  624.  
  625. void  DChildDlogView::ReadyToOpen()
  626. {
  627.     SetSlateBorder( false);
  628.     SetResize( DView::matchsuper, DView::relsuper);  
  629.     SizeToSuperview( this, true, false);  
  630.     Disable(); //! make so only control items are clickable !! (need for mwin)
  631. }
  632.  
  633.  
  634. DList* DChildDlogView::GetControlObjects()
  635. { 
  636.     DList* controls= new DList();
  637.     short i, n= fStyles->GetSize();
  638.     for (i=0; i<n; i++) {
  639.         DRichStyle* st= (DRichStyle*) fStyles->At(i);
  640.         if (st->fObject 
  641.             && st->fObject->fKind >= DControlStyle::kControlKindStart
  642.             && st->fObject->fKind <= DControlStyle::kControlKindEnd) {
  643.                 controls->InsertLast(st->fObject);
  644.             }
  645.         }
  646.     return controls;
  647. }
  648.  
  649.  
  650.  
  651.  
  652. //class    DChildDlogDoc : public DWindow
  653.  
  654. extern "C" void Nlm_SetRect (Nlm_GraphiC a, Nlm_RectPtr r);
  655. extern "C" void Nlm_GetRect (Nlm_GraphiC a, Nlm_RectPtr r);
  656.  
  657.  
  658. DChildDlogDoc::DChildDlogDoc( long id, Boolean freeOnClose, Nlm_FonT itsFont) :
  659.         DWindow( id, gApplication, document, -5, -5, -50, -20, NULL, freeOnClose), 
  660.         fDlog(NULL), fControls(NULL)
  661. {     
  662.     Nlm_PoinT nps;
  663.     short width, height;
  664.     Nlm_RecT  r;
  665.     
  666.     fFont= itsFont;
  667.     this->GetNextPosition( &nps);
  668.     nps.x= 0; // fix for odd offset
  669.     this->SetNextPosition( nps);
  670.     gUtil->screensize(width, height);
  671.     width = MAX(250, MIN(width-60,gPrintManager->PageWidth()-100));
  672.     height= MIN(350, height-60);
  673.     fDlog= new DChildDlogView( 0, this, width, height, false);
  674.     
  675.     Nlm_GraphiC nwin= (Nlm_GraphiC)this->fNlmObject;
  676.     Nlm_GetRect( nwin, &r);
  677.     r.bottom= height + 5; // + Nlm_vScrollBarWidth; 
  678.     r.right= width + 5; //+ Nlm_hScrollBarHeight;
  679.     Nlm_SetRect( nwin, &r);
  680. }
  681.  
  682.  
  683. DChildDlogDoc::~DChildDlogDoc()
  684. {
  685.     delete fControls;
  686. }
  687.  
  688. void DChildDlogDoc::AddSubordinate(DTaskMaster* subordinate)
  689. {
  690.     DWindow::AddSubordinate(subordinate);
  691. #if 0
  692.     if (subordinate->fId >= DControlStyle::kControlKindStart 
  693.         && subordinate->fId <= DControlStyle::kControlKindEnd) {
  694.         if (!fControls) fControls= new DList();
  695.         fControls->InsertLast(subordinate);
  696.         }
  697. #endif
  698. }
  699.  
  700.  
  701. DList* DChildDlogDoc::GetControls()
  702. {
  703.     if (!fControls) fControls= fDlog->GetControlObjects();
  704.     return fControls;
  705. }
  706.  
  707.  
  708. Nlm_Boolean DChildDlogDoc::PoseModally() 
  709. { 
  710.     if (!IsVisible()) Open(); // already open !?
  711.     fModal = true;
  712.     while (fModal)  
  713.         gApplication->ProcessTasks();  
  714.     return fOkay; // ?? ain't what we want - want fSubordinate's fId
  715. }
  716.  
  717.                               
  718.  
  719. void DChildDlogDoc::OpenText( char* doctext, ulong doclength)
  720. {
  721.     if (doctext) {
  722.         fDlog->ShowDoc( doctext, doclength);
  723.         Open();
  724.         }
  725. }
  726.  
  727. void DChildDlogDoc::Open( DFile* aFile)
  728. {
  729.     if (aFile) {
  730.         SetTitle( (char*)aFile->GetShortname());
  731.         SetFilename( (char*)aFile->GetName());
  732.         fDlog->ShowFile( (char*)aFile->GetName(), fFont);
  733.         }
  734.     Open();
  735. }
  736.  
  737. void  DChildDlogDoc::Open( char* filename) 
  738. {
  739.     SetTitle( (char*)DFileManager::FilenameFromPath(filename));
  740.     SetFilename( (char*) filename);
  741.     fDlog->ShowFile( filename, fFont);
  742.   Open();
  743. }
  744.  
  745. void DChildDlogDoc::Close()
  746. {
  747.     DWindow::Close();
  748. }
  749.  
  750. void DChildDlogDoc::CloseAndFree() 
  751. { 
  752.     fModal= false;
  753.     if (this != gWindowManager->GetAppWindow()) {
  754.         gWindowManager->DeleteWindow(this, false);  
  755.         //fFreeOnClose= true; //<< !!! NO NO NO NO - crash in XWin at least !
  756.         this->Close(); 
  757.         }
  758. }
  759.  
  760. void DChildDlogDoc::ResizeWin()
  761. {
  762.     DWindow::ResizeWin();
  763.     //if (fDlog) fDlog->ViewRect( gRichDocRect);
  764. }
  765.  
  766. Nlm_Boolean DChildDlogDoc::IsMyAction(DTaskMaster* action) 
  767. {
  768.     char buf[512];
  769.  
  770.     if (action->Id() >= DControlStyle::kControlKindStart
  771.         && action->Id() <= DControlStyle::kControlKindEnd)
  772.         {
  773.         switch (action->Id()) {
  774.         
  775.             case DControlStyle::kFileChooser:
  776.                 {
  777.                 DFileCStyle* cs= (DFileCStyle*) ((DView*)action)->fKind;
  778.                 const char* name= DFileManager::GetInputFileName( NULL, NULL);
  779.                 if (name) cs->fNamebox->SetTitle( (char*)name);
  780.                 }
  781.                 return true;
  782.                 
  783.             //kButton, kSubmitButton,  kResetButton,     kRadioButton, kCheckBox,
  784.              //kPopup, kPrompt,     kEditText,     kDialogScrollText,
  785.           //kPasswordText, 
  786.             default:
  787.                 //dlog checkboxes, radios, edittext, etc all call here when actioned!
  788.                 //Message(MSG_OK,"DControlStyle::message not ready.");
  789.                 return true;
  790.             }
  791.         }
  792.         
  793.     switch(action->Id()) {
  794.     
  795.         case cOKAY:
  796.             this->OkayAction();
  797.             fOkay= true;
  798.             // fall thru to next case
  799.         case cCANC: 
  800.             fModal= false;
  801.             this->Close(); 
  802.             return true;
  803.  
  804.         case DApplication::kUndo:
  805.             Message(MSG_OK,"DChildDlogDoc::Undo not ready.");
  806.             return true;
  807.         case DApplication::kCut:
  808.             Message(MSG_OK,"DChildDlogDoc::Cut not ready.");
  809.             //this->CutText(); 
  810.             return true;
  811.             
  812.         case DApplication::kCopy: {
  813.             Message(MSG_OK,"DChildDlogDoc::Copy not ready.");
  814.         }
  815.             return true;
  816.             
  817.         case DApplication::kPaste:
  818.             Message(MSG_OK,"DChildDlogDoc::Paste not ready.");
  819.             //this->PasteText(); 
  820.             return true;
  821.         case DApplication::kClear:
  822.             Message(MSG_OK,"DChildDlogDoc::Clear not ready.");
  823.             //this->ClearText(); 
  824.             return true;
  825.         case DApplication::kSelectAll:
  826.             Message(MSG_OK,"DChildDlogDoc::Select all not ready.");
  827.             //if (fDlog) fDlog->SelectAll();
  828.             //this->SetSelection(0,0,32000,32000); 
  829.             return true;
  830.         default:
  831.             return DWindow::IsMyAction(action);
  832.         }
  833. }
  834.  
  835.  
  836. #ifdef WIN_MOTIF
  837. #include <ncbiwin.h>
  838. #include <ncbiport.h>
  839. extern Display* Nlm_currentXDisplay;
  840. extern Window   Nlm_currentXWindow;
  841. #endif
  842.  
  843. void DChildDlogDoc::Open()
  844. {
  845.     this->CalcWindowSize();
  846.     fDlog->ReadyToOpen();
  847.     DWindow::Open();
  848. #ifdef WIN_MOTIF
  849.     //fDlog->SendBehind();
  850.     fDlog->Select();
  851.     XLowerWindow( Nlm_currentXDisplay, Nlm_currentXWindow); // make this a DView method?
  852. #endif
  853. }
  854.  
  855.  
  856.  
  857.