home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / Libraries / DCLAP 6d / dclap6d / DNet / DGoNetDoc.cpp < prev    next >
Encoding:
Text File  |  1996-07-05  |  53.3 KB  |  2,113 lines  |  [TEXT/R*ch]
  1. // DGopherDoc.cp
  2. // d.g.gilbert
  3.  
  4.  
  5.  
  6. #include "DGoNetDoc.h"
  7.  
  8. #include <DGoDoc.h>
  9.  
  10. #include <ncbi.h>
  11. #include <dgg.h>
  12. #include <Dvibrant.h>
  13. #include <DApplication.h>
  14. #include <DGopher.h>
  15. #include <DGoList.h>
  16. #include <DGoInit.h>
  17. #include <DGoPlus.h>
  18. #include <DGoClasses.h>
  19. #include <DPanel.h>
  20. #include <DControl.h>
  21. #include <DDialogText.h>
  22. #include <DWindow.h>
  23. #include <DMenu.h>
  24. #include <DFile.h>
  25. #include <DUtil.h>
  26. #include <DIconLib.h>  
  27. #include <DIcons.h> 
  28.  
  29. #include <DChildApp.h>
  30.  
  31. #include <DRichViewNu.h>
  32. #include <DRTFHandler.h>
  33. #include <DHTMLHandler.h>
  34. #include <DPICTHandler.h>
  35. #include <DGIFHandler.h>
  36.  
  37. // DAMN SUN CC/LD can't find DNetHTML objects !
  38. #include <DNetHTMLHandler.h>
  39.  
  40.  
  41. enum ResizeWindSizes {
  42.     kWinDragHeight = 20,
  43.     kWinScrollWidth = 0,   // added to both vert & hor.
  44.     kWinMinWidth = 0,
  45.     kWinExtraHeight= 0
  46.     };
  47.  
  48. /* from vibrant/vibwndws.c */
  49. extern "C" void Nlm_ResizeWindow(Nlm_GraphiC w, Nlm_Int2 dragHeight,
  50.                               Nlm_Int2 scrollWidth, Nlm_Int2 minWidth,
  51.                               Nlm_Int2 extraHeight);
  52. /* for doc window: Nlm_ResizeWindow (w, 20, 0, Nlm_StringWidth (title) + 70, 0); */
  53.  
  54.  
  55. //Global     DList*    gTextStoreList = NULL;
  56. //Local        short        gListAt = kEmptyIndex;
  57. Global  DGopherTextDoc* gGopherTextDoc = NULL;
  58.  
  59. Local unsigned long gLinkcolor = (0<<16) + (170<<8) + 0;
  60.                                                               // red      green    blue
  61.  
  62.  
  63. enum { kGolistViewWidth = 225 };
  64.  
  65. enum DGoDocCmds {
  66.     cProcessGopher = 30346,
  67.     cStuf,
  68.     cStufInline,
  69.     cSave,
  70.     cAdd,
  71.     cProcessInlines
  72.     };
  73.  
  74. Local Nlm_FonT    gSmallFont= NULL;
  75.  
  76.  
  77. inline void MakeSmallFont()
  78. {
  79.     if (!gSmallFont) 
  80.         gSmallFont = Nlm_GetFont( "Times", 9, false, false, false, "Roman");
  81. }
  82.  
  83.  
  84.  
  85.  
  86. class DLinkedRichView : public DRichView
  87. {
  88. public:
  89.     enum MarkState {
  90.         kMarkNone, kMarkMoving, kMarkOff, kMarkOn
  91.         };
  92.     Nlm_PoinT    fAnchorPt, fEndPt;
  93.     MarkState fMarqueeState;
  94.     DGoLinkedTextDoc * fDoc;
  95.     
  96.     DLinkedRichView(long id, DGoLinkedTextDoc* itsSuperior, short pixwidth, short pixheight);
  97.  
  98.     virtual void DoClickFetch(Nlm_PoinT mouse);
  99.     virtual void Click(Nlm_PoinT mouse);
  100.     virtual void Drag(Nlm_PoinT mouse);
  101.     virtual void Hold(Nlm_PoinT mouse);
  102.     virtual void Release(Nlm_PoinT mouse);
  103.     virtual void DrawMarquee( MarkState state = kMarkMoving);
  104. };
  105.  
  106.  
  107. DLinkedRichView::DLinkedRichView(long id, DGoLinkedTextDoc* itsSuperior, short pixwidth, short pixheight):
  108.     DRichView( id, itsSuperior, pixwidth, pixheight),
  109.     fDoc( itsSuperior),
  110.     fMarqueeState(kMarkNone)
  111. {
  112.     Nlm_LoadPt( &fAnchorPt, 0, 0);
  113.     fEndPt= fAnchorPt;
  114. }
  115.  
  116.  
  117.  
  118.  
  119. void DLinkedRichView::Click(Nlm_PoinT mouse)
  120. {
  121.     if (fMarqueeState == kMarkOn) DrawMarquee( kMarkOff);
  122.     if (Nlm_dblClick) {
  123.         if (gDoubleClicker) DoClickFetch( mouse);
  124.         //else DoubleClick(mouse);
  125.         }
  126.     else {
  127.         fAnchorPt= mouse;
  128.         fEndPt= mouse;
  129.         if (gSingleClicker) DoClickFetch( mouse);
  130.         else SingleClick(mouse);        
  131.         }
  132. }
  133.  
  134.  
  135. void DLinkedRichView::DrawMarquee( MarkState state)
  136. {
  137.     if (state != kMarkNone && ! Nlm_EqualPt(fAnchorPt, fEndPt)) {
  138.         Nlm_RecT r;
  139.         r.left= MIN(fAnchorPt.x, fEndPt.x);
  140.         r.right= MAX(fAnchorPt.x, fEndPt.x);
  141.         r.top= MIN(fAnchorPt.y, fEndPt.y);
  142.         r.bottom= MAX(fAnchorPt.y, fEndPt.y);
  143.         switch (state) {
  144.             case kMarkMoving:
  145.                 Nlm_InvertMode();
  146.                 Nlm_Dotted();
  147.                 break;
  148.             case kMarkOff:
  149.                 Nlm_InvertMode();
  150.                 break;
  151.             case kMarkOn:
  152.                 Nlm_InvertMode();
  153.                 break;
  154.             }
  155.         Nlm_FrameRect( &r);
  156.         switch (state) {
  157.             case kMarkMoving:
  158.                 Nlm_Solid();
  159.                 Nlm_CopyMode();
  160.                 fMarqueeState= kMarkMoving;
  161.                 break;
  162.             case kMarkOff:
  163.                 Nlm_CopyMode();
  164.                 fMarqueeState= kMarkNone;
  165.                 break;
  166.             case kMarkOn:
  167.                 Nlm_CopyMode();
  168.                 fMarqueeState= kMarkOn;
  169.                  break;
  170.             }
  171.         }
  172. }
  173.  
  174.  
  175. void DLinkedRichView::Hold(Nlm_PoinT mouse)
  176. {
  177.         // for marquee selection ??
  178.     //DrawMarquee(kMarkMoving);
  179.     //fEndPt= mouse;
  180.     //DrawMarquee(kMarkMoving);
  181. }
  182.  
  183. void DLinkedRichView::Drag(Nlm_PoinT mouse)
  184. {
  185.         // for marquee selection
  186.     DrawMarquee(kMarkMoving);
  187.     fEndPt= mouse;
  188.         // !! need to scroll doc if mouse is outside of doc view, but in doc area
  189.     DrawMarquee(kMarkMoving);
  190. }
  191.  
  192.  
  193. void DLinkedRichView::Release(Nlm_PoinT mouse)
  194. {
  195.     if (fMarqueeState != kMarkNone) {
  196.             // don't mark things if this was just a simple, non-dragged click
  197.             // for marquee selection
  198.         DrawMarquee(kMarkMoving);
  199.         fEndPt= mouse;
  200. #if 1
  201.         Nlm_RecT r;
  202.         r.left= MIN(fAnchorPt.x, fEndPt.x);
  203.         r.right= MAX(fAnchorPt.x, fEndPt.x);
  204.         r.top= MIN(fAnchorPt.y, fEndPt.y);
  205.         r.bottom= MAX(fAnchorPt.y, fEndPt.y);
  206.     
  207.         // ClearSelection();
  208.         if (r.right > r.left + 5 || r.bottom > r.top + 5)
  209.             MarkSelection( r);
  210. #else
  211.         DrawMarquee(kMarkOn);
  212. #endif
  213.     }
  214. }
  215.  
  216.  
  217.  
  218. void DLinkedRichView::DoClickFetch(Nlm_PoinT mouse)
  219. {
  220.     short item, row;
  221.     Nlm_RecT        rct;
  222.     char                wordAt[512];
  223.     DRichStyle    styleAt;
  224.  
  225.     wordAt[0]= 0;
  226.     MapPoint( mouse, item, row, &rct, wordAt, 512, &styleAt);
  227.     if (styleAt.ispict && styleAt.fPict) {
  228.         Nlm_PoinT atp;
  229.         short    linkid, kind = 0;
  230.         atp= mouse;
  231.         MapView2Doc( atp);
  232.         // if atp is inside a pict, adjust it by pict top,left
  233.         atp.x -= fDrawr.left;
  234.         atp.y    -= fDrawr.top;
  235.  
  236.         linkid= styleAt.fPict->GetLink( atp, kind); 
  237.                 
  238.         if (kind == DPictStyle::kPictNetPic)
  239.             fDoc->SetupInlinePart( fMapStyle); 
  240.         else if (linkid) {
  241.             // if styleAt.ismap, do things w/ gopher link
  242.             // need to stuff atp.x,y into gopher.fQuery....
  243.             if (styleAt.ismap) fDoc->OpenGopherLink(linkid-1, &atp);    
  244.             else fDoc->OpenGopherLink(linkid-1, NULL);    // send atp anyway ???
  245.             }
  246.         else if (fDoc->fStore->fMapLink) {
  247.             fDoc->OpenGopherLink( fDoc->fStore->fMapLink-1, &atp);    
  248.             }
  249.         else {
  250.             fDoc->SetupInlinePart( fMapStyle); // ?? check in case it needs pic fetched
  251.             }
  252.         }
  253.     else {
  254.         if (styleAt.linkid) fDoc->OpenGopherLink(styleAt.linkid-1);    
  255.         }
  256.     styleAt.ownpict= false; // !!!! not this copy, so we don't delete
  257. }
  258.  
  259.  
  260.  
  261.  
  262.  
  263.  
  264.  
  265.  
  266.  
  267.  
  268.  
  269.  
  270.  
  271.  
  272.  
  273.  
  274. // class    DGopherTextStore : public DTaskMaster
  275.  
  276.  
  277.  
  278. DGopherTextStore::DGopherTextStore( DGopher* itsGopher, DWindow* itsWindow, Boolean havelinks) :
  279.         DTaskMaster( 0, gApplication),
  280.         fWindow(itsWindow), fIsLinkDoc(havelinks),
  281.         fParentGo(itsGopher), fStufGo(NULL),
  282.         fRichView(NULL),  
  283.         fDocFormat(DRichHandler::kTextformat),
  284.         fRichHandler(NULL), 
  285.         fInlineStyle(NULL),
  286.         fDocFile(NULL), fFetchFile(NULL),
  287.         fGolist(NULL), fIsFromFile(false), fMapLink(0),
  288.         fFirststuff(1)
  289. { 
  290.     short pixwidth = gPrintManager->PageWidth(), pixheight = 0;
  291.     
  292.     if (fParentGo) {
  293.         fParentGo->newOwner();
  294.         if (fParentGo->fType == kTypeHtml) fDocFormat= DHTMLHandler::kHTMLformat;
  295.         }
  296.     fFetchFile= new DTempFile();
  297.     //fFetchFile->Open("wb"); //! << WITHOUT THIS, save IS BAD for Binary data
  298.  
  299. #if 1    
  300.     if (((DGopherTextDoc*)fWindow)->fTextStoreList->GetSize()) {
  301.             // already have a view in window, use same size
  302.         Nlm_RecT r;
  303.         ((DGopherTextDoc*)fWindow)->fRichView->GetPosition( r);
  304.         pixwidth=  r.right - r.left;
  305.         pixheight= r.bottom- r.top;
  306.                 // need this for all systems
  307.         pixwidth -= 16; // Damn, this is scrollbar width, why do we need this adjustment !?
  308.         }
  309.     else if (!Nlm_EmptyRect( &DRichTextDoc::gRichDocRect)) {
  310.         Nlm_PoinT  npt;
  311.         //fWindow->GetNextPosition( &npt);
  312.         pixwidth= DRichTextDoc::gRichDocRect.right - DRichTextDoc::gRichDocRect.left
  313.                 + 20; //- npt.x;
  314.         pixheight= DRichTextDoc::gRichDocRect.bottom - DRichTextDoc::gRichDocRect.top
  315.                 + 8; //- npt.y;
  316.         }
  317. #endif        
  318.     if (fIsLinkDoc)
  319.         fRichView= new DLinkedRichView(0, (DGoLinkedTextDoc*)fWindow, pixwidth, pixheight);
  320.     else
  321.       fRichView= new DRichView(0, fWindow, pixwidth, pixheight);
  322.     fRichView->SetSlateBorder( true);
  323.     fRichView->SetResize( DView::matchsuper, DView::relsuper);
  324.     fRichView->SetTabs( gTextTabStops);
  325.     //fRichView->SizeToSuperview( fWindow, true, false); // this needs to adjust for if view has scrollbar !
  326. }
  327.         
  328.  
  329. DGopherTextStore::~DGopherTextStore()
  330. {
  331.     this->Close();
  332.     if (fGolist) fGolist->suicide(); //!
  333.     if (fParentGo) fParentGo->suicide();  
  334.   if (fRichView) fRichView->ResetDoc(); // drop all data, but leave view for deleteSubviews
  335.     // ?? ^^ ResetDoc is a memory sieve !!???!  doesn't free any of the view mem ?? or is bug elsewhere
  336.     if (fRichHandler) delete fRichHandler; fRichHandler= NULL;
  337.     if (fDocFile) delete fDocFile; fDocFile= NULL;
  338.     if (fFetchFile) delete fFetchFile; fFetchFile= NULL;
  339. }
  340.  
  341. Boolean DGopherTextStore::suicide(void) 
  342. { 
  343.     if (GetOwnerCount() <= 1) { 
  344.         delete this; 
  345.         return true; 
  346.         }
  347.     else 
  348.         return DObject::suicide();
  349. }
  350.  
  351. Boolean DGopherTextStore::suicide(short ownercount)
  352. {
  353.     if (ownercount < 1) {
  354.         delete this; 
  355.         return true; 
  356.         }
  357.     else 
  358.         return DObject::suicide(ownercount);
  359. }
  360.  
  361. #if 0
  362. void DGopherTextStore::AddToList()
  363. {
  364.     if (!gTextStoreList) {
  365.         gTextStoreList= new DList(NULL, DList::kDeleteObjects);
  366.         gListAt= kEmptyIndex;
  367.         }
  368.     if (gTextStoreList) {
  369.             // clean out storage below current displayed item...
  370.             // ???? is this going to be a mess w/ different windows ??
  371.       for (short idoc= gTextStoreList->GetSize()-1; idoc>gListAt; idoc--)
  372.           gTextStoreList->AtDelete(idoc); // deletes all of storage
  373.         gTextStoreList->Push( this);
  374.         gListAt= gTextStoreList->GetSize()-1;
  375.         }
  376. }
  377. #endif
  378.  
  379. void DGopherTextStore::SetGolist( DGopherList *theList)
  380. {
  381.     fGolist= theList;
  382.     if (fParentGo && fParentGo->fGoMenuBlock) {
  383.         fGolist= fParentGo->fGoMenuBlock->fGolist;
  384.         if (fGolist) fGolist->newOwner();
  385.         }
  386.         
  387.     if (fParentGo && fParentGo->fIsLocal) {
  388.             // look for a separate "path.go4" link file
  389.         DFile* goFile= NULL;
  390.         char    name[512];
  391.         StrNCpy( name, fParentGo->GetPath(), 512);
  392.         gFileManager->ReplaceSuffix( name, 512, DGopherListDoc::kGopherDocSuffix);
  393.         if (gFileManager->FileExists( name))  
  394.             goFile= new DFile(name, "r");
  395.         if (goFile) {
  396.             ulong filelen;
  397.             goFile->OpenFile();
  398.             goFile->GetDataLength(filelen);
  399.             char* buf= (char*) MemNew( filelen+1);
  400.             goFile->ReadData( buf, filelen);
  401.             fGolist->ReadLinks( buf, filelen);
  402.             MemFree( buf);
  403.             goFile->CloseFile();
  404.             delete goFile;
  405.             }
  406.         }
  407.         
  408.     if (fGolist) fGolist->fParentMenu= fParentGo;
  409. }
  410.  
  411. void DGopherTextStore::WriteDoc( DFile* toFile, char* readkind, char* writekind)
  412. {
  413.     enum { kLineMax = 2048 };
  414.     char     line[kLineMax];
  415.     ulong count, bytesleft;
  416.     
  417.     if (!fDocFile) {
  418.         if (!fFetchFile) return;
  419.         fDocFile= fFetchFile;
  420.         fFetchFile= new DTempFile();
  421.         }
  422.     fDocFile->Open(readkind);
  423.     fDocFile->GetDataLength(bytesleft);
  424.     toFile->Open(writekind);
  425.     while (bytesleft>0) {
  426.         count= MIN(kLineMax, bytesleft);
  427.         fDocFile->ReadData(line, count);
  428.         bytesleft -= count;
  429.         toFile->WriteData(line, count);
  430.         }
  431.     toFile->Close();
  432.     fDocFile->Close();
  433. }
  434.  
  435.  
  436. const char* DGopherTextStore::GetTitle()
  437. {
  438.     static char buf[256];
  439.     if (fParentGo) return fParentGo->ShortName();
  440.     else if (fStufGo) return fStufGo->ShortName();
  441.     else if (fRichView) return fRichView->GetTitle( buf, 256); 
  442.     else return "";
  443. }
  444.  
  445. void DGopherTextStore::StartInlineFetch( DGopher* stufGo, DRichStyle* stufStyle)
  446. {
  447.     fStufGo= stufGo;
  448.     fInlineStyle= stufStyle;
  449.     fFirststuff= 1;
  450.     if (!fDocFile && fFetchFile) {
  451.         fDocFile= fFetchFile;
  452.         fFetchFile= new DTempFile();
  453.         }
  454. }
  455.  
  456. Boolean DGopherTextStore::IsMyTask(DTask* theTask) 
  457. {
  458.     if (theTask->fKind == DGopherTextDoc::kGoTextdoc) {
  459.         ProcessTask( theTask);
  460.         return true;
  461.         }
  462.     else 
  463.         return DTaskMaster::IsMyTask(theTask);
  464. }
  465.  
  466.  
  467. ulong CRLF2Newline( char* databuf, ulong datasize)
  468. {
  469.     ulong  oldsize = 0;
  470.     char lastc = 0, * newp = databuf, * oldp = databuf;
  471.     
  472.     while (oldsize < datasize) {
  473.         if (*oldp == kLF && lastc == kCR) {
  474.             newp[-1]= '\n'; // system newline
  475.             lastc= kLF;
  476.             oldp++;
  477.             oldsize++;
  478.             }
  479.         else {
  480.             *newp++= lastc= *oldp++;
  481.             oldsize++;
  482.             }
  483.         }
  484.     *newp= 0;
  485.     return newp - databuf;
  486. } 
  487.  
  488. char* DGopherTextStore::ProcessTask1( char* databuf, ulong& datasize) 
  489. {
  490.     char *dataAt;
  491.  
  492.     fFirststuff++;    
  493.     
  494.     if (!fFetchFile) fFetchFile= new DTempFile();
  495.     fFetchFile->Open("wb");  
  496.     fRichHandler = new DRTFHandler(fRichView, fFetchFile);
  497.     dataAt= fRichHandler->IsRich( databuf, datasize);
  498.     if (dataAt) {
  499.         fDocFormat= fRichHandler->Format();
  500.         return dataAt;
  501.         }
  502.     delete fRichHandler;
  503.  
  504.     fRichHandler = new DPICTHandler(fRichView, fFetchFile);
  505.     dataAt= fRichHandler->IsRich( databuf, datasize);
  506.     if (dataAt) {
  507.         fDocFormat= fRichHandler->Format();
  508.         fStufGo->fTransferType= kTransferBinary;  // ! this mayn't be safe ?!
  509.         return dataAt;
  510.         }
  511.     delete fRichHandler;
  512.  
  513.     fRichHandler = new DGIFHandler(fRichView, fFetchFile);
  514.     dataAt= fRichHandler->IsRich( databuf, datasize);
  515.     if (dataAt) {
  516.         fDocFormat= fRichHandler->Format();
  517.         fStufGo->fTransferType= kTransferBinary;  // ! this mayn't be safe ?!
  518.         return dataAt;
  519.         }
  520.     delete fRichHandler;
  521.                 
  522.     fRichHandler = new DNetHTMLHandler(fRichView, fFetchFile, fGolist);
  523. #if 0
  524.     // ?? not always ??
  525.     if (fStufGo && fStufGo->fProtocol == DGopher::kHTTPprot)
  526.         dataAt= databuf;
  527.     else
  528. #endif
  529.         dataAt= fRichHandler->IsRich( databuf, datasize);
  530.     if (dataAt) {
  531.         fDocFormat= fRichHandler->Format();
  532.         return dataAt;
  533.         }
  534.     delete fRichHandler;
  535.  
  536.     fRichHandler = new DRichHandler(fRichView, fFetchFile);
  537.     fDocFormat= fRichHandler->Format();
  538.     fStufGo->fTransferType= kTransferText; // fix problems caused by binary test
  539.     datasize= CRLF2Newline( databuf, datasize); 
  540.     fStufGo->fInfoSize= datasize;    // ??    
  541.     return databuf; 
  542. }
  543.  
  544.  
  545. void DGopherTextStore::ProcessTask(DTask* theTask) 
  546. {
  547.     if (theTask->fNumber == cStuf || theTask->fNumber == cStufInline) {
  548.  
  549.          Boolean gotInline= (theTask->fNumber == cStufInline);
  550.  
  551.         if ( fStufGo 
  552. #if 0
  553.             && (fStufGo->fInfoSize || fStufGo->ThreadProgress() != DGopher::kThreadDoneReading) 
  554. #endif
  555.             ) {
  556.             char * cbeg, * cend, clineend;
  557.             Boolean update= true, endOfData;
  558.             short lastItemCount=0, lastLineCount;
  559.             ulong dataRemaining, oldsize;
  560.             
  561.             endOfData= fStufGo->ThreadProgress() == DGopher::kThreadDoneReading;
  562.             fStufGo->ShowProgress();            
  563.             cbeg = fStufGo->fInfo; 
  564.             ulong csize= fStufGo->fInfoSize;
  565.             if (cbeg==NULL || csize==0) {
  566.                 if (! (endOfData && fRichHandler) ) return; 
  567.                 }
  568.             cend = cbeg + csize; // - 1; 
  569.             clineend = *LineEnd; 
  570.             
  571.             if (!fRichHandler || fFirststuff == 1) {
  572.                 oldsize= csize;
  573.                 char* cp= ProcessTask1(cbeg, csize);
  574.                 fRichHandler->fTasknum= theTask->fNumber - cStuf;
  575.                 if (!cp) return; 
  576.                 else if (cp > cbeg) {
  577.                     if (cp > cend) csize= 0; 
  578.                     else csize= cend - cp; // + 1; 
  579.                     Nlm_MemMove( cbeg, cp, csize);
  580.                     cend= cbeg + csize; // - 1;
  581.                     fStufGo->fInfoSize= csize;        
  582.                     }
  583.                 else if (oldsize != csize) {
  584.                     fStufGo->fInfoSize= csize;    
  585.                     cend = cbeg + csize; // - 1; 
  586.                     }
  587.                 }
  588.                 
  589.             if (fFirststuff>0)  
  590.                 fRichView->GetDocStats( lastItemCount, lastLineCount);
  591.              
  592.             dataRemaining = fStufGo->fInfoSize;
  593.             update= fRichHandler->ProcessData( cbeg, cend, endOfData, dataRemaining);
  594.             if (update) fStufGo->fInfoSize= dataRemaining;        
  595.             
  596.             if (endOfData && gotInline) {
  597.                 fRichHandler->InstallInStyle( fRichView, fInlineStyle);
  598.                 fInlineStyle= NULL;
  599.                 }
  600.  
  601.             if (update && fFirststuff>0 && update != 3 && !gotInline) { 
  602.                 Nlm_RecT  invalr;
  603.                 short i, winheight, pixh, pixold, 
  604.                             itemCount, lineCount, lineHeight, startsAt, rowCount;
  605.  
  606.                 invalr= fRichView->fViewrect;
  607.                 // check if we have updated all of display...
  608.                 winheight= invalr.bottom  -  invalr.top;
  609.                 fRichView->GetDocStats( itemCount, lineCount);
  610.                 pixold= 0;
  611.                 for (i= 1, pixh= 0; i<=itemCount; i++) {
  612.                     fRichView->GetItemStats( i, startsAt, rowCount, lineHeight);
  613.                     pixh += rowCount * lineHeight;
  614.                     if (i<=lastItemCount) pixold= pixh;
  615.                     }
  616.                 // remember pixh from last time & only inval new part !?
  617.                 invalr.top += pixold;
  618.                 fRichView->InvalRect(invalr);
  619.                 if (pixh >= winheight) fFirststuff= 0; 
  620.                 }
  621.  
  622.             }
  623.         
  624.         if (!fStufGo || fStufGo->ThreadProgress() == DGopher::kThreadDoneReading) {
  625.             theTask->SetRepeat(false); // done w/ gopher fetch, dequeue this task
  626.             //this->ShowMessage("done reading");
  627.             fFetchFile->Close();
  628.             delete fRichHandler; 
  629.             fRichHandler= NULL;
  630.             }
  631.         }
  632. }
  633.  
  634.  
  635. void DGopherTextStore::Close()
  636. {
  637.     if (fStufGo && fStufGo->ThreadProgress() != DGopher::kThreadDoneReading) {
  638.             // kill tcp connection !!!!!!!!
  639.         fStufGo->CloseQuery();
  640.         fStufGo->fThreadState= DGopher::kThreadNotStarted;  
  641.         fStufGo= NULL; // don't delete !?
  642.         }
  643.     if (fFetchFile) fFetchFile->Close();
  644.     if (fDocFile) fDocFile->Close();
  645. }
  646.  
  647.  
  648.  
  649. Boolean DGopherTextStore::OpenStore()
  650. {
  651.     // ?! need to link this proc w/ Window.Open() procs
  652.  
  653. #if 0
  654.             // do this in constructor !?
  655.     if (!fRichView) {
  656.         if (fIsLinkDoc)
  657.             fRichView= new DLinkedRichView(0, (DGoLinkedTextDoc*)fWindow, 
  658.                                                         gPrintManager->PageWidth(), 0);
  659.         else
  660.           fRichView= new DRichView(0, fWindow, gPrintManager->PageWidth(), 0);
  661.         }
  662.     fRichView->SetSlateBorder( true);
  663.     fRichView->SetResize( DView::matchsuper, DView::relsuper);
  664.     fRichView->SetTabs( gTextTabStops);
  665.     //fRichView->SizeToSuperview( fWindow, true, false); // this needs to adjust for if view has scrollbar !
  666. #endif
  667.         
  668.   if (!fGolist) fGolist= new DGopherList(NULL);
  669.     fGolist->fParentMenu= fParentGo;  
  670.     if (!fIsFromFile && fParentGo) {
  671.         fGolist->InsertFirst( fParentGo); // !?!? put papa into list, 
  672.                 // mainly for use  with extract !?
  673.         if (fParentGo->fThreadState == DGopher::kThreadNotStarted) 
  674.             fParentGo->ReadTask();  // tell gopher to read data thru a repeat task
  675.         if (fParentGo->fThreadState == DGopher::kThreadDoneReading 
  676.           && fParentGo->fInfoSize < 1) { 
  677.             fParentGo->fThreadState= DGopher::kThreadNotStarted; // ! need to reset this somewhere for used gophers
  678.             this->suicide(); 
  679.             return false;  // ?? return false; ?? 
  680.             }
  681.         fStufGo= fParentGo;
  682.         //DTask* aStuffTask= newTask(cStuf, DGopherTextDoc::kGoTextdoc);
  683.         DTask* aStuffTask= new DTask(cStuf, DGopherTextDoc::kGoTextdoc, fWindow);
  684.         aStuffTask->SetRepeat(true);
  685.         this->PostTask( aStuffTask);
  686.         }
  687.         
  688.     return true; 
  689. }
  690.     
  691.  
  692.  
  693.  
  694.  
  695.  
  696.  
  697.  
  698.  
  699.  
  700.  
  701.  
  702.  
  703.  
  704.  
  705.  
  706.  
  707.  
  708.  
  709. // class    DGopherTextDoc : public DRichTextDoc
  710.  
  711.  
  712. DGopherTextDoc::DGopherTextDoc(long id, DGopher* itsGopher, Boolean havelinks) :
  713.         DRichTextDoc( id, false),
  714.         fInUse(false), fPinned(false), fStickpin(NULL),
  715.         fTextStoreList(NULL), fListAt(kEmptyIndex),
  716.         fStore(NULL), fStatus(NULL)
  717. { 
  718.     DIconButton* ib;
  719.     
  720.     if (fRichView) { this->RemoveSubview( fRichView, true); fRichView= NULL; }
  721.     
  722.     //fTextStoreList= new DList(NULL, DList::kDeleteObjects);
  723.     fTextStoreList= new DList(NULL);
  724.     fStickpin= new DIconButton( cPushpin, this, &gPushpinOut);
  725.     this->NextSubviewToRight();
  726. #if 0
  727.     ib = new DIconButton( cParentDrop, this, &gDownTriangle);
  728.     this->NextSubviewBelowLeft();
  729. #endif
  730.     ib = new DIconButton( cShiftBack, this, &gLeftTriangle);
  731.     this->NextSubviewToRight();
  732.     fShiftBack= ib; fShiftBack->Disable();
  733.     ib = new DIconButton( cShiftFore, this, &gRightTriangle);
  734.     this->NextSubviewBelowLeft();
  735.     fShiftFore= ib; fShiftFore->Disable();
  736.     
  737.     this->GetNextPosition( &fTextViewLoc);
  738.     fTextViewLoc.x= 0; // fix for odd offset
  739.     this->SetNextPosition( fTextViewLoc);
  740.     fStore= new DGopherTextStore( itsGopher, this, havelinks);
  741.     fRichView= fStore->fRichView;
  742.     
  743.     AddToList(fStore);
  744.     fSaveHandler= this;  
  745.     fPrintHandler= fRichView; // make sure current view is printed
  746.     this->NextSubviewBelowLeft();
  747. }
  748.         
  749. DGopherTextDoc::~DGopherTextDoc()
  750. {
  751.     if (fTextStoreList) {
  752.             // !! DAMMIT, delete fTextStoreList IS NOT freeing fStore objects !!
  753.         short i, n= fTextStoreList->GetSize();
  754.         for (i=0; i<n; i++) {
  755.             DGopherTextStore* st= (DGopherTextStore*) fTextStoreList->At(i);
  756.             delete st; // !!!!! DIE DAMMIT
  757.             }
  758.         delete fTextStoreList; // deletes all objects in list
  759.         }
  760.     //if (fStore) delete fStore; //<< fTextStoreList kills this
  761. }
  762.  
  763.  
  764. void DGopherTextDoc::AddToList( DGopherTextStore* theStore)
  765. {
  766.         // clean out storage below current displayed item...
  767.   for (short idoc= fTextStoreList->GetSize()-1; idoc>fListAt; idoc--) {
  768.         DGopherTextStore* st= (DGopherTextStore*) fTextStoreList->At(idoc);
  769.         delete st; // !!!!! DIE DAMMIT
  770.       fTextStoreList->AtDelete(idoc); // DOESN"T delete all of storage
  771.       }
  772.     fTextStoreList->Push( theStore);
  773.     fListAt= fTextStoreList->GetSize()-1;
  774. }
  775.  
  776.  
  777. Boolean DGopherTextDoc::PushNewDoc( DGopher* itsGopher, DGopherList* itsList, Boolean havelinks)
  778. {
  779.     // !! need to test for free mem here, free top of fTextStoreList if full...
  780.     if (!fInUse && !fPinned) {
  781.         this->SetNextPosition( fTextViewLoc);
  782.         DGopherTextStore* newStore= new DGopherTextStore( itsGopher, this, havelinks);
  783.         if (!newStore->OpenStore()) { 
  784.             delete newStore;
  785.             }
  786.         else {
  787.           fRichView->Hide();
  788.             fStore= newStore;
  789.             fRichView= fStore->fRichView;
  790.             this->AddToList(fStore);
  791.             if (fStatus) {
  792.                 fStore->fGolist->SetStatus( fStatus);
  793.                 if (fStore->fParentGo) fStore->fParentGo->fStatusLine= fStatus;
  794.                 }
  795.             this->SetTitle((char*)fStore->GetTitle());
  796.             fSaveHandler= this; // replace fRichView's handler w/ us        
  797.             fPrintHandler= fRichView; // make sure current view is printed
  798.             this->ShowMessage("Reading...");
  799.             gGopherTextDoc= this; // track front gopher doc/window
  800.             fRichView->SizeToSuperview( this, true, false); // this needs to adjust for if view has scrollbar !
  801.             this->Invalidate();
  802.             fShiftBack->Enable();
  803.             fShiftFore->Disable();
  804.             //this->Select();    //?? DWindow::Open()
  805.             //this->Show();     //?? DWindow::Open()
  806.             }
  807.         return true;
  808.         }
  809.     else
  810.         return false;
  811. }
  812.  
  813.  
  814. Boolean DGopherTextDoc::PopDoc( short numitems)
  815. {
  816.     DGopherTextStore* astore = NULL;
  817.     if (fTextStoreList->GetSize() != kEmptySize) {
  818.         short newat = fListAt - numitems;
  819.         if (newat > kEmptyIndex && newat < fTextStoreList->GetSize()) {
  820.             fListAt= newat;
  821.             astore= (DGopherTextStore*) fTextStoreList->At( fListAt);
  822.             }
  823.         }
  824.     if (astore) {
  825.       fRichView->Hide();
  826.         fStore= astore;
  827.         fRichView= fStore->fRichView;
  828.             // ?? need to make sure fRichView is in this window  !! YES
  829.         //fRichView->SetWindow(this); //<< doesn't set scrollbars, other stuff !?
  830.         this->SetTitle( (char*)fStore->GetTitle());
  831.       fRichView->Select(); //?? for motif
  832.       fRichView->Show();
  833.       
  834.         if (fListAt+1 < fTextStoreList->GetSize()) fShiftFore->Enable();
  835.         else fShiftFore->Disable();
  836.         if (fListAt > 0) fShiftBack->Enable();
  837.         else fShiftBack->Disable();
  838.         return true;
  839.         }
  840.     else
  841.         return false;
  842. }
  843.  
  844.  
  845. void DGopherTextDoc::Close()
  846. {
  847.     fStore->Close();
  848.     if (gGopherTextDoc == this) gGopherTextDoc= NULL; // track front gopher doc/window
  849.     fInUse= false;
  850.     fPinned= false;
  851.     DRichTextDoc::Close();
  852. }
  853.  
  854.  
  855. void DGopherTextDoc::Activate()
  856. {    
  857.     if (DGopherListDoc::gLockWinMenuItem) 
  858.         DGopherListDoc::gLockWinMenuItem->SetStatus( fInUse || fPinned);        
  859.     gGopherTextDoc= this; // track front gopher doc/window
  860.     DRichTextDoc::Activate();
  861. }
  862.  
  863. void DGopherTextDoc::Deactivate()
  864. {    
  865. #if 0
  866.     if (DGopherListDoc::gLockWinMenuItem)  
  867.         DGopherListDoc::gLockWinMenuItem->SetStatus(false);
  868.     if (gGopherTextDoc == this) gGopherTextDoc= NULL;  
  869. #endif
  870.     DRichTextDoc::Deactivate();
  871. }
  872.  
  873.  
  874. Boolean DGopherTextDoc::IsMyTask(DTask* theTask) 
  875. {
  876.     if (theTask->fKind == kGoTextdoc) {
  877.         ProcessTask( theTask);
  878.         return true;
  879.         }
  880.     else 
  881.         return DWindow::IsMyTask(theTask);
  882. }
  883.  
  884. void DGopherTextDoc::ProcessTask( DTask* theTask)
  885. {
  886.     if (theTask->fNumber == cStuf || theTask->fNumber == cStufInline) { 
  887.         fStore->ProcessTask( theTask);
  888.         if (!fStore->fRichHandler) this->ShowMessage("done reading");
  889.         }
  890.     else
  891.         DRichTextDoc::ProcessTask( theTask);
  892. }
  893.  
  894.  
  895. void DGopherTextDoc::PinWindow(Boolean turnon)
  896. { 
  897.     fPinned= turnon;
  898.     if (fStickpin) {
  899.         if (fPinned) fStickpin->SetIcon( &gPushpinIn, true);
  900.         else fStickpin->SetIcon( &gPushpinOut, true);
  901.         }
  902. }
  903.  
  904. Boolean DGopherTextDoc::IsMyAction(DTaskMaster* action) 
  905. {
  906.     switch(action->Id()) {
  907.     
  908.         case cParentDrop:
  909.             return true;
  910.  
  911.         case cPushpin:
  912.             PinWindow( !fPinned);
  913.             return true;
  914.  
  915.         default: 
  916.             return DRichTextDoc::IsMyAction(action);
  917.         }
  918. }
  919.  
  920.  
  921. const char* DGopherTextDoc::GetFileToSave(DFile*& aFile)
  922. {
  923.     static char *name;
  924.     enum   { kLineMax = 512 };
  925.     char     filename[kLineMax];
  926.     char   *suffix = NULL, *macsire = NULL, *mactype = NULL;
  927.     Boolean    useTemp;
  928.     char     *writeflag= "w"; 
  929.     
  930.     useTemp= (fStore->fDocFormat != DRichHandler::kTextformat 
  931.                 && (fStore->fDocFile || fStore->fFetchFile));
  932.     if (!aFile) {
  933.         name= this->GetTitle();
  934.         if (useTemp) switch (fStore->fDocFormat) {
  935.             case DRTFHandler::kRTFformat  : 
  936.                 DRTFHandler::RTFFileSigs( suffix, mactype, macsire);
  937.                 writeflag= "w"; 
  938.                 break;
  939.             case DPICTHandler::kPICTformat:  
  940.                 DPICTHandler::PICTFileSigs( suffix, mactype, macsire); 
  941.                 writeflag= "wb"; 
  942.                 break;
  943.             case DGIFHandler::kGIFformat    : 
  944.                 DGIFHandler::GIFFileSigs( suffix, mactype, macsire); 
  945.                 writeflag= "wb"; 
  946.                 break;
  947.             case DHTMLHandler::kHTMLformat: 
  948.                 DHTMLHandler::HTMLFileSigs( suffix, mactype, macsire); 
  949.                 writeflag= "w"; 
  950.                 break;
  951.             default:
  952.                 DRichHandler::RichFileSigs( suffix, mactype, macsire); 
  953.                 writeflag= "w"; 
  954.                 break;
  955.             }
  956.         else  
  957.             DRichHandler::RichFileSigs( suffix, mactype, macsire); 
  958.         sprintf(filename, "%s%s", name, suffix);
  959.         MemFree(name);
  960.         name= (char*) gFileManager->GetOutputFileName(filename);  
  961.         if (name) aFile= new DFile( name, writeflag, mactype, macsire);
  962.         }
  963.     else  {
  964.         name= (char*) aFile->GetName();
  965.         }
  966.     return name;
  967. }
  968.  
  969.  
  970. void DGopherTextDoc::Save(DFile* aFile)
  971. {
  972.     char    *name = NULL, *data, *readkind, *writekind;
  973.     char     *mackind= "TEXT", *macsire= "ttxt";
  974.     Boolean callerOwnsFile= (aFile != NULL);
  975.     Boolean    useTemp;
  976.     
  977.     useTemp= (fStore->fDocFormat != DRichHandler::kTextformat 
  978.                 && (fStore->fDocFile || fStore->fFetchFile));
  979.     gCursor->watch();
  980.     if (callerOwnsFile) 
  981.         name= (char*) aFile->GetName();
  982.     else        
  983.         name= (char*) GetFileToSave( aFile);
  984.         
  985.     if (aFile) {
  986.         if (useTemp) { 
  987.             mackind= aFile->fType;
  988.             macsire= aFile->fSire;
  989.             aFile->Delete();
  990.             }
  991.         else {
  992.             fRichView->Save(aFile); 
  993.             this->NotDirty(); // !? is this correct, but only for current fRichView !?
  994.             }
  995.         if (!callerOwnsFile) delete aFile; //aFile->suicide();
  996.         }
  997.  
  998.     switch( fStore->fDocFormat ) {
  999.         case DPICTHandler::kPICTformat:  
  1000.         case DGIFHandler::kGIFformat:  
  1001.             writekind= "wb";
  1002.             readkind= "rb";
  1003.             break;
  1004.                 
  1005.         case DHTMLHandler::kHTMLformat:  
  1006.         case DRTFHandler::kRTFformat:
  1007.         case DRichHandler::kTextformat:
  1008.         default: 
  1009.             writekind= "w";
  1010.             readkind= "r";
  1011.             break;
  1012.         }
  1013.             
  1014.     if (useTemp) {
  1015.         DFile tFile( name, writekind, mackind, macsire);
  1016.         fStore->WriteDoc( &tFile, readkind, writekind);
  1017.         this->NotDirty(); // !? is this correct, but only for current fRichView !?
  1018.         }
  1019.             
  1020.     gCursor->arrow();
  1021. }
  1022.  
  1023.  
  1024. void DGopherTextDoc::ShowMessage(const char* msg)
  1025. {
  1026.     if (fStatus) fStatus->SetTitle( (char*)msg);
  1027. }
  1028.  
  1029.  
  1030.  
  1031. void DGopherTextDoc::Open()
  1032. {
  1033.     if (!fStore->OpenStore()) 
  1034.         this->suicide();
  1035.     else {
  1036.                 // add status line after DRichView...
  1037.                 // this is for Window part of doc
  1038.         Nlm_ResizeWindow( (Nlm_GraphiC)fWindow, kWinDragHeight, kWinScrollWidth,
  1039.                              kWinMinWidth, kWinExtraHeight+16);
  1040.         MakeSmallFont();
  1041.         Nlm_PoinT nps;
  1042.         this->GetNextPosition( &nps);
  1043.         DPrompt* pr= new DPrompt( 0, this, "Status:", 0, 0, gSmallFont); // Nlm_programFont
  1044.         pr->SetResize( DView::fixed, DView::moveinsuper);
  1045.         // positioning is messed up, maybe because this is at bottom of window??
  1046.         //this->NextSubviewToRight();
  1047.         nps.x += Nlm_StringWidth( "Status:");
  1048.         this->SetNextPosition(nps);
  1049.         
  1050.         fStatus= new DPrompt(  0, this, NULL, 350, 0, gSmallFont); // Nlm_programFont
  1051.         fStatus->SetResize( DView::fixed, DView::moveinsuper);
  1052.         
  1053.         if (fStatus) {
  1054.             fStore->fGolist->SetStatus( fStatus);
  1055.             if (fStore->fParentGo) fStore->fParentGo->fStatusLine= fStatus;
  1056.             }
  1057.         
  1058.         this->SetTitle( (char*)fStore->GetTitle());
  1059.         fSaveHandler= this; // replace fRichView's handler w/ us    
  1060.         fPrintHandler= fRichView; // make sure current view is printed
  1061.         fRichView->SizeToSuperview( this, true, false); // this needs to adjust for if view has scrollbar !
  1062.         this->ShowMessage("Reading...");
  1063.         gGopherTextDoc= this; // track front gopher doc/window
  1064.         
  1065.         // DRichTextDoc::Open() does ResizeWindow, SizeToSuperview && DWIndow::Open 
  1066.         // ?? use it instead ??
  1067.         DWindow::Open();
  1068.         }
  1069. }
  1070.  
  1071.  
  1072.  
  1073.  
  1074.  
  1075.  
  1076.  
  1077.  
  1078.  
  1079.  
  1080.  
  1081.  
  1082.  
  1083.  
  1084.  
  1085.  
  1086.  
  1087.  
  1088.  
  1089.  
  1090. //class DGoLinkedTextDoc : public DGopherTextDoc
  1091.  
  1092. Boolean DGoLinkedTextDoc::gAutoloadInlines = TRUE;
  1093.  
  1094. DGoLinkedTextDoc::DGoLinkedTextDoc(long id, DGopher* itsGopher, DGopherList* itsList) :
  1095.         DGopherTextDoc( id, itsGopher),
  1096.         fGopherDoc(NULL),
  1097.         fInlineParts(NULL)
  1098. { 
  1099. #if 1
  1100.     if (itsList) itsList->newOwner();
  1101.     else itsList= new DGopherList(NULL);
  1102.     fStore->fIsLinkDoc= true;
  1103.     fStore->SetGolist(itsList);
  1104. #else
  1105.     fGopherDoc= itsGoDoc;  
  1106.     if (!fGopherDoc) {
  1107.         fGopherDoc= new DGopherListDoc();
  1108.         fGopherDoc->fGolist= new DGopherList(NULL);
  1109.         fGopherDoc->fGoview= new DGolistView(0, fGopherDoc, fGopherDoc->fGolist, kGolistViewWidth);
  1110.         }
  1111.     else
  1112.         fGopherDoc->newOwner();
  1113.     fStore->fIsLinkDoc= true;
  1114.     fStore->SetGolist(fGopherDoc->fGolist);
  1115. #endif
  1116. }
  1117.         
  1118. DGoLinkedTextDoc::~DGoLinkedTextDoc()
  1119. {
  1120.     if (fGopherDoc) fGopherDoc->suicide(); //???
  1121.     if (fInlineParts) delete fInlineParts;
  1122. }
  1123.  
  1124.  
  1125. Boolean DGoLinkedTextDoc::PushNewDoc( DGopher* itsGopher, DGopherList* itsList, Boolean havelinks) 
  1126. {
  1127.     if (itsList) itsList->newOwner();
  1128.     else itsList= new DGopherList(NULL);
  1129.  
  1130.     if (!DGopherTextDoc::PushNewDoc( itsGopher, itsList, true)) 
  1131.         return false;
  1132.  
  1133.     fStore->fIsLinkDoc= true;
  1134.     fStore->SetGolist(itsList);
  1135.     
  1136.     return true;
  1137. }
  1138.  
  1139. Boolean DGoLinkedTextDoc::PushNewLocalDoc(DFile* docFile, DFile* goFile)
  1140. {
  1141.     if (!this->PushNewDoc( (DGopher*)NULL, (DGopherList*)NULL, true)) 
  1142.         return false;
  1143.     if ( ReadFrom( docFile, goFile) ) {
  1144.         fStore->OpenStore();
  1145.         if (fStore->fParentGo) this->SetTitle((char*)fStore->GetTitle());
  1146.         else if (docFile) this->SetTitle((char*)docFile->GetName());
  1147.         }
  1148.     else 
  1149.         this->PopDoc(1);
  1150.     return true;
  1151. }
  1152.  
  1153.  
  1154. // static
  1155. short DGoLinkedTextDoc::TestFormat(char* databuf, ulong datasize, char*& datastart) 
  1156. {
  1157.     short format = 0;
  1158.     datastart= NULL;
  1159.     DRichHandler* doctest;
  1160.     long        ioffs;
  1161.     
  1162.     if ( Nlm_StrNICmp( databuf, "+MENU:", 6 ) == 0) {
  1163.         // this is a shaky test, need better magic key for this data ?!!?
  1164.         datastart= databuf;
  1165.         return DGopher::cGopherNetDoc;
  1166.         }
  1167.     else {
  1168.         char* cp= (char*) MemChr( databuf, '\n', MIN(datasize,255));
  1169.       if (cp && Nlm_StrNICmp( cp+1, "+MENU:", 6 ) == 0)  {
  1170.             datastart= cp+1;
  1171.             return DGopher::cGopherNetDoc;
  1172.             }
  1173.         }
  1174.         
  1175.     if ( DGopherList::IsGopherLine( databuf) ) {
  1176.         datastart= databuf;
  1177.         return DGopher::cNewGopherFolder; // == 2211
  1178.         }
  1179.  
  1180.     doctest = new DRTFHandler( NULL, NULL);
  1181.     datastart= doctest->IsRich( databuf, datasize);
  1182.     if (datastart) format= doctest->Format();
  1183.     delete doctest;
  1184.     if (format) return format;
  1185.         
  1186.     doctest = new DPICTHandler( NULL, NULL);
  1187.     datastart= doctest->IsRich( databuf, datasize);
  1188.     if (datastart)  format= doctest->Format();
  1189.     delete doctest;
  1190.     if (format) return format;
  1191.  
  1192.     doctest = new DGIFHandler( NULL, NULL);
  1193.     datastart= doctest->IsRich( databuf, datasize);
  1194.     if (datastart)  format= doctest->Format();
  1195.     delete doctest;
  1196.     if (format) return format;
  1197.  
  1198.     doctest = new DHTMLHandler( NULL, NULL);
  1199.     datastart= doctest->IsRich( databuf, datasize);
  1200.     if (datastart)  format= doctest->Format();
  1201.     delete doctest;
  1202.     if (format) return format;
  1203.  
  1204.     doctest = new DRichHandler( NULL, NULL);
  1205.     datastart= databuf;
  1206.     format= doctest->Format();
  1207.     delete doctest;
  1208.     return format;
  1209. }
  1210.  
  1211.  
  1212. // ?????
  1213. void DGoLinkedTextDoc::ProcessTask( DTask* theTask)
  1214. {
  1215.     if (theTask->fNumber == cProcessInlines) {
  1216.         if (!fStore->fStufGo) { // !! we can't do more than one at a time !! (not yet)
  1217.             if (!ReadInlinePart() )
  1218.                 theTask->SetRepeat(false);  // dequeue this task
  1219.             }
  1220.         }
  1221.     else 
  1222.         DGopherTextDoc::ProcessTask( theTask); 
  1223.  
  1224.     if (theTask->fNumber == cStuf) {
  1225.         if (!fStore->fStufGo 
  1226.          || fStore->fStufGo->ThreadProgress() == DGopher::kThreadDoneReading) {
  1227.             // add fGolist links into fRichView text.... (do also for net-read doc)
  1228.             this->ShowMessage("marking links...");
  1229.             this->AddGolinksToDoc();
  1230.             fRichView->Invalidate();
  1231.             this->ShowMessage("ready");
  1232.             fStore->fStufGo= NULL;
  1233.             }
  1234.         }
  1235.     else if (theTask->fNumber == cStufInline) {
  1236.         if (!fStore->fStufGo 
  1237.          || fStore->fStufGo->ThreadProgress() == DGopher::kThreadDoneReading) {
  1238.             fRichView->Invalidate();
  1239.             this->ShowMessage("ready");
  1240.             fStore->fStufGo= NULL;
  1241.             }
  1242.         }
  1243. }
  1244.  
  1245.  
  1246. class DGoStyle : public DObject
  1247. {
  1248. public:
  1249.     DGopher*         fGo;
  1250.     DRichStyle* fStyle;
  1251.     short    fStyleindex;
  1252.     
  1253.     DGoStyle( short indx, DRichStyle* st, DGopher* go):
  1254.         fStyleindex(indx), fGo(go), fStyle(st)
  1255.     {
  1256.     }
  1257.     ~DGoStyle() {}
  1258. };
  1259.  
  1260.  
  1261. Boolean DGoLinkedTextDoc::ReadInlinePart()
  1262. {
  1263.     DGoStyle* gs = (DGoStyle*) fInlineParts->Dequeue();
  1264.     fStore->fStufGo= NULL;
  1265.     if (gs) {
  1266.         //fStore->fStufGo= gs->fGo;
  1267.         //fStore->fStufGo->ReadTask();  // tell gopher to read data thru a repeat task
  1268.         gs->fGo->ReadTask();
  1269.         if (gs->fGo->fThreadState != DGopher::kThreadDoneReading) { 
  1270. #if 1
  1271.             fStore->StartInlineFetch( gs->fGo, gs->fStyle);
  1272. #else
  1273.             if (!fStore->fDocFile && fStore->fFetchFile) {
  1274.                 fStore->fDocFile= fStore->fFetchFile;
  1275.                 fStore->fFetchFile= new DTempFile();
  1276.                 }
  1277.             fStore->fFirststuff= 1;
  1278.             fStore->fInlineStyle= gs->fStyle;
  1279. #endif
  1280.             DTask* aStuffTask= newTask( cStufInline, kGoTextdoc);
  1281.             aStuffTask->SetRepeat(true);
  1282.             this->PostTask( aStuffTask); 
  1283.             }
  1284.         else 
  1285.             fStore->fStufGo= NULL;
  1286.         delete gs;
  1287.         return true;
  1288.         }
  1289.     else 
  1290.         return false;
  1291. }
  1292.  
  1293.  
  1294. void DGoLinkedTextDoc::SetupInlinePart( DRichStyle* st)
  1295. {
  1296.     Boolean added= false;
  1297.     Boolean needtask= (!fInlineParts || fInlineParts->GetSize() == 0);
  1298.     if (st->ispict && st->fPict && st->fPict->HasNetPict()) {
  1299.         short linkid= st->fPict->fLinks[0].fLinkid;
  1300.         if (linkid) {
  1301.             DGopher* ag= fStore->fGolist->GopherAt(linkid-1);
  1302.             if (ag) {
  1303.                 DGoStyle* gs= new DGoStyle( 0, st, ag);
  1304.                 if (!fInlineParts) fInlineParts= new DList();
  1305.                 fInlineParts->Queue( gs);
  1306.                 added= true;
  1307.                 }
  1308.             }
  1309.         }
  1310.     if (needtask && added && fInlineParts->GetSize()) {
  1311.         DTask* aStuffTask= newTask( cProcessInlines, kGoTextdoc);
  1312.         aStuffTask->SetRepeat(true);
  1313.         this->PostTask( aStuffTask); 
  1314.         }
  1315. }
  1316.  
  1317.  
  1318. void DGoLinkedTextDoc::SetupInlineParts()
  1319. {
  1320.     Boolean added= false;
  1321.     Boolean needtask= (!fInlineParts || fInlineParts->GetSize() == 0);
  1322.     short i, n= fRichView->fStyles->GetSize();
  1323.     for (i= 0; i<n; i++) {
  1324.         DRichStyle* st= (DRichStyle*) fRichView->fStyles->At(i);
  1325.         if (st->ispict && st->fPict && st->fPict->HasNetPict()) {
  1326.             short linkid= st->fPict->fLinks[0].fLinkid;
  1327.             if (linkid) {
  1328.                 DGopher* ag= fStore->fGolist->GopherAt(linkid-1);
  1329.                 if (ag) {
  1330.                     DGoStyle* gs= new DGoStyle( i, st, ag);
  1331.                     if (!fInlineParts) fInlineParts= new DList();
  1332.                     fInlineParts->Queue( gs);
  1333.                     added= true;
  1334.                     }
  1335.                 }
  1336.             }
  1337.         }
  1338.     if (needtask && added && fInlineParts->GetSize()) {
  1339.         DTask* aStuffTask= newTask( cProcessInlines, kGoTextdoc);
  1340.         aStuffTask->SetRepeat(true);
  1341.         this->PostTask( aStuffTask); 
  1342.         }
  1343. }
  1344.  
  1345.  
  1346.  
  1347.  
  1348. void DGoLinkedTextDoc::ExtractGopherDoc()
  1349. {
  1350.     fStore->fGolist->newOwner();
  1351.     if (fStore->fParentGo) fStore->fParentGo->newOwner();
  1352.     fStore->fGolist->fParentMenu= fStore->fParentGo;
  1353. #if 0
  1354.         // Replace is buggy still 
  1355.     if (gGopherDoc && gGopherDoc->ReplaceData( fStore->fGolist)) 
  1356.         ;  // never here because this doc is active & gGopherDoc is NULL if not frontwin
  1357.     else
  1358. #endif
  1359.   {
  1360.         DGopherListDoc* win= 
  1361.           new DGopherListDoc( DGopherListDoc::kGoListdoc, fStore->fGolist, 
  1362.                                                 this->GetTitle());
  1363.         //win->Open(true); //<< new does this !?
  1364.         }
  1365. }
  1366.  
  1367.  
  1368. void DGoLinkedTextDoc::OpenGopherLink( short gopherItem, Nlm_PoinT* mappt)
  1369. { 
  1370.     if (fStore->fGolist) {
  1371.         DGopher* ag= fStore->fGolist->GopherAt(gopherItem);
  1372.         OpenGopherLink( ag, mappt);
  1373.         }
  1374. }
  1375.  
  1376. void DGoLinkedTextDoc::OpenGopherLink( DGopher* ag, Nlm_PoinT* mappt)
  1377. { 
  1378.     if (ag) {   
  1379.         char *maps = NULL;
  1380.         gCursor->watch();
  1381.         this->ShowMessage("opening link...");
  1382.         Boolean nooption= false;
  1383.         Boolean optionIsOn= gKeys->option();
  1384.         if (ag) {
  1385.             nooption= (ag->fType == kTypeFolder 
  1386.                 || ag->fType == kTypeQuery  // ??
  1387.                 || ag->fIsMap
  1388.                 || ag->fIsPlus != kGopherPlusYes); 
  1389.             if (!nooption && DGopherListDoc::gOptionIsOn) 
  1390.                 optionIsOn= !optionIsOn;
  1391.             if (mappt) {
  1392.                 char  buf[128];
  1393.                 sprintf( buf, "\t%d,%d", mappt->x, mappt->y);
  1394.                 maps= StrDup( buf);
  1395.                 ag->fQuery= maps;
  1396.                 }
  1397.             if (optionIsOn)  
  1398.                 (void) DGopherListDoc::GopherByViewDialog(ag, ag->fOwnerList);
  1399.             else {
  1400.                 short itsViewchoice= DGopherListDoc::DefaultGopherView(ag);
  1401.                 DGopherListDoc::ProcessGopher( ag, itsViewchoice);
  1402.                 }
  1403.             if (mappt && maps) {
  1404.                     // !? maker of fQuery must free it when gopher processing is done!?
  1405.                     // can we fix DGopher::CloseQuery() to handle this?
  1406.                     // e.g., all fQuery must be owned by the gopher item...
  1407.                 maps= (char*) MemFree(maps);
  1408.                 }
  1409.              }
  1410.         gCursor->arrow();
  1411.          }
  1412. }
  1413.  
  1414.  
  1415. Boolean DGoLinkedTextDoc::IsMyAction(DTaskMaster* action) 
  1416. {
  1417.     switch(action->Id()) {
  1418.     
  1419.         case cParentDrop:
  1420.             return true;
  1421.         
  1422.         case cShiftFore:
  1423.             this->PopDoc(-1);
  1424.             return true;
  1425.             
  1426.         case cShiftBack:
  1427.             this->PopDoc(1);
  1428.             return true;
  1429.             
  1430.         case cMenuPopup: {
  1431.             DPopupList* pl= (DPopupList*) action;  
  1432.             if (pl) OpenGopherLink( pl->GetValue() - 1);
  1433.             }
  1434.             return true;
  1435.  
  1436.         default: 
  1437.             return DGopherTextDoc::IsMyAction(action);
  1438.         }
  1439. }
  1440.  
  1441.  
  1442.  
  1443. Boolean DGoLinkedTextDoc::ReadFrom(DFile* docFile, DFile* goFile)
  1444. {
  1445.     if (docFile) {
  1446. #if 1
  1447.  
  1448. #else
  1449.         if (!fGopherDoc) {
  1450.             fGopherDoc= new DGopherListDoc();
  1451.             fGopherDoc->fGolist= new DGopherList(NULL);
  1452.             fGopherDoc->fGoview= new DGolistView(0, fGopherDoc, fGopherDoc->fGolist, kGolistViewWidth);
  1453.             }
  1454.         fStore->SetGolist(fGopherDoc->fGolist);
  1455. #endif
  1456.  
  1457.         if (fStatus) fStore->fGolist->SetStatus( fStatus);
  1458.         if (!fStore->fGolist->fParentMenu) {
  1459.             char docurl[1024];
  1460.             char * name = (char*) docFile->GetName();
  1461.             char quote= '\'';
  1462.             if (StrChr( name, quote)) quote= '"';
  1463.             StrCpy(docurl, " file:///");
  1464.             StrNCat(docurl, name, 1000);
  1465.             StrNCat(docurl, " ", 1000); 
  1466.             docurl[1023]= 0;
  1467.             long doclen= StrLen(docurl);
  1468.             docurl[0]= quote; // so parseURL doesn't eat spaces
  1469.             docurl[doclen-1]= quote;
  1470.             fStore->fGolist->fParentMenu= DGopherList::GopherFromURL(docurl, doclen, fStore->fGolist);
  1471.             //this->SetTitle((char*)docFile->GetName());
  1472.             // ! GopherFromURL() sticks new gopher into list also !
  1473.             }
  1474.         fStore->fParentGo= fStore->fGolist->fParentMenu;
  1475.     
  1476.       if (goFile) {
  1477.             ulong filelen;
  1478.             goFile->OpenFile();
  1479.             goFile->GetDataLength(filelen);
  1480.             char* buf= (char*) MemNew( filelen+1);
  1481.             goFile->ReadData( buf, filelen);
  1482.             //fGopherDoc->AddData( buf, filelen);
  1483.             fStore->fGolist->ReadLinks( buf, filelen);
  1484.             MemFree( buf);
  1485.             goFile->CloseFile();
  1486.             delete goFile;
  1487.             //fGopherDoc->UpdateListSize();
  1488.             //fGopherDoc->fGoview->SetColWidths(); //?
  1489.             }
  1490.             
  1491.         // delete docFile; //<< !?!?!?
  1492.         fStore->fIsFromFile= false;
  1493.         return true;
  1494.         }
  1495.     else
  1496.         return false;
  1497. }
  1498.  
  1499.  
  1500. void DGoLinkedTextDoc::Save(DFile* aFile)
  1501. {
  1502.     // we have to dup this part from DGopherTextDoc::Save() or rewrite all of save usage...
  1503.     char    filename[512];
  1504.     char    *name = NULL, *data;
  1505.     ulong    dlen;
  1506.     Boolean callerOwnsFile= (aFile != NULL);
  1507.     
  1508.     if (callerOwnsFile)  
  1509.         name= (char*) aFile->GetName();
  1510.     else        
  1511.         name= (char*) GetFileToSave( aFile);
  1512.         
  1513.     if (aFile) {
  1514.         DGopherTextDoc::Save(aFile);
  1515.         // and save data to filename.go4 == filename.DGopherListDoc::kGopherDocSuffix
  1516.  
  1517.         switch ( fStore->fDocFormat && fStore->fGolist->GetSize()>0 ) {
  1518.             case DHTMLHandler::kHTMLformat:  
  1519.                 break;
  1520.                 
  1521.             case DGIFHandler::kGIFformat:  
  1522.             case DPICTHandler::kPICTformat:  
  1523.             case DRTFHandler::kRTFformat:
  1524.             default: 
  1525.                 gCursor->watch();
  1526.                 aFile->Close();
  1527.                 StrNCpy( filename, (char*) aFile->GetName(), 512);
  1528.                 gFileManager->ReplaceSuffix(filename, 512, DGopherListDoc::kGopherDocSuffix);
  1529.             
  1530.                 data= fStore->fGolist->WriteLinks();
  1531.                 dlen= StrLen(data);
  1532.                  {
  1533.                      // sunCC is getting confused w/ DFile bFile() unless wrapped in braces !
  1534.                      DFile bFile( (const char*)filename, (const char*)"w", 
  1535.                                           (const char*)"TEXT",  (const char*)"IGo4");
  1536.                   //aFile->Initialize( filename, "w", "TEXT", "IGo4");
  1537.                   bFile.OpenFile();  
  1538.                   bFile.WriteData(data, dlen); 
  1539.                   bFile.CloseFile(); 
  1540.                  }
  1541.                 MemFree(data);
  1542.                 gCursor->arrow();
  1543.                 break;
  1544.             }
  1545.             
  1546.         if (!callerOwnsFile) delete aFile; // aFile->suicide();  
  1547.         }
  1548.     
  1549. }
  1550.  
  1551.  
  1552.  
  1553.  
  1554.  
  1555. void DGoLinkedTextDoc::InsertLink( short golistItem, DGopher* theGo, short atparag, short atchar, short atlen)
  1556. {
  1557.     DRichStyle linkStyle;
  1558.     
  1559.     DRichStyle* aStyle= fRichView->GetStyleAtChar( atparag, atchar);
  1560.     if (aStyle) linkStyle= *aStyle; 
  1561.     linkStyle.color= gLinkcolor;
  1562.     linkStyle.last = false;
  1563.     linkStyle.linkid= golistItem + 1; 
  1564.     if (theGo) {
  1565.         if (theGo->fIsMap) {
  1566.             linkStyle.ismap= true;
  1567.             fStore->fMapLink= linkStyle.linkid;
  1568.             }
  1569.         }
  1570.     fRichView->InsertStyle( atparag, atchar, atlen, &linkStyle);
  1571.     linkStyle.ownpict= false;
  1572. }
  1573.  
  1574. void DGoLinkedTextDoc::InsertLink( short golistItem, DGopher* theGo, 
  1575.                     Nlm_RecT arect, short atparag, short atchar)
  1576. {    
  1577.     DRichStyle* aStyle= fRichView->GetStyleAtChar( atparag, atchar);
  1578.     if (aStyle && aStyle->ispict && aStyle->fPict) {
  1579.              //!! arect must be relative to pict top,left !!
  1580.         if (theGo) {
  1581.             if (theGo->fIsMap) {
  1582.                 aStyle->ismap= true;
  1583.                 // fStore->fMapLink= golistItem+1;
  1584.                 }
  1585.             }
  1586.         aStyle->fPict->AddLink( DPictStyle::kPictNetLink, golistItem+1, arect);
  1587.         }
  1588. }
  1589.  
  1590. void DGoLinkedTextDoc::InsertLink( DGopher* theGo, short atparag, short atchar, short atlen)
  1591. {
  1592.     if (theGo) {
  1593.         short igo= fStore->fGolist->GetIdentityItemNo( (DObject*) theGo);
  1594.         if (igo == kEmptyIndex) {
  1595.             fStore->fGolist->InsertLast( theGo);
  1596.             igo= fStore->fGolist->GetSize()-1;
  1597.             }
  1598.       InsertLink( igo, theGo, atparag, atchar, atlen);
  1599.       }
  1600. }
  1601.  
  1602. void DGoLinkedTextDoc::InsertLink( DGopher* theGo, Nlm_RecT arect, short atparag, short atchar)
  1603. {
  1604.     if (theGo) {
  1605.         short igo= fStore->fGolist->GetIdentityItemNo( (DObject*) theGo);
  1606.         if (igo == kEmptyIndex) {
  1607.             fStore->fGolist->InsertLast( theGo);
  1608.             igo= fStore->fGolist->GetSize()-1;
  1609.             }
  1610.       InsertLink( igo, theGo, arect, atparag, atchar);
  1611.       }
  1612. }
  1613.  
  1614.  
  1615. void DGoLinkedTextDoc::LinkToSelection( DGopher* aGopher)
  1616. {
  1617.     short              selparag, selchar, selendparag, selendchar;
  1618.     Boolean         inpict, isSelected;
  1619.     Nlm_RecT        selrect;
  1620.     DRichStyle    selstyle;
  1621.     
  1622.     isSelected= fRichView->GetSelection( inpict, selparag, selchar, selendparag, selendchar, 
  1623.                                                     selrect, &selstyle);
  1624.     if (isSelected && aGopher) {
  1625.         aGopher= (DGopher*) aGopher->Clone(); 
  1626.         // must add +MENULINE or +MENURECT info to aGopher !!
  1627.         if (!aGopher->fDocLink) aGopher->fDocLink= new DocLink();
  1628.         if (inpict) {
  1629.             aGopher->fDocLink->SetLineRect( selrect, selparag, selchar);
  1630.             this->InsertLink( aGopher, selrect, selparag, selchar);
  1631.             }
  1632.         else {
  1633.             aGopher->fDocLink->SetLine( selparag, selchar, selendparag, selendchar);
  1634.             this->InsertLink( aGopher, selparag, selchar, selendchar-selchar);
  1635.             }
  1636.         fRichView->Invalidate(); // !? show new link
  1637.         Dirty();
  1638.         }
  1639.     selstyle.ownpict= false;
  1640. }
  1641.  
  1642.  
  1643. void DGoLinkedTextDoc::MarkURLs()
  1644. {
  1645.     if (fRichView && fStore->fGolist) {
  1646.         Boolean found;
  1647.         short        atparag, atchar, atlen, startparag = 0, startchar = 0;
  1648.         do {
  1649.             found= fRichView->FindURL( atparag, atchar, atlen, startparag, startchar);
  1650.             if (found) {
  1651.                 DGopher* go;
  1652.                 
  1653.                 char* itemtxt= fRichView->GetText(atparag, -1);
  1654.                 if (itemtxt) {
  1655.                   go= DGopherList::GopherFromURL( itemtxt+atchar, atlen, fStore->fGolist); 
  1656.                     InsertLink( go, atparag, atchar, atlen);
  1657.                     }
  1658.  
  1659.                 startchar= atchar+atlen+1; 
  1660.                 startparag= atparag;
  1661.                 }
  1662.         } while (found);
  1663.         }    
  1664. }
  1665.  
  1666.  
  1667. void DGoLinkedTextDoc::AddGolinksToDoc()
  1668. {
  1669.     if (gAutoloadInlines) this->SetupInlineParts();
  1670.     if (fStore->fDocFormat == DHTMLHandler::kHTMLformat) return;
  1671.  
  1672.     this->MarkURLs();
  1673.     
  1674.     if (fRichView && fStore->fGolist) {
  1675.         short igo, ngo= fStore->fGolist->GetSize();
  1676.         for (igo= 0; igo<ngo; igo++) {
  1677.             Boolean found;
  1678.             short        atparag, atchar, atlen, startparag = 0, startchar = 0;
  1679.             DGopher* go= fStore->fGolist->GopherAt(igo);
  1680.  
  1681.             if (go->fIsMap) {
  1682.                 fStore->fMapLink= igo+1;
  1683.                 }
  1684.                 
  1685.             if (go->HasDocLink()) 
  1686.                 switch (go->fDocLink->Kind()) {
  1687.                                 
  1688.                 case DocLink::kNoLink:
  1689.                     break;
  1690.                     
  1691.                 case DocLink::kLine: {
  1692.                     short endparag, endchar;
  1693.                     go->fDocLink->GetLine( atparag, atchar, endparag, endchar);
  1694.                     //InsertLink( igo, atparag, atchar, endparag, endchar);
  1695.                     InsertLink( igo, go, atparag, atchar, endchar-atchar); // need new Ins type
  1696.                     }
  1697.                     break;
  1698.  
  1699.                 case DocLink::kLineRect: {
  1700.                     Nlm_RecT rect;
  1701.                     go->fDocLink->GetLineRect( rect, atparag, atchar);
  1702.                     InsertLink( igo, go, rect, atparag, atchar);
  1703.                     }
  1704.                     break;
  1705.  
  1706.                 case DocLink::kRect: {
  1707.                     Nlm_RecT rect;
  1708.                     go->fDocLink->GetRect( rect);
  1709.                     InsertLink( igo, go, rect, 0, 0); // assume this is PICT w/ only 1 char !?
  1710.                     }
  1711.                     break;
  1712.                     
  1713.                 case DocLink::kString: {
  1714.                     short skipval = 0;
  1715.                     char* finds= go->fDocLink->GetString( skipval);
  1716.                     Boolean haveskipval= skipval>0;
  1717.                     atlen= MIN( 10240, StrLen(finds));
  1718.                     do {
  1719.                         found= fRichView->Find( finds, atparag, atchar, startparag, startchar);
  1720.                         if (skipval) skipval--;
  1721.                         if (found && !skipval) {
  1722.                             InsertLink( igo, go, atparag, atchar, atlen);
  1723.                             startchar= atchar+atlen+1; 
  1724.                             startparag= atparag;
  1725.                             if (haveskipval) found= false; // do no more
  1726.                             }
  1727.                         } while (found);
  1728.                     }
  1729.                 break;
  1730.                 
  1731.                 }
  1732.             }
  1733.         }
  1734. }
  1735.  
  1736.  
  1737.  
  1738. void DGoLinkedTextDoc::Open(DFile* docFile, DFile* goFile)
  1739. {
  1740.     if ( ReadFrom( docFile, goFile) ) 
  1741.         this->Open();
  1742.     else 
  1743.         this->Close(); //this->suicide();
  1744. }
  1745.  
  1746.  
  1747. void DGoLinkedTextDoc::Open()
  1748. {
  1749.     DGopherTextDoc::Open();
  1750.  
  1751. #if 0 
  1752.     this->NextSubviewBelowLeft();
  1753.     DPrompt* pr= new DPrompt( 0, this, "Related topics:", 0, 0, Nlm_programFont);             
  1754.     pr->SetResize( DView::fixed, DView::moveinsuper);
  1755.     this->NextSubviewToRight();
  1756.     fMenuList= new DPopupList( cMenuPopup, this);
  1757.     fMenuList->SetResize( DView::fixed, DView::moveinsuper);
  1758.  
  1759.     if (fGolist) {
  1760.         short i, n= fGolist->GetSize();
  1761.         for (i= 0; i<n; i++) {
  1762.             DGopher* go= fGolist->GopherAt(i);
  1763.             fMenuList->AddItem((char*)go->GetName()); //<< need to MenuCleanName !! ShortName());  
  1764.             }
  1765.         }
  1766. #endif
  1767. }
  1768.  
  1769.  
  1770.  
  1771.  
  1772.  
  1773.  
  1774. //class DGopherInfoDoc : public DGopherTextDoc
  1775.  
  1776. void DGopherInfoDoc::ProcessTask(DTask* theTask) 
  1777. {
  1778.     if (theTask->fNumber == cInfo) {
  1779.  
  1780.         if (fStore->fStufGo && fStore->fStufGo->ThreadProgress() != DGopher::kThreadDoneReading)  
  1781.                 fStore->fStufGo->ShowProgress();
  1782.                 
  1783.         if (!fStore->fStufGo || fStore->fStufGo->ThreadProgress() == DGopher::kThreadDoneReading) {
  1784.             theTask->SetRepeat(false); // done w/ gopher fetch, dequeue this task
  1785.             this->ShowMessage("done reading");
  1786.             if (fStore->fStufGo && fStore->fStufGo->fInfoSize) {
  1787.                 fRichView->Append( fStore->fStufGo->fInfo, NULL, NULL, 0, gTextFont);
  1788.                 fRichView->Invalidate();
  1789.                 fStore->fStufGo->DeleteInfo(); 
  1790.                 fStore->fStufGo->fTransferType= fSavedType;
  1791.                 }
  1792.             }
  1793.         }
  1794.     else {
  1795.         DWindow::ProcessTask(theTask);
  1796.         }
  1797. }
  1798.  
  1799.  
  1800. void DGopherInfoDoc::Open()
  1801. {
  1802.     fSavedType= fStore->fParentGo->fTransferType;
  1803.     fStore->fParentGo->fTransferType= kTransferText;
  1804.     fStore->fParentGo->InfoTask();   
  1805.     if (fStore->fParentGo->fThreadState == DGopher::kThreadDoneReading) { 
  1806.         this->suicide(); //delete this; 
  1807.         return; 
  1808.         }
  1809.     fStore->fStufGo= fStore->fParentGo;
  1810.     DTask* aTask= newTask(cInfo, kGoTextdoc);
  1811.     aTask->SetRepeat(true);
  1812.     this->PostTask( aTask);  
  1813.  
  1814.     //// view
  1815.     
  1816.     char title[512];
  1817.     sprintf(title,"Info for %s",(char*)fStore->GetTitle());
  1818.     this->SetTitle(title);
  1819.             // this is for Window part of doc
  1820.     Nlm_ResizeWindow( (Nlm_GraphiC)fWindow, kWinDragHeight, kWinScrollWidth,
  1821.                          kWinMinWidth, kWinExtraHeight+16);
  1822.  
  1823.     fSaveHandler= this; // replace fRichView's handler w/ us
  1824.     this->ShowMessage("Reading...");
  1825.     gGopherTextDoc= this; // track front gopher doc/window
  1826.     DWindow::Open();
  1827. }
  1828.  
  1829.  
  1830.  
  1831. //class    DGopherFileDoc : public DWindow
  1832.  
  1833.  
  1834. DGopherFileDoc::DGopherFileDoc(long id, DGopher* itsGopher) :
  1835.         DWindow( id, gApplication, fixed),
  1836.         fParentGo(itsGopher), 
  1837.         fFile(NULL), fLaunch(NULL), fMapper(NULL),
  1838.         fBytesAvail(NULL), fBytesGot(NULL),
  1839.         fTimeSpent(NULL), fBytesPerSec(NULL),
  1840.         fFirststuff(1)
  1841. { 
  1842.     // FailNIL(fParentGo);
  1843.     fParentGo->newOwner();
  1844. }
  1845.         
  1846. DGopherFileDoc::~DGopherFileDoc()
  1847. {
  1848. #if 0
  1849.         /// nnoooooooo ... dview::deletesubviews does this
  1850.     if (fBytesAvail) delete fBytesAvail;
  1851.     if (fBytesGot) delete fBytesGot;
  1852.     if (fTimeSpent) delete fTimeSpent;
  1853.     if (fBytesPerSec) delete fBytesPerSec;
  1854. #endif
  1855.     if (fFile) delete fFile;
  1856.     delete fParentGo; //fParentGo->suicide();
  1857. }
  1858.     
  1859. Boolean DGopherFileDoc::suicide(void) 
  1860. { 
  1861.     if (GetOwnerCount() <= 1) { 
  1862.         delete this; 
  1863.         return true; 
  1864.         }
  1865.     else 
  1866.         return DObject::suicide();
  1867. }
  1868.  
  1869. Boolean DGopherFileDoc::suicide(short ownercount)
  1870. {
  1871.     if (ownercount < 1) {
  1872.         delete this; 
  1873.         return true; 
  1874.         }
  1875.     else 
  1876.         return DObject::suicide(ownercount);
  1877. }
  1878.  
  1879.  
  1880. Boolean DGopherFileDoc::IsMyTask(DTask* theTask) 
  1881. {
  1882.     if (theTask->fKind == kGoFiledoc) {
  1883.         ProcessTask( theTask);
  1884.         return true;
  1885.         }
  1886.     else 
  1887.         return DWindow::IsMyTask(theTask);
  1888. }
  1889.  
  1890. Boolean DGopherFileDoc::IsMyAction(DTaskMaster* action) 
  1891. {
  1892.     switch (action->Id()) {
  1893.     
  1894.         case kLaunchBut:
  1895.             {
  1896.             // launch file
  1897.             char* name= (char*) fFile->GetName();
  1898. #ifdef WIN_MAC
  1899. #if 1
  1900.             DExternalHandler* child= new DExternalHandler( name);
  1901.             if (!child->Launch()) 
  1902. #else
  1903.             if (!Dgg_LaunchFile( name))
  1904. #endif
  1905.           Nlm_Message(MSG_OK, "Application launch failed");
  1906. #else
  1907.             char  buf[1024];
  1908.             char* commandline= (char*)fMapper->GetHandlerName(); // may well include $file variable
  1909.             char* cp= StrStr(commandline, "$file"); // may look for other vars later, like $url, ...
  1910.             if (cp) {
  1911.                 long len= cp - commandline;
  1912.                 StrNCpy(buf, commandline, len);
  1913.                 buf[len]= 0;
  1914.                 StrNCat(buf, name, 512);
  1915.                 StrNCat(buf, cp+5, 512);
  1916.                 }
  1917.             else {
  1918.                 StrNCpy(buf, commandline, 512);
  1919.                 StrNCat(buf, " ",512);
  1920.                 StrNCat(buf,name,512);
  1921.                 }                
  1922. #if 1
  1923.             DExternalHandler* child= new DExternalHandler( buf);
  1924.             if (!child->Launch()) 
  1925. #else
  1926.             if (!Dgg_LaunchFile( buf))
  1927. #endif
  1928.            Nlm_Message(MSG_OK, "Application launch failed");
  1929. #endif
  1930.             }
  1931.             return true;
  1932.             
  1933.         default: 
  1934.             return DWindow::IsMyAction(action);        
  1935.         }
  1936. }
  1937.             
  1938.  
  1939. void DGopherFileDoc::ProcessTask(DTask* theTask) 
  1940. {
  1941.     if (theTask->fNumber == cSave) {
  1942.         char snum[128];
  1943.         Boolean alldone =  (fParentGo->ThreadProgress() == DGopher::kThreadDoneReading);
  1944.  
  1945.         if (fParentGo->fInfoSize) {
  1946.             char * cbeg = fParentGo->fInfo;
  1947.             ulong clen = fParentGo->fInfoSize;
  1948.             short err= fFile->WriteData( cbeg, clen);
  1949.             fParentGo->DeleteInfo(); 
  1950.             //fParentGo->fInfo= (char*)MemGet(1, true); // NOW part of DGopher::DeleteInfo()
  1951.             
  1952.             // also, update progress stats on display
  1953.             Dgg_LongToStr(fParentGo->fBytesReceived, snum, 0, 128);
  1954.             fBytesGot->SetTitle( snum);
  1955.             Dgg_LongToStr(fParentGo->fConnectTime, snum, 0, 128);
  1956.             fTimeSpent->SetTitle( snum);
  1957.  
  1958.             long csec = fParentGo->fConnectTime; // time / 60;
  1959.             if (csec > 0) {
  1960.                 csec= fParentGo->fBytesReceived / csec;
  1961.                 Dgg_LongToStr( csec, snum, 0, 128);
  1962.                 fBytesPerSec->SetTitle( snum);
  1963.                 }
  1964.  
  1965.             if (fFirststuff>0) {
  1966.                 long bytesavail;
  1967.                 if (fParentGo->fBytesExpected > 0) bytesavail= fParentGo->fBytesExpected; 
  1968.                 else bytesavail= fParentGo->fSizeLong;
  1969.                 Dgg_LongToStr(bytesavail, snum, 0, 128);
  1970.                 fBytesAvail->SetTitle( snum);
  1971.                 fFirststuff= 0;
  1972.                 }
  1973.             }
  1974.         
  1975.         if (alldone) {
  1976.             char sdone[80];
  1977.             StrCpy(sdone, "Done ");
  1978.             Dgg_LongToStr(fParentGo->fConnectTime, snum, 0, 20);
  1979.             StrCat(sdone, snum);
  1980.             fTimeSpent->SetTitle( sdone);
  1981.             if (fLaunch) {
  1982.                 fLaunch->Enable();
  1983.                 //fLaunch->Invalidate(); //?? do we need this to get it redrawn?
  1984.                 }
  1985.                 
  1986.             theTask->SetRepeat(false); // done w/ gopher fetch, dequeue this task
  1987.             fFile->CloseFile();
  1988.             }
  1989.         }
  1990.         
  1991.     else {
  1992.         DWindow::ProcessTask(theTask);
  1993.         }
  1994. }
  1995.  
  1996.  
  1997. void DGopherFileDoc::Open()
  1998. {
  1999.     char namebuf[256], *name;
  2000.     long  macType, macSire;
  2001.     char *suffix, macTypeStr[6], macSireStr[6];
  2002.     
  2003.     StrCpy(namebuf, (char*) fParentGo->ShortName());
  2004.     name= namebuf;
  2005.     this->SetTitle(name);
  2006.  
  2007.     // TESTING....
  2008.     //Nlm_ResizeWindow( (Nlm_GraphiC)fWindow, kWinDragHeight, kWinScrollWidth,
  2009.     //                     kWinMinWidth, kWinExtraHeight);
  2010.     
  2011.     // ?? is this info already set in fParentGo ?? ->fLaunch, ->fMacType, ->fMacSire
  2012.     // YES -- call to ItemForm before this doc is created sets it in fParentGo !
  2013.     fMapper= gGopherMap->GetPreferedFiletype(fParentGo, macType, macSire, suffix);
  2014.     if (fMapper) {
  2015. #ifdef WIN_MAC
  2016.         StrCpy(macTypeStr, Idtype2Str(macType));
  2017.         StrCpy(macSireStr, Idtype2Str(macSire));
  2018. #else
  2019.         gFileManager->ReplaceSuffix( namebuf, 255, suffix);
  2020. #endif
  2021.         MemFree(suffix);
  2022.         }
  2023.     
  2024.     name= (char*)gFileManager->GetOutputFileName( namebuf);
  2025.     if (!name) {
  2026.         this->suicide(); //delete this;
  2027.         return;
  2028.         }
  2029.     
  2030.     DFile* itsFile= new DFile( name, "wb", macTypeStr, macSireStr); //!! NEED "b" or stupid ansi/NLM converts newlines !
  2031.     if (!itsFile) { this->suicide(); return; } //delete this // ?? is this a reasonable abort?...
  2032.     fFile= itsFile;
  2033.     fFile->OpenFile();
  2034.     
  2035.     // add (open)/cancel button
  2036.     // static text w/ file name, total size, & size transferred
  2037.     // progress indicator ??
  2038.  
  2039.     DView *super = this;
  2040.     DPrompt *pr, *prDate = NULL;
  2041.     DCluster* clus;
  2042.     
  2043.     pr= new DPrompt( 0, super, "File:", 0, 0, Nlm_programFont);             
  2044.     super->NextSubviewToRight();
  2045.     pr= new DPrompt( 0, super, (char*)gFileManager->FilenameFromPath( name), 0, 0, Nlm_programFont);             
  2046.     super->NextSubviewBelowLeft();
  2047.  
  2048.             // left side
  2049.     clus= new DCluster(0, this, 0, 0, true);
  2050.     super = clus;
  2051.     if (fParentGo->fDate) {
  2052.         pr= new DPrompt( 0, super, "File Date:", 0, 0, Nlm_programFont);             
  2053.         super->NextSubviewBelowLeft();
  2054.         }
  2055.     pr= new DPrompt( 0, super, "Total bytes:", 0, 0, Nlm_programFont);             
  2056.     super->NextSubviewBelowLeft();
  2057.     pr= new DPrompt( 0, super, "Received:", 0, 0, Nlm_programFont);             
  2058.     super->NextSubviewBelowLeft();
  2059.     pr= new DPrompt( 0, super, "Time:", 0, 0, Nlm_programFont);             
  2060.     super->NextSubviewBelowLeft();
  2061.     pr= new DPrompt( 0, super, "Bytes/sec:", 0, 0, Nlm_programFont);             
  2062.     super->NextSubviewBelowLeft();
  2063.  
  2064.             // right side
  2065.     char *kFillnum = "     000000";
  2066.     this->NextSubviewToRight();
  2067.     clus= new DCluster(0, this, 0, 0, true);
  2068.     super = clus;
  2069.     if (fParentGo->fDate) {
  2070.         prDate= new DPrompt( 0, super, kFillnum, 0, 0, Nlm_programFont, justright);             
  2071.         prDate->SetTitle( fParentGo->fDate);
  2072.         super->NextSubviewBelowLeft();
  2073.         }    
  2074.     fBytesAvail=     new DPrompt( 0, super, kFillnum, 0, 0, Nlm_programFont, justright);             
  2075.     super->NextSubviewBelowLeft();
  2076.     fBytesGot=         new DPrompt( 0, super, kFillnum, 0, 0, Nlm_programFont, justright);             
  2077.     super->NextSubviewBelowLeft();    
  2078.     fTimeSpent=     new DPrompt( 0, super, kFillnum, 0, 0, Nlm_programFont, justright);             
  2079.     super->NextSubviewBelowLeft();    
  2080.     fBytesPerSec= new DPrompt( 0, super, kFillnum, 0, 0, Nlm_programFont, justright);             
  2081.     super->NextSubviewBelowLeft();
  2082.     
  2083.     if (fMapper && (fMapper->fHandlerType == 2 || fMapper->fHandlerName)) {   // 2 == kExternalHandler !! fix this??
  2084.         fLaunch= new DButton( kLaunchBut, super, "Launch");
  2085.         fLaunch->Disable();
  2086.         }
  2087.     
  2088.     //fParentGo->fTransferType= kTransferBinary; // ?? is this messed up ??
  2089.     if (fParentGo->fThreadState == DGopher::kThreadNotStarted) 
  2090.         fParentGo->ReadTask();   
  2091.     if (fParentGo->fThreadState == DGopher::kThreadDoneReading) { 
  2092.         fParentGo->fThreadState= DGopher::kThreadNotStarted; // ! need to reset this somewhere for used gophers
  2093.         this->suicide(); //delete this; 
  2094.         return; 
  2095.         }
  2096.     //fParentGo= fParentGo;
  2097.     DTask* aSaveTask= newTask(cSave, kGoFiledoc);
  2098.     aSaveTask->SetRepeat(true);
  2099.     this->PostTask( aSaveTask); // ?? bug in gTaskCentral, getting only ReadTask in queue...
  2100.  
  2101.     DWindow::Open();
  2102. }
  2103.  
  2104.  
  2105.  
  2106.  
  2107.  
  2108.  
  2109.  
  2110.  
  2111.  
  2112.  
  2113.