home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 4 / Apprentice-Release4.iso / Source Code / Libraries / DCLAP 4j / Drtf / DRichViewNu.cpp < prev    next >
Encoding:
Text File  |  1995-12-17  |  102.2 KB  |  3,947 lines  |  [TEXT/R*ch]
  1. // DRichView.cpp
  2. // d.g.gilbert
  3.  
  4.  
  5. #include "Dvibrant.h"
  6. #include "DWindow.h"
  7. #include "DPanel.h"
  8. #include "DControl.h"
  9. #include "DFile.h"
  10. #include "DFindDlog.h"
  11. #include "DList.h"
  12. #include "DUtil.h"
  13. #include "DDialogText.h"
  14. #include "DViewCentral.h"
  15.  
  16. #include "DDrawPICT.h"
  17.  
  18. #include "DRichStyle.h"
  19. #include "DRichViewNu.h"
  20. #include "DRTFHandler.h"
  21. #include "DPICTHandler.h"
  22. #include "DHTMLHandler.h"
  23. #include "DGIFHandler.h"
  24.  
  25.  
  26. #include "DIconLib.h"
  27. #include "DIcons.h"
  28.  
  29.  
  30. static DDrawPict* gDrawPict = NULL; 
  31.  
  32. static Boolean gNotInitted = true;
  33.  
  34. #ifdef DBUG
  35. #define Debug(x)  fprintf(stderr,x)
  36. #define Debug1(x,y)  fprintf(stderr,x,y);
  37. #else
  38. #define Debug(x) 
  39. #define Debug1(x,y)
  40. #endif
  41.  
  42. enum {
  43.     chPictTag = 26,
  44.     MAXFONTS  = 32
  45.     };
  46.  
  47. static struct fontheights {
  48.   Nlm_FonT  font;
  49.   short          height;
  50.     } gFontHeights[MAXFONTS];
  51.  
  52.  
  53. //short DRichView::GetFontHeight(Nlm_FonT font)
  54. static short GetFontHeight(Nlm_FonT font)
  55. {
  56.             // Returns the pixel height of a font, caching for quicker access
  57.   short  height, i;
  58.   height = 0;
  59.   i = 0;
  60.   while (i < MAXFONTS && gFontHeights[i].font != font
  61.          && gFontHeights[i].font != NULL)
  62.             i++;
  63.   if (gFontHeights[i].font == font) 
  64.     return gFontHeights[i].height;
  65.     else {
  66.     Nlm_SelectFont(font);
  67.     height = Nlm_LineHeight();
  68.     if (i < MAXFONTS) {
  69.       gFontHeights[i].font = font;
  70.       gFontHeights[i].height = height;
  71.         }
  72.        return height;
  73.         }
  74. }
  75.  
  76.  
  77.  
  78. // struct DRichStyle
  79.  
  80. DRichStyle::DRichStyle()
  81. {
  82.   //SetClass("DRichStyle",sizeof(DRichStyle));
  83.     ispict= false;
  84.     ismap= false;
  85.     ownpict= false;
  86.     fPict= NULL; 
  87.  
  88.     boxed= false;
  89.     hidden= false;
  90.     last= false; //??
  91.     color= 0; // black ??
  92.     nextofs= 0;
  93.     pixheight= pixwidth= pixleft= 0;
  94.     linkid= 0;
  95.     font= NULL;
  96.     superSub= 0;
  97.     underline= kNoUnderline;
  98.     bold= false;
  99.     italic= false;
  100.     outline= false;
  101.     shadow= false;
  102.     strikeout= false;
  103.     smallcaps= false;
  104.     allcaps= false;
  105. }
  106.  
  107. DRichStyle::~DRichStyle()
  108. {
  109.     // this was killing things due to large # of static variables of this type
  110.     // commonly used as save temps -- was deleting same data more than once !!
  111. #if 1
  112.     if (ownpict && fPict) {
  113.         fPict->suicide(); 
  114.         // if (ownpict) ownpict= true; //  debug trap 
  115.         }
  116. #else
  117.     //if (ownpict) MemFree(picdata);  
  118. #endif
  119. }
  120.  
  121. Boolean DRichStyle::suicide(void) 
  122. { 
  123.     if (GetOwnerCount() <= 1) { 
  124.         delete this; 
  125.         return true; 
  126.         }
  127.     else 
  128.         return DObject::suicide();
  129. }
  130.  
  131. Boolean DRichStyle::suicide(short ownercount)
  132. {
  133.     if (ownercount < 1) {
  134.         delete this; 
  135.         return true; 
  136.         }
  137.     else 
  138.         return DObject::suicide(ownercount);
  139. }
  140.  
  141. #if 0
  142. // this bombs......
  143. DRichStyle& DRichStyle::operator=( DRichStyle& ast)
  144. {
  145.     if (this != &ast) {
  146.         //*this ::= ast; 
  147.         //this->DObject::operator=(ast);
  148.       MemCpy( this, &ast, sizeof(DRichStyle)); //<<! subclass bad !!
  149.         this->ownpict= false;
  150.         }
  151.     return *this;
  152. }
  153. #endif
  154.  
  155. #if 0
  156. DObject* DRichStyle::Clone()
  157. {
  158.     DRichStyle* result = (DRichStyle*) DObject::Clone();
  159.     if (picdata) {
  160.          result->picdata= (char*) MemDup( picdata,  picsize);
  161.          result->ownpict= true;
  162.          }
  163.     return result;
  164. }
  165. #endif
  166.  
  167. Boolean DRichStyle::IsNotEqual(DRichStyle* other)
  168. {
  169.     if ( 0 == MemCmp( this, other, sizeof(DRichStyle)) )
  170.         return false;
  171.     else if (ispict && other->ispict) {
  172.         // ?? need some better way to test if two picts are the same ??
  173.         return ( linkid != other->linkid
  174.                     || ismap != other->ismap
  175.                     || (fPict && fPict->IsNotEqual(other->fPict))
  176.                     );
  177.         }
  178.     else
  179.       return (  linkid != other->linkid 
  180.                     || ispict != other->ispict
  181.                     || ismap != other->ismap
  182.                     || color != other->color 
  183.                     || superSub != other->superSub 
  184.                     || underline != other->underline
  185.                     || bold != other->bold
  186.                     || italic != other->italic
  187.                     || hidden != other->hidden
  188.                     || outline != other->outline
  189.                     || shadow != other->shadow
  190.                     || strikeout != other->strikeout
  191.                     || smallcaps != other->smallcaps
  192.                     || allcaps != other->allcaps
  193.                     || boxed != other->boxed
  194.                     );
  195. }
  196.  
  197.  
  198.  
  199.  
  200.  
  201. // class DPictStyle
  202.  
  203. DPictStyle::DPictStyle()
  204. {
  205.     fKind= kPictOther;  // kPictMac
  206.     fSize= 0;
  207.     fData= NULL;
  208.     fLinks = NULL;
  209.     fNumLinks= 0;
  210. }
  211.  
  212. DPictStyle::DPictStyle( short kind, void* data, ulong dsize, Boolean owndata)
  213. {
  214.     fKind= kind;
  215.     fSize= 0;
  216.     fData= NULL;
  217.     fLinks = NULL;
  218.     fNumLinks= 0;
  219.     SetData( kind, data, dsize, owndata);
  220. }
  221.  
  222. DPictStyle::~DPictStyle()
  223. {
  224.     MemFree( fData);
  225.     MemFree( fLinks);
  226. }
  227.  
  228. Boolean DPictStyle::suicide(void) 
  229. { 
  230.     if (GetOwnerCount() <= 1) { 
  231.         delete this; 
  232.         return true; 
  233.         }
  234.     else 
  235.         return DObject::suicide();
  236. }
  237.  
  238. Boolean DPictStyle::suicide(short ownercount)
  239. {
  240.     if (ownercount < 1) {
  241.         delete this; 
  242.         return true; 
  243.         }
  244.     else 
  245.         return DObject::suicide(ownercount);
  246. }
  247.  
  248. Boolean DPictStyle::IsNotEqual(DPictStyle* other)
  249. {
  250.     if ( !other 
  251.         || fSize != other->fSize 
  252.         || fKind != other->fKind   
  253.         || (fData == NULL) != (other->fData == NULL)
  254.         )  return true;
  255.     if (fData && other->fData)  
  256.         return (0 != MemCmp( fData, other->fData, fSize));
  257.     else
  258.         return false; 
  259. }
  260.  
  261. void DPictStyle::SetData( short kind, void* data, ulong dsize, Boolean owndata)
  262. {
  263.     if (fData) MemFree( fData); 
  264.     fKind= kind;
  265.     if (owndata) fData= (char*) data;   // this was bad ?!?
  266.     else fData= (char*) MemDup(data, dsize); 
  267.     fSize= dsize;
  268. }
  269.  
  270.  
  271. short DPictStyle::GetLink( Nlm_PoinT atp, short& kind)
  272. {
  273.     for (short i= 0; i<fNumLinks; i++) {
  274.         if (Nlm_PtInRect( atp, &fLinks[i].fLoc)) {
  275.             kind= fLinks[i].fKind;
  276.             return fLinks[i].fLinkid;
  277.             }
  278.         }
  279.     kind= 0;
  280.     return 0;
  281. }
  282.  
  283. short DPictStyle::GetLink( short index, short& kind, Nlm_RecT& loc)
  284. {
  285.     if (index>=0 && index<fNumLinks) {
  286.         kind= fLinks[index].fKind;
  287.         loc= fLinks[index].fLoc;
  288.         return fLinks[index].fLinkid;
  289.         }
  290.     else {
  291.         kind= 0;
  292.         return 0;
  293.         }
  294. }
  295.  
  296. void DPictStyle::AddLink( short kind, short linkid, Nlm_RecT loc)
  297. {
  298.     PictLinkIndex lnk;
  299.     lnk.fLinkid= linkid;
  300.     lnk.fLoc= loc;
  301.     lnk.fKind= kind;
  302.     fNumLinks++;
  303.     if ( fLinks )
  304.         fLinks= (PictLinkIndex*) MemMore( fLinks, fNumLinks * sizeof(PictLinkIndex));
  305.     else
  306.         fLinks= (PictLinkIndex*) MemNew( fNumLinks * sizeof(PictLinkIndex));
  307.     fLinks[fNumLinks-1]= lnk;
  308. }
  309.  
  310. Boolean DPictStyle::HasNetPict()
  311. {    
  312.     return (fLinks && 
  313.         (fKind == DPictStyle::kPictNetLink 
  314.     || fKind == DPictStyle::kPictNetPic));
  315. }
  316.  
  317. Boolean DPictStyle::CanDraw()
  318. {    
  319.     return (fKind == kPictMac); // add more later...
  320. }
  321.  
  322. void DPictStyle::Draw( Nlm_RecT area)
  323. {
  324.     if (fKind == kPictMac) gDrawPict->Draw( &area, fData, fSize, fKind);
  325.     else if (fKind == kPictNetLink) gNetpicIcon.Draw( area); 
  326.     else gPictureIcon.Draw( area);
  327. }
  328.  
  329.  
  330.  
  331.  
  332.  
  333.  
  334.  
  335. // struct DParagraph
  336.  
  337. void DParagraph::Initialize()
  338. {
  339.   //SetClass("DParagraph", sizeof(DParagraph));  
  340.     just = 'l';
  341.      tablead = ' ';                  
  342.     deftabstop = 36;
  343.   numstops = 0;
  344.     tabstops = NULL;
  345.     tabkinds = NULL;
  346.     firstInset= leftInset= rightInset= 0;
  347.     spaceBefore= spaceAfter= spaceBetween = 0;
  348.     minLines = minHeight = 0;
  349.     startsAt = numRows = 0;     
  350.     lineHeight = leadHeight = 0; 
  351.   
  352.   fDataPtr = NULL;     
  353.     fText = NULL;             
  354.     fStyleIndex = NULL;
  355.     fNumStyles = 0;
  356.  
  357.     borderstyle    = kNoBorder;
  358.     bordertop  = false;
  359.     borderbottom = false;
  360.     borderleft  = false;
  361.     borderright = false;
  362.     borderbetween = false;
  363.     borderbar = false;
  364.     borderbox = false;
  365.      
  366.     openSpace = FALSE; // was TRUE;
  367.     keepWithNext = FALSE;
  368.     keepTogether = FALSE;
  369.     newPage = FALSE;
  370.     minLines = 0;
  371.     minHeight = 0;
  372.     just = 'l';
  373.     leftInset = 0;
  374.     wrap =  TRUE;
  375.  
  376.     notCached = TRUE;
  377.     neverCached = TRUE;
  378.     fDocOwnsData= false;
  379.     fDocOwnsStyles= true;
  380. }
  381.  
  382.  
  383. DParagraph::~DParagraph()
  384. {
  385. #if 1
  386.     if (fDocOwnsData) MemFree( fDataPtr);
  387.     if (fDocOwnsStyles) MemFree( fStyleIndex);
  388.     MemFree( fText);
  389.     MemFree( tabkinds);
  390.     MemFree( tabstops);
  391. #endif
  392. }
  393.  
  394. Boolean DParagraph::suicide(void) 
  395. { 
  396.     if (GetOwnerCount() <= 1) { 
  397.         delete this; 
  398.         return true; 
  399.         }
  400.     else
  401.         return DObject::suicide();
  402. }
  403.  
  404. Boolean DParagraph::suicide(short ownercount)
  405. {
  406.     if (ownercount < 1) {
  407.         delete this; 
  408.         return true; 
  409.         }
  410.     else 
  411.         return DObject::suicide(ownercount);
  412. }
  413.  
  414. #if 0
  415. DObject* DParagraph::Clone()
  416. {
  417.     DParagraph* result = (DParagraph*) DObject::Clone();
  418.     
  419.     if (fDocOwnsStyles) {
  420.         result->fStyleIndex= (StyleIndex*) MemDup( fStyleIndex, fNumStyles*sizeof(StyleIndex));
  421.         }
  422.     result->fText= (char*) StrDup( fText);
  423.     if (fDocOwnsData) result->fDataPtr= (char*) StrDup( fDataPtr);
  424.     result->tabkinds=  (char*) MemDup( tabkinds, numstops*sizeof(char) );
  425.     result->tabstops=  (short*) MemDup( tabstops, numstops*sizeof(short) );
  426.     return result;
  427. }
  428. #endif
  429.  
  430.  
  431. #if 0
  432. DParagraph& DParagraph::operator=( const DParagraph &val)
  433. {
  434.     this = (DParagraph*) val.Clone();
  435.     return *this; // ??????????
  436. }
  437. #endif
  438.  
  439.  
  440. void DParagraph::Copy(DParagraph* it)
  441. {
  442.     just = it->just;
  443.      tablead = it->tablead;                  
  444.     deftabstop = it->deftabstop;
  445.   numstops = it->numstops;
  446.     tabstops = it->tabstops;
  447.     tabkinds = it->tabkinds;
  448.     firstInset= it->firstInset;
  449.     leftInset= it->leftInset;
  450.     rightInset= it->rightInset;
  451.     spaceBefore= it->spaceBefore;
  452.     spaceAfter= it->spaceAfter;
  453.     spaceBetween =spaceBetween;
  454.     minLines = it->minLines;
  455.     minHeight = it->minHeight;
  456.     startsAt = it->startsAt;
  457.     numRows = it->numRows;     
  458.     lineHeight = it->lineHeight;
  459.     leadHeight = it->leadHeight; 
  460.   
  461.   fDataPtr = it->fDataPtr;     
  462.     fText = it->fText;             
  463.     fStyleIndex = it->fStyleIndex;
  464.     fNumStyles = it->fNumStyles;
  465.  
  466.     borderstyle    = it->borderstyle;
  467.     bordertop  = it->bordertop;
  468.     borderbottom = it->borderbottom;
  469.     borderleft  = it->borderleft;
  470.     borderright = it->borderright;
  471.     borderbetween = it->borderbetween;
  472.     borderbar = it->borderbar;
  473.     borderbox = it->borderbox;
  474.      
  475.     openSpace = it->openSpace;
  476.     keepWithNext = it->keepWithNext;
  477.     keepTogether = it->keepTogether;
  478.     newPage = it->newPage;
  479.     minLines = it->minLines;
  480.     minHeight = it->minHeight;
  481.     wrap = it-> wrap;
  482.  
  483.     notCached = it->notCached;
  484.     neverCached = it->neverCached;
  485.     fDocOwnsData= it->fDocOwnsData;
  486.     fDocOwnsStyles= it->fDocOwnsStyles;
  487. }
  488.  
  489.  
  490.  
  491. DParagraph::DParagraph()
  492. {
  493.     Initialize();
  494. }
  495.  
  496. DParagraph::DParagraph( char* data, Boolean docOwnsData, short lines, DParagraph* parFmt, 
  497.                        StyleIndex* styles, short numstyle, Boolean docOwnsStyles) 
  498. {
  499.     Initialize();
  500.     if (parFmt) {
  501.         //*this= *parFmt;
  502.         this->Copy( parFmt);
  503.     minLines= MAX( parFmt->minLines, (short) 1);
  504.     fText= NULL;
  505.     tabkinds= (char*) MemDup( parFmt->tabkinds, numstops*sizeof(char) );
  506.     tabstops= (short*)MemDup( parFmt->tabstops, numstops*sizeof(short) );
  507.       } 
  508.      fDataPtr= data;
  509.     fDocOwnsData = docOwnsData;
  510.     fDocOwnsStyles = docOwnsStyles;
  511.      fStyleIndex= styles;
  512.      fNumStyles= numstyle;
  513.     numRows = MAX(lines, 1);
  514. }
  515.  
  516.  
  517.  
  518.  
  519.  
  520.  
  521.  
  522. //class DRichView : public DPanel
  523.  
  524.  
  525. extern "C" void richPanelClickProc(Nlm_PaneL item, Nlm_PoinT mouse)
  526. {
  527.     DRichView *obj= (DRichView*) Nlm_GetObject( (Nlm_GraphiC)item);
  528.     if (obj) obj->Click(mouse);
  529. }
  530.  
  531. extern "C" void richPanelDragProc(Nlm_PaneL item, Nlm_PoinT mouse)
  532. {
  533.     DRichView *obj= (DRichView*) Nlm_GetObject( (Nlm_GraphiC)item);
  534.     if (obj) obj->Drag(mouse);
  535. }
  536.  
  537. extern "C" void richPanelHoldProc(Nlm_PaneL item, Nlm_PoinT mouse)
  538. {
  539.     DRichView *obj= (DRichView*) Nlm_GetObject( (Nlm_GraphiC)item);
  540.     if (obj) obj->Hold(mouse);
  541. }
  542.  
  543. extern "C" void richPanelReleaseProc(Nlm_PaneL item, Nlm_PoinT mouse)
  544. {
  545.     DRichView *obj= (DRichView*) Nlm_GetObject( (Nlm_GraphiC)item);
  546.     if (obj) obj->Release(mouse);
  547. }
  548.  
  549. extern "C" void richPanelDrawProc(Nlm_PaneL item)
  550. {
  551.     DRichView *obj= (DRichView*) Nlm_GetObject( (Nlm_GraphiC)item);
  552.     if (obj) obj->Draw();
  553. }
  554.  
  555. extern "C" void richPanelScrollProc(Nlm_BaR sb, Nlm_SlatE slate, short newval, short oldval)
  556. {
  557.     DRichView *obj= (DRichView*) Nlm_GetObject( (Nlm_GraphiC)slate);
  558.     if (obj) obj->ScrollDoc(sb, newval, oldval);
  559.     //if (obj) obj->Scroll(true, obj, newval, oldval);
  560. }
  561.  
  562. extern "C" void richPanelResetProc(Nlm_PaneL item)
  563. {
  564.     DRichView *obj= (DRichView*) Nlm_GetObject( (Nlm_GraphiC)item);
  565.         // damn, this is called by Vibrant cleaner-upper AFTER DRichView::~DRichView() !!
  566.     if (obj) obj->ResetDoc();
  567. }
  568.  
  569.  
  570. //typedef    short (*CompareFunc)( void*, void*);     // compare two list/array Items 
  571.  
  572. short richPanelCompareStyles( void* item1, void* item2)
  573. {
  574. #if 0
  575.     if ( ((DRichStyle*) item1)->IsNotEqual( (DRichStyle*) item2) ) { 
  576.         if (item1 > item2) return 1;
  577.         else return -1;
  578.         }
  579.     else 
  580.         return 0;
  581. #else
  582.     return MemCmp( item1, item2, sizeof(DRichStyle));
  583. #endif
  584. } 
  585.  
  586.  
  587.  
  588. DRichView::DRichView(long id, DView* itsSuperior, short pixwidth, short pixheight):
  589.     DPanel(id, itsSuperior, pixwidth, pixheight, DPanel::subclasscreates)
  590. {
  591.      fNumItems= 0;
  592.     fNumLines= 0;
  593.     fBarmax= 0;
  594.     fDocFormat= 0;
  595.     fTabCount= 1;
  596.   fAutoAdjust= true; 
  597.   fIsVirtual= false; 
  598.   fDodraw= true;
  599.     fStyles= NULL; 
  600.     fParags= NULL; 
  601.     fCurrentStyle= NULL;
  602.     fSelParag= fSelChar= fSelEndParag= fSelEndChar= 0;
  603.     fSelected= fSelInPict= false;
  604.     ZeroCharWidths();
  605.  
  606. #if 0    
  607.     if (!Nlm_EmptyRect( &DRichTextDoc::gRichDocRect)) {
  608.         pixwidth= DRichTextDoc::gRichDocRect.right - DRichTextDoc::gRichDocRect.left;
  609.         pixheight= DRichTextDoc::gRichDocRect.bottom - DRichTextDoc::gRichDocRect.top;
  610.         }
  611. #endif        
  612.     if (pixwidth ==0) pixwidth = Nlm_screenRect.right - Nlm_screenRect.left - 60;
  613.     if (pixheight==0) pixheight= Nlm_screenRect.bottom - Nlm_screenRect.top - 120;
  614.             // these -## adjustments are not very good -- need to know what other
  615.             // views are in the given window and adjust for their size !?
  616.  
  617.     if (!itsSuperior) return; // FAILNil(itsSuperior)
  618.     Nlm_GrouP prnt= (Nlm_GrouP)itsSuperior->GetNlmObject();
  619.     if (!prnt) return; // FAILNil(prnt)
  620.   Nlm_WindoW tempPort = Nlm_SavePort(prnt);
  621.   fPanel= Nlm_AutonomousPanel(prnt, pixwidth, pixheight, richPanelDrawProc,
  622.                                richPanelScrollProc, NULL, 0,
  623.                                NULL/*richPanelResetProc*/, NULL);
  624.   if (!fPanel) return;  //FailNIL(fPanel);
  625.   if (tempPort) Nlm_RestorePort(tempPort);
  626.   
  627.     Nlm_SetPanelClick(fPanel, richPanelClickProc, richPanelDragProc, richPanelHoldProc, 
  628.                                         richPanelReleaseProc);
  629.     this->SetNlmObject(fPanel);
  630.     this->SetAutoAdjust(true); // used after append/insert/replace/delete
  631.     this->SetSlateBorder(true);
  632.  
  633.     fStyles= new DList( ::richPanelCompareStyles ); //, DList::kDeleteObjects); // + DList::kOwnObjects 
  634.     fParags= new DList( ); // NULL, DList::kDeleteObjects);
  635.     //fStyles->fArrayIncrement= 30;
  636.     //fParags->fArrayIncrement= 30;
  637.     
  638.     if (gNotInitted) InitRichView();
  639.     fCurrentStyle= new DRichStyle();
  640.     ClearCurrentStyle();
  641.  
  642.     Nlm_LoadRect( &fDrawr, 0,0,0,0);
  643.     fAtpt.x= fAtpt.y= 0;
  644.             
  645.     DWindow* win= this->GetWindow();
  646.     if (win) {
  647.         win->fPrintHandler= this;
  648.         win->fSaveHandler= this;
  649.         }
  650. }
  651.     
  652. DRichView::~DRichView()
  653. {
  654.     //?? need for SetDocData's DocFreeProc call...
  655.     //if (fStyles) delete fStyles; fStyles= NULL;
  656.     //if (fParags) delete fParags; fParags= NULL;
  657.         // damn, delete fList isn't calling object destructors !!!!
  658.     long i, n;
  659.     if (fStyles) {
  660.         n= fStyles->GetSize();
  661.         for (i=0; i<n; i++) {
  662.             DRichStyle* st= (DRichStyle*) fStyles->At(i);
  663.             if (st) delete st;
  664.             }
  665.         delete fStyles;
  666.         }
  667.     if (fParags) {
  668.         n= fParags->GetSize();
  669.         for (i=0; i<n; i++) {
  670.             DParagraph* pa= (DParagraph*) fParags->At(i);
  671.             if (pa) delete pa;
  672.             }
  673.         delete fParags;
  674.         }
  675.     if (fCurrentStyle) {
  676.         fCurrentStyle->ownpict= false;
  677.         delete fCurrentStyle;
  678.         }
  679. }
  680.  
  681. void  DRichView::DeleteAll() 
  682. {
  683.     short i, n;
  684.     if (fStyles) {
  685.         n= fStyles->GetSize();
  686.         for (i=0; i<n; i++) {
  687.             DRichStyle* st= (DRichStyle*) fStyles->At(i);
  688.             delete st;
  689.             }
  690.         fStyles->DeleteAll();
  691.         //delete fStyles;
  692.         }
  693.     if (fParags) {
  694.         n= fParags->GetSize();
  695.         for (i=0; i<n; i++) {
  696.             DParagraph* pa= (DParagraph*) fParags->At(i);
  697.             delete pa;
  698.             }
  699.         fParags->DeleteAll();
  700.         //delete fParags;
  701.         }
  702.     fNumItems= fNumLines= 0;
  703. }
  704.  
  705.  
  706.  
  707. void DRichView::InitRichView()
  708. {
  709.     gNotInitted= true;
  710.   for (short i = 0; i < MAXFONTS; i++) {
  711.     gFontHeights[i].font = NULL;
  712.     gFontHeights[i].height = 0;
  713.       }
  714.     gDrawPict = new DDrawPict();
  715. }
  716.  
  717.  
  718.  
  719. void DRichView::ViewRect( Nlm_RecT& r)  
  720. { 
  721.     DPanel::ViewRect( r);
  722.     Nlm_InsetRect(&r, 10, 4); 
  723. }
  724.  
  725.  
  726.  
  727.     
  728. void DRichView::SetSlateBorder(Boolean turnon) 
  729. {
  730.      Nlm_SetSlateBorder((Nlm_SlatE)fPanel, turnon);  
  731. }
  732.  
  733. void DRichView::SizeToSuperview( DView* super, Boolean horiz, Boolean vert)
  734. {
  735. #if 0
  736. #ifdef WIN_MOTIF
  737.     DPanel::SizeToSuperview( super, horiz, vert);
  738. #else
  739.     // size only lower and right sides == leave top area...
  740.     Nlm_RecT r, myr;
  741.     super->ViewRect(r);
  742.     GetPosition( myr); // ViewRect(myr); <<!!NO, diff from Get/SetPos
  743.     if (horiz)     myr.right= (r.right - r.left) +1;
  744.     // myr.right -= (Nlm_vScrollBarWidth - 8); // mswin patch !?
  745.     if (vert) myr.bottom =  (r.bottom - r.top)  +1; 
  746.     SetPosition( myr);
  747. #endif
  748. #endif
  749. }
  750.   
  751.  
  752. void DRichView::Resize(DView* superview, Nlm_PoinT sizechange)
  753. {
  754.     DPanel::Resize( superview, sizechange);
  755. }
  756.  
  757.  
  758.  
  759.  
  760.  
  761. DRichStyle* DRichView::GetStyle( short styleid)
  762. {
  763.     return (DRichStyle*) fStyles->At(styleid);
  764. }
  765.  
  766. DRichStyle* DRichView::GetStyleAtIndex(DParagraph* aParag, short styleindex)
  767. {    
  768.     short id= -1;
  769.     if (aParag) {
  770.         id= aParag->fStyleIndex[styleindex].styleid;
  771.         return (DRichStyle*) fStyles->At(id);  // id-1?? NO
  772.         }
  773.   else return NULL;
  774. }
  775.  
  776. DRichStyle* DRichView::GetStyleAtChar( DParagraph* aParag, short atchar)
  777. {
  778.     short id= -1;
  779.     if (aParag) {
  780.         short i;
  781.         for (i= aParag->fNumStyles-1; i>0; i--) { 
  782.             if (atchar >= aParag->fStyleIndex[i].nextofs) 
  783.                 break;
  784.             }
  785.         id= aParag->fStyleIndex[i].styleid; 
  786.         }
  787.     return (DRichStyle*) fStyles->At(id);  // id-1?? NO
  788. }
  789.  
  790. DRichStyle* DRichView::GetStyleAtChar( short atparag, short atchar)
  791. {
  792.     return GetStyleAtChar( (DParagraph*)fParags->At(atparag), atchar);
  793. }
  794.  
  795. short DRichView::FindOrAddStyle( DRichStyle* theStyle)
  796. { 
  797.     short styleid= fStyles->GetEqualItemNo( theStyle);
  798.     if (styleid == kEmptyIndex) {
  799.         DRichStyle* bst= new DRichStyle();
  800.         *bst= *theStyle;   // need a smart assign/copy method !! ?? a FIXED clone() ??
  801.         bst->ownpict= true;
  802.         theStyle->fPict= NULL; //theStyle->picdata= NULL;
  803.         fStyles->InsertLast(bst);
  804.         styleid= fStyles->GetSize() - 1;
  805.         }
  806.     return styleid;
  807. }
  808.  
  809.  
  810.  
  811.  
  812. DParagraph* DRichView::GetParaPtr( short item)
  813. { 
  814.     return (DParagraph*) fParags->At(item); 
  815. }
  816.  
  817.  
  818.  
  819. DParagraph* DRichView::MakeNewParag( void* data, short lines, 
  820.                         DParagraph* parFormat, DRichStyle* styles, short nstyles, Boolean docOwnsData)
  821. {
  822.     short ist, nst=0;
  823.     //if (styles) do nst++; while (!styles[nst-1].last);
  824.     StyleIndex* styleindex= (StyleIndex*) MemNew( nstyles*sizeof(StyleIndex));
  825.     for (ist=0; ist<nstyles; ist++) {
  826.         short id= FindOrAddStyle( &styles[ist]);
  827.         styleindex[ist].styleid= id;
  828.         styleindex[ist].nextofs= styles[ist].nextofs;
  829.         }
  830.     
  831.     return  new DParagraph( (char*)data, docOwnsData, lines, parFormat, styleindex, nstyles);
  832. }
  833.  
  834.  
  835. void     DRichView::AppendParag( DParagraph* aParag)
  836. {    
  837.   if (aParag) {
  838.         aParag->startsAt= fNumLines;
  839.     fNumLines += aParag->numRows;
  840.         fParags->InsertLast(aParag);
  841.     fNumItems++; // == fParags->GetSize();
  842.       }
  843. }
  844.  
  845. void     DRichView::Append( void* data, short lines, DParagraph* parFormat,  
  846.                         DRichStyle* styles, short nstyles, Boolean docOwnsData)
  847. {    
  848.     DParagraph* aParag= MakeNewParag( data, lines, parFormat, styles, nstyles, docOwnsData);
  849.   if (aParag) {
  850.     UpdateItemHeights(aParag);
  851.     AppendParag( aParag);
  852.     if (fAutoAdjust) AdjustScroll();
  853.       }
  854. }
  855.  
  856. void     DRichView::Insert( short item, void* data, short lines, DParagraph* parFormat, 
  857.                         DRichStyle* styles, short nstyles, Boolean docOwnsData)
  858. {
  859.     DParagraph* aParag= MakeNewParag( data, lines, parFormat, styles, nstyles, docOwnsData);
  860.   if (aParag) {
  861.     UpdateItemHeights(aParag);
  862.         DParagraph* pat= (DParagraph*)fParags->At(item);
  863.         if (pat) {
  864.             aParag->startsAt= pat->startsAt;
  865.             fParags->InsertBefore(item, aParag);
  866.         fNumLines = UpdateLineStarts(item);
  867.             fNumItems++; // == fParags->GetSize();
  868.         }
  869.       else {
  870.             AppendParag( aParag);    
  871.           }
  872.     if (fAutoAdjust) AdjustScroll();
  873.       }
  874. }
  875.  
  876. void     DRichView::Replace( short item, void* data, short lines, DParagraph* parFormat,  
  877.                 DRichStyle* styles, short nstyles, Boolean docOwnsData)
  878. {
  879.     DParagraph* aParag= MakeNewParag( data, lines, parFormat, styles, nstyles, docOwnsData);
  880.   if (aParag) {
  881.     UpdateItemHeights(aParag);
  882.         DParagraph* pat= (DParagraph*) fParags->At(item);
  883.         if (pat) {
  884.             aParag->startsAt= pat->startsAt;
  885.             fParags->AtPut(item, aParag);
  886.         fNumLines = UpdateLineStarts(item);
  887.             delete pat; // !? should DList do this on AtPut ?? it doesn't
  888.         }
  889.       else {
  890.             AppendParag( aParag);
  891.           }
  892.     if (fAutoAdjust) AdjustScroll();
  893.       }
  894. }
  895.  
  896.  
  897. void     DRichView::UpdateStyleHeight( DRichStyle* theStyle)
  898. {
  899.   if (theStyle) {
  900.       short theid= fStyles->GetIdentityItemNo( theStyle);
  901.         if (theid == kEmptyIndex) return;
  902.         
  903.       short j, item, nitem= fParags->GetSize();
  904.       for (item= 0; item<nitem; item++) {
  905.             DParagraph* pat= (DParagraph*) fParags->At(item);
  906.             for (j= 0; j< pat->fNumStyles; j++) {
  907.                 if (pat->fStyleIndex[j].styleid == theid) {
  908.                 short rtop, rbottom, firstline;
  909.                 UpdateItemHeights(pat);
  910.                 if (IsVisible( item, rtop, rbottom, firstline )) {
  911.                     Nlm_RecT    rec;
  912.                     ViewRect( rec);
  913.                         rec.top= rtop;
  914.                         InvalRect( rec);
  915.                     }
  916.                 break;
  917.                 }
  918.             }
  919.         }
  920.     if (fAutoAdjust) AdjustScroll();
  921.       }
  922. }
  923.  
  924.  
  925.  
  926.  
  927.  
  928. short DRichView::GetItemNum(short desiredLine)
  929. {
  930.     // Returns the number of the paragraph containing the desired line
  931.  
  932.   short mid = 1;
  933.   short left = 1;
  934.   short right = fNumItems;
  935.   Boolean goOn = TRUE;
  936.   while (left <= right && goOn) {
  937.     mid = (left + right) / 2;
  938.     DParagraph* aParag = GetParaPtr(mid - 1);
  939.     if (aParag) {
  940.       if (desiredLine < aParag->startsAt + aParag->numRows)  
  941.         right = mid - 1;
  942.       if (desiredLine >= aParag->startsAt)  
  943.         left = mid + 1;
  944.         } 
  945.     else {
  946.       goOn = FALSE;
  947.       mid = 1;
  948.         }
  949.   }
  950.   return mid - 1;
  951. }
  952.  
  953.  
  954.  
  955. void DRichView::SetStyle(DRichStyle* theStyle)
  956. {
  957.     if (!theStyle || theStyle->linkid || theStyle->ispict) 
  958.         return; /* do these styles separately */
  959.     if (theStyle->font != fCurrentStyle->font) 
  960.         Nlm_SelectFont(theStyle->font);
  961.     if (theStyle->color != fCurrentStyle->color)
  962.         Nlm_SetColor(theStyle->color);
  963.  
  964.     ZeroCharWidths();
  965.     *fCurrentStyle = *theStyle;
  966. }
  967.  
  968.  
  969. void DRichView::ClearCurrentStyle()
  970. {
  971.     fCurrentStyle->ispict= false;
  972.     fCurrentStyle->ismap= false;
  973.     fCurrentStyle->ownpict= false;
  974.     fCurrentStyle->fPict= NULL; //fCurrentStyle->picdata= NULL;
  975.     fCurrentStyle->font= NULL;
  976.     fCurrentStyle->superSub= 0;
  977.     fCurrentStyle->color= 0;
  978. }
  979.  
  980.  
  981.  
  982. short DRichView::CharWidth(char ch)
  983. {
  984.     unsigned char cw= fCharWidths[ch];
  985.     if (cw == kNoCharWidth) {
  986.         cw= Nlm_CharWidth(ch);
  987.          fCharWidths[ch]= cw;
  988.          }
  989.     return cw;
  990. }
  991.  
  992. void DRichView::ZeroCharWidths()
  993. {
  994.     Nlm_MemFill( fCharWidths, kNoCharWidth, 256); // sizeof(fCharWidths)
  995. }
  996.  
  997. short DRichView::StyleLineWidth(char* texts, short maxwid, DParagraph* itemPtr, short& istyle)
  998. {
  999.   Char               ch;
  1000.   short              i,swid,wid,nextofs,numStyles;
  1001.     Boolean         styleset;
  1002.     DRichStyle * atstyle, savestyle;
  1003.     
  1004.   styleset= FALSE;
  1005.   i = wid = swid = 0;
  1006.     nextofs= itemPtr->fStyleIndex[istyle].nextofs;
  1007.     numStyles= itemPtr->fNumStyles;
  1008.     atstyle= GetStyleAtIndex(itemPtr, istyle);
  1009.     savestyle= *atstyle;
  1010.     
  1011.      if (atstyle->ispict) wid += atstyle->pixwidth; 
  1012.     if (texts && maxwid > 0) {
  1013.     ch = texts[i];
  1014.     while (ch != '\0' && ch != '\n' && ch != '\r' && wid <= maxwid) {
  1015.  
  1016.       if (i>=nextofs && istyle<numStyles-1) {  // && !atstyle->last    
  1017.                 ++istyle;
  1018.                 nextofs= itemPtr->fStyleIndex[istyle].nextofs;
  1019.                 atstyle= GetStyleAtIndex(itemPtr, istyle);
  1020.              SetStyle(atstyle);
  1021.              styleset= TRUE;
  1022.               if (atstyle->ispict) wid += atstyle->pixwidth; 
  1023.         }
  1024.         
  1025.       else if (!atstyle->hidden) {
  1026.             if (ch == '\t') {
  1027.                         // fix this tab width !!!
  1028.                   }
  1029.             else wid += CharWidth(ch);
  1030.           }
  1031.       
  1032.       i++;
  1033.       ch = texts [i];
  1034.         }
  1035.       }
  1036.     if (styleset) SetStyle( &savestyle);
  1037.     savestyle.ownpict= false;
  1038.   return wid;
  1039. }
  1040.  
  1041.  
  1042.  
  1043. short DRichView::FitTextToWidth(char* texts, short maxwid, Boolean byPixels,
  1044.                           DParagraph* itemPtr, short& istyle)
  1045. {
  1046.             // Returns the number of characters in the next block, including 
  1047.             // trailing spaces (which are trimmed back later)
  1048.   Char  ch;
  1049.   short  i,j,wid, swid, nextofs, numStyles;
  1050.     Boolean wordWrap, styleset;
  1051.     DRichStyle *atstyle, savestyle;
  1052.     
  1053.     nextofs= itemPtr->fStyleIndex[istyle].nextofs;
  1054.     numStyles= itemPtr->fNumStyles;
  1055.     atstyle= GetStyleAtIndex(itemPtr, istyle);
  1056.     SetStyle(atstyle); // be sure ??
  1057.     savestyle= *atstyle;
  1058.     wordWrap= itemPtr->wrap;
  1059.   i = j = 0;
  1060.   wid = swid = 0;
  1061.   if (texts && maxwid > 0) {
  1062.     ch = texts [i];
  1063.     while (ch != '\0' && ch != '\n' && ch != '\r' && wid <= maxwid) {
  1064.       if (wordWrap) {
  1065.           if (i>=nextofs && istyle<numStyles-1) {   //if (ch == chStyleTag) 
  1066.                     ++istyle;
  1067.                     nextofs= itemPtr->fStyleIndex[istyle].nextofs;
  1068.                     atstyle= GetStyleAtIndex(itemPtr, istyle);
  1069.                SetStyle(atstyle);
  1070.                styleset= TRUE;
  1071.                 if (atstyle->ispict && byPixels) wid += atstyle->pixwidth; 
  1072.             }
  1073.             
  1074.         else if (!atstyle->hidden) {
  1075.               if (ch == '\t') {
  1076.                         /* !!! FIX THIS !?!?! */
  1077.                 }
  1078.           else if (byPixels) wid += CharWidth (ch);
  1079.           else wid++;
  1080.             }
  1081.           }
  1082.       i++;
  1083.       ch = texts [i];
  1084.         }
  1085.           
  1086.     j = i;
  1087.     if (wordWrap && wid > maxwid) {
  1088.         // don't break in a word, and leave trailing spaces at end of line 
  1089.       j--;
  1090.       if (byPixels)  
  1091.         while (Nlm_TextWidth(texts, i) >= maxwid)  i--;
  1092.       else 
  1093.         while (i >= maxwid) i--;
  1094.       while (i > 0 && texts[i - 1] != ' ' && texts[i - 1] != '-')  i--;
  1095.       while (texts [i] == ' ')  i++;
  1096.         }
  1097.         
  1098.       }
  1099.     if (styleset) SetStyle( &savestyle);
  1100.     savestyle.ownpict= false; //!!
  1101.   if (i > 0 && i < j) return i;
  1102.     else if (j > 0) return j;
  1103.     else  return 0;
  1104. }
  1105.  
  1106.  
  1107.  
  1108.  
  1109.  
  1110.  
  1111. void DRichView::ParseText(DParagraph* itemPtr, char* text, Boolean byPixels, Nlm_RecT r)
  1112. {
  1113.             //  Parses text that contains \t, \r and \n characters into a list of
  1114.             //  cells organized by row and column
  1115.  
  1116.   char        ch, just;
  1117.   short       inset,
  1118.             istyle, numStyles, col, blklen, len,width,maxwid,
  1119.                       numRows,tabRow,returnRow,row;
  1120.   Uint2        start;
  1121.   Boolean      wrap;
  1122.     char           * ptex, * newtex;
  1123.     ulong         maxsize, newsize;
  1124.     
  1125.   if (itemPtr && text && *text != '\0') {
  1126.       numStyles= itemPtr->fNumStyles;
  1127.        istyle= 0;
  1128.     if (numStyles) {
  1129.         DRichStyle savestyle;
  1130.         savestyle= *fCurrentStyle;
  1131.         ClearCurrentStyle();
  1132.         SetStyle(GetStyleAtIndex(itemPtr, istyle));
  1133.         
  1134.           maxsize= (ulong) (StrLen(text) + 50 + itemPtr->minLines);
  1135.           newsize= 0;
  1136.           newtex = (char*) MemNew (maxsize);
  1137.          ptex= newtex;
  1138.          
  1139.       width = 0;
  1140.       inset = itemPtr->leftInset; /* pixLeft, pixFirst ?? */
  1141.       just = itemPtr->just; /*'l';*/
  1142.       wrap = itemPtr->wrap; /* TRUE; /* fix this as choice ... */
  1143.       start = 0;
  1144.       row = 0;
  1145.       tabRow = 0;
  1146.       returnRow = 1;
  1147.       col = 0;
  1148.       numRows = 0;
  1149.       while (text[start] != '\0') {
  1150.         ch = text[start];
  1151.         if (ch != '\0' && ch != '\n' && ch != '\r'  ) {
  1152.           maxwid =  r.right - r.left - 15; // !!! Need PAGEWIDTH here !!
  1153.           short istyle0= istyle;                    
  1154.           blklen =  FitTextToWidth(text + start, maxwid, byPixels, 
  1155.                               itemPtr, istyle);
  1156.                 if (istyle!=istyle0) SetStyle(GetStyleAtIndex(itemPtr, istyle));
  1157.           len = blklen;
  1158.           
  1159.           if (len > 0) {
  1160.             if (text[start + len] != '\0') { // eat trailing spaces 
  1161.               while (len > 0 && text [start + len - 1] == ' ') len--;
  1162.               if (len == 0) len = blklen;
  1163.                 }
  1164.             if (newsize+len > maxsize) {
  1165.                 maxsize= newsize+len+100;
  1166.                 newtex= (char*) MemMore(newtex, maxsize);  
  1167.                 }
  1168.             MemCpy( newtex+newsize, text+start, len);
  1169.             newsize += len;
  1170.             start += blklen;
  1171.               } 
  1172.               
  1173.           else { // len==0, shouldn't be true ? 
  1174.  
  1175.               }
  1176.             }
  1177.             
  1178.         ch = text [start];
  1179.         if (ch == '\n') {
  1180.                  newtex[newsize++]= '\n';
  1181.               start++;
  1182.           row = returnRow;
  1183.           tabRow = row;
  1184.           returnRow++;
  1185.           col = 0;
  1186.             } 
  1187.         else if (ch == '\r') {
  1188.                  newtex[newsize++]= '\n';
  1189.           start++;
  1190.           row++;
  1191.           returnRow = MAX (returnRow, row + 1);
  1192.                } 
  1193. #if 0
  1194.         else if (ch == '\t') {
  1195.           start++;
  1196.           row = tabRow;
  1197.               newtex[newsize++]= '\t';
  1198.           if (text [start] == '\0') row = returnRow;
  1199.             } 
  1200. #endif
  1201.         else if (ch != '\0' && wrap) {
  1202.               newtex[newsize++]= '\n';
  1203.           if (len == 0) start++;
  1204.           row++;
  1205.           returnRow = MAX (returnRow, row + 1);
  1206.             } 
  1207.         else if (ch != '\0') 
  1208.             start++;
  1209.         else if (text [start - 1] != '\n' && text [start - 1] != '\r')  
  1210.           row = returnRow;
  1211.          
  1212.         numRows = MAX (numRows, row);
  1213.           }
  1214.       itemPtr->numRows = MAX (numRows, itemPtr->minLines);
  1215.             newtex[newsize++]= '\0';
  1216.             itemPtr->fText = newtex;
  1217.             SetStyle(&savestyle);
  1218.             savestyle.ownpict= false; // !!
  1219.         }
  1220.       } 
  1221.   else if (itemPtr != NULL)  
  1222.     itemPtr->numRows = 0;
  1223. }
  1224.  
  1225.  
  1226.  
  1227.  
  1228.  
  1229. // temp globals...
  1230.  
  1231. static short gMapOfs = 0;
  1232. //static DRichStyle* gMapStyle = NULL;
  1233.  
  1234. short DRichView::DrawStyledItem(DParagraph* itemPtr, Nlm_RectPtr rpara, short item,
  1235.                                       short frst, Boolean forPrinter, Nlm_PoinT* mapPoint)
  1236. {
  1237.                 // Draws a given paragraph(item) on the screen, using parag & char styles 
  1238.   char         ch, just, csave;
  1239.   Boolean      isnewline, bartab, dotab, mapPt, drawSelection,   
  1240.                           aBorderLast, aBorderNext, gray, doborder;
  1241.   char         * ptext, * text;
  1242.   unsigned long            nextofs;
  1243.   short     lineHeight, num, row, rsult, rleft, rright, rbottom, width, maxwid,
  1244.                          istyle,styleid, istyle2, numStyles, superSub, txtwidth, yfont; 
  1245.                       
  1246.   DRichStyle    * astyle;  
  1247.   Nlm_RecT         rct; // drw
  1248.     Nlm_PoinT            pt1, pt2; //, atpt;
  1249.     
  1250.     mapPt= (mapPoint != NULL);
  1251.     if (mapPt) fMapStyle= NULL;
  1252.     fDodraw= (mapPoint == NULL);
  1253.     drawSelection= (fSelected && fDodraw && !forPrinter 
  1254.                                     && item >= fSelParag && item <= fSelEndParag);
  1255.   rsult = 0;
  1256.   if (itemPtr && rpara) {
  1257.     text = itemPtr->fText;
  1258.     numStyles= itemPtr->fNumStyles;
  1259.     
  1260.     if (text && *text != '\0') {
  1261.         just= itemPtr->just;
  1262.       lineHeight = itemPtr->lineHeight;
  1263.       rct.top = rpara->top;
  1264.       rct.bottom = rct.top;
  1265.             rbottom = rct.top + lineHeight * (itemPtr->numRows - frst);
  1266.              rleft= fAtpt.x = rpara->left + itemPtr->leftInset + itemPtr->firstInset;
  1267.       fAtpt.y = rpara->top;
  1268.       row = 0;
  1269.       txtwidth= 0;
  1270.       ptext = text;
  1271.       ch = *ptext;
  1272.           gray = FALSE;
  1273.             isnewline= TRUE;
  1274.  
  1275. //Debug("1");
  1276.          istyle= 0;
  1277.          styleid= itemPtr->fStyleIndex[istyle].styleid;
  1278.          nextofs= itemPtr->fStyleIndex[istyle].nextofs;
  1279.              astyle= GetStyle(styleid);
  1280.  
  1281.             Nlm_LoadRect(&fDrawr, rleft, rpara->top, rpara->right, rbottom);
  1282.             
  1283.       if (itemPtr->newPage) {
  1284.           /* probably on line by self... */
  1285.           /* record footnote text somewhere and dump out here before page break... */
  1286.           if (fDodraw && !forPrinter) {
  1287.                     Nlm_Dashed(); // Nlm_Dotted(); 
  1288.                 Nlm_FrameRect(&fDrawr);
  1289.                     Nlm_ResetDrawingTools();
  1290.                     }
  1291.           }
  1292.                        
  1293.          ClearCurrentStyle();
  1294.          SetStyle(astyle);
  1295.             superSub= astyle->superSub;
  1296.             
  1297.       while (ch != '\0') {
  1298.       
  1299.         if (ch == '\n') {
  1300.           rct.top = rpara->top + (row - frst) * lineHeight;
  1301.           rct.bottom = rct.top + lineHeight;
  1302.             rleft= fAtpt.x = rpara->left + itemPtr->leftInset;
  1303.           row++;
  1304.           ptext++; 
  1305.           isnewline= TRUE;
  1306. //Debug("/");
  1307.             } 
  1308.                     
  1309.         else if (ch == chPictTag) {
  1310.           ptext++;
  1311.             } 
  1312.            
  1313.         else  {
  1314.         
  1315.                     while ( (ptext - text >= nextofs) && (istyle < numStyles-1)) {
  1316. //Debug("s");
  1317.                      istyle++;
  1318.                      styleid= itemPtr->fStyleIndex[istyle].styleid;
  1319.                      nextofs= itemPtr->fStyleIndex[istyle].nextofs;
  1320.                      if (!((ptext - text >= nextofs) && (istyle < numStyles-1))) {
  1321.                              astyle= GetStyle(styleid);
  1322.                          SetStyle(astyle);
  1323.                             superSub= astyle->superSub;
  1324.                             }
  1325.                         }
  1326.  
  1327.                   if (isnewline) {
  1328.                          doborder= itemPtr->borderright || itemPtr->borderleft 
  1329.                                 || itemPtr->borderbottom || itemPtr->bordertop 
  1330.                                 || itemPtr->borderbox;
  1331.                         if (doborder) {        
  1332.                          DParagraph*  otherItem;
  1333.                            
  1334.                            aBorderLast= FALSE;
  1335.                            aBorderNext= FALSE;
  1336.                          if (item>1 && itemPtr->bordertop || itemPtr->borderbox) {
  1337.                              otherItem = GetParaPtr(item-2);  //! item# is +1 of parag# 
  1338.                              aBorderLast= (otherItem->bordertop || otherItem->borderbox);
  1339.                              }
  1340.                          if (itemPtr->borderbottom || itemPtr->borderbox) {
  1341.                              otherItem = GetParaPtr(item);    //! item# is +1 of parag# 
  1342.                                 if (otherItem) aBorderNext= (otherItem->borderbottom || otherItem->borderbox);
  1343.                              }
  1344.                          }
  1345.  
  1346.                 if (just != 'l') {
  1347.                     istyle2= istyle;
  1348.                   maxwid=  rpara->right - rpara->left; //!!! Need PAGEWIDTH here !!
  1349.                              width= StyleLineWidth( ptext, maxwid, itemPtr, istyle2);
  1350.                              if (width<maxwid) {
  1351.                                  switch (just) {
  1352.                                      case 'r': 
  1353.                                          fAtpt.x= /*rleft= */ MAX( rleft, rpara->right - itemPtr->rightInset - width); 
  1354.                                          break;
  1355.                                      case 'c': { 
  1356.                                          short rhalf= ((rpara->right - itemPtr->rightInset - rleft) - width) / 2; 
  1357.                                          if (rhalf>0) fAtpt.x= rleft += rhalf;
  1358.                                          }
  1359.                                          break;
  1360.                                      }
  1361.                                  }
  1362.                     }
  1363.                       isnewline= FALSE;
  1364.                       }
  1365.                       
  1366.                 num = 0;
  1367.                 while ( ch == '\t') ch= ptext[++num];
  1368.           while ( ch != '\0' && ch != '\n' && ch != '\t' 
  1369.               && ( (num + ptext - text) < nextofs))   
  1370.                 ch = ptext[++num];
  1371.  
  1372.           if (row >= frst) {
  1373.                     Boolean inrect;
  1374.  
  1375.  //Debug("r");
  1376.             rct.top = rpara->top + (row - frst) * lineHeight;
  1377.             rct.bottom = rct.top + lineHeight;
  1378.             rct.left = fAtpt.x;  
  1379.             rct.right = rpara->right - itemPtr->rightInset; 
  1380.                         if (doborder && row == itemPtr->numRows-1 
  1381.                             && (itemPtr->borderbottom || itemPtr->borderbox)) 
  1382.                                 rct.bottom--;
  1383.             Nlm_LoadRect (&fDrawr, MAX (rct.left, rpara->left), rct.top,
  1384.                       MIN (rct.right, rpara->right), rct.bottom);
  1385.  
  1386. #if 1
  1387.                         inrect= (rct.top <= rpara->bottom && rct.bottom > rpara->top);
  1388. #else
  1389.                          inrect= Nlm_SectRect( &fDrawr, rpara, &rsect);
  1390. #endif
  1391.             if ( inrect && (mapPt || forPrinter || Nlm_updateRgn == NULL ||
  1392.                      Nlm_RectInRgn (&rct, Nlm_updateRgn))) {
  1393.               fDrawr = rct;
  1394.                             fDrawr.top += superSub; 
  1395.                             fDrawr.bottom += superSub;  
  1396. // Debug1("%d",num);
  1397.               if (num > 0  && !(astyle->hidden)) {
  1398. // Debug("i");
  1399.                   just= 'l';
  1400.                        bartab= FALSE;
  1401.                      dotab= FALSE;
  1402.  
  1403.                         /* yfont= fDrawr.top + Nlm_Ascent();  /* a. large font mismatch */
  1404.                            /* yfont= fDrawr.bottom - Nlm_Descent() - Nlm_Leading(); /* b. better than a */
  1405.                            /* yfont= fDrawr.bottom - Nlm_Descent(); /* c. almost perfect, slight font mismatch */
  1406.                         /* yfont= fDrawr.top + Nlm_FontHeight(); /* d. bad, too low, font mismatch */
  1407.                            yfont= fDrawr.bottom - 4; /* Nlm_stdDescent; /* e. !! YES, but what is right ## ?? */
  1408.                            /* yfont= fDrawr.top + Nlm_FontHeight() - Nlm_Descent(); /* f. ?? */
  1409.  
  1410.                 while (num > 0 && *ptext == '\t') {
  1411.                   dotab= TRUE;
  1412.                   num--;
  1413.                   ptext++;
  1414.                   
  1415.                   if (fDrawr.left < rleft) /* rpara->left + itemPtr->leftInset + itemPtr->firstInset */
  1416.                       fDrawr.left= rleft;
  1417.                   else if (itemPtr->numstops) {
  1418.                        short istop, nextstop;
  1419.                        istop= 0;
  1420.                       do { 
  1421.                           /* nextstop = rpara->left + itemPtr->leftInset + itemPtr->tabstops[istop]; */
  1422.                           nextstop = rleft + itemPtr->tabstops[istop];
  1423.                           istop++; 
  1424.                           }
  1425.                       while (istop<itemPtr->numstops && nextstop>0 && nextstop<fDrawr.left);
  1426.                       
  1427.                       /* ?? 27may */
  1428.                       nextstop = MIN(nextstop, rpara->right - itemPtr->rightInset/* - width*/);
  1429.                       
  1430.                       if (*ptext == '\t')
  1431.                           fDrawr.left= nextstop;
  1432.                       else switch (itemPtr->tabkinds[istop-1]) {
  1433.                           case DParagraph::kTabBar:
  1434.                                   bartab= TRUE;
  1435.                           case DParagraph::kTabDecimal: 
  1436.                           case DParagraph::kTabLeft    : 
  1437.                                   just= 'l'; 
  1438.                                      fDrawr.left= nextstop;
  1439.                                   break;
  1440.                           case DParagraph::kTabRight: 
  1441.                                   just= 'r'; 
  1442.                                   fDrawr.right= nextstop;
  1443.                                   break;
  1444.                           case DParagraph::kTabCenter: 
  1445.                                   just= 'c'; 
  1446.                                   fDrawr.right= nextstop + (nextstop - fDrawr.left);
  1447.                                   break;
  1448.                           }
  1449.                          }
  1450.                   else { 
  1451.                       short nextstop= rleft; /* rpara->left + itemPtr->leftInset;*/
  1452.                       if (itemPtr->deftabstop>0)
  1453.                        do { nextstop += itemPtr->deftabstop; }
  1454.                        while (nextstop>0 && fDrawr.left > nextstop);
  1455.                       fDrawr.left= nextstop;
  1456.                       }
  1457.                         
  1458.                     fAtpt.x = fDrawr.left; /* ??? */
  1459.                     }
  1460.                     
  1461.                    if (dotab && itemPtr->tablead > ' ') {
  1462.                     char    tabbuf[256];
  1463.                     short    cwidth, tabcount= 0;
  1464.                     Nlm_RecT    tabr;
  1465.                     
  1466.                     cwidth= CharWidth(itemPtr->tablead);
  1467.                                 tabr= rct;
  1468.                                 tabr.right= fDrawr.left;
  1469.                                 tabcount= MIN(254, MAX(1, (tabr.right - tabr.left - 1) / cwidth + 1));
  1470.                                 Nlm_MemFill( tabbuf, itemPtr->tablead, tabcount);
  1471.                                 tabbuf[tabcount]= 0;
  1472.                        Nlm_MoveTo(tabr.left, yfont); /*! need to ajust for leading !*/
  1473.                        if (fDodraw) Nlm_PaintString(tabbuf);
  1474.                     }
  1475.                
  1476.                                 if (bartab) {
  1477.                                     pt1.x= pt2.x= fDrawr.left;
  1478.                                     pt1.y= rct.top;
  1479.                                     pt2.y= rct.bottom;
  1480.                                     if (fDodraw) Nlm_DrawLine(pt1,pt2);
  1481.                                     fAtpt.x= ++fDrawr.left;
  1482.                                     }
  1483.  
  1484.                     if (astyle->allcaps || astyle->smallcaps) { 
  1485.                         char* cp= ptext;
  1486.                         for (short i=0; i<num; i++) cp[i]= to_upper(cp[i]);
  1487.                             // need to shift fontsize down for lowercases 
  1488.                         }
  1489.  
  1490.                         txtwidth= Nlm_TextWidth(ptext, num); 
  1491.                          
  1492.                   switch (just) {
  1493.                          case 'c': 
  1494.                              rright= (fDrawr.left + txtwidth + fDrawr.right)/ 2; 
  1495.                                         fDrawr.left += (fDrawr.right - fDrawr.left - txtwidth) / 2; 
  1496.                              break;
  1497.                          case 'r':
  1498.                              rright = fDrawr.right; 
  1499.                              fDrawr.left = fDrawr.right - txtwidth; 
  1500.                              break;
  1501.                          default:
  1502.                          case 'l':
  1503.                                    /* rright= fDrawr.left + astyle->pixwidth; */
  1504.                                 rright= fDrawr.left + txtwidth + 1;
  1505.                              break;
  1506.                          }
  1507.                          
  1508.                      /* these are no good for multilines w/ same style, & resizing changes */
  1509.                                 if (astyle->pixwidth==0) astyle->pixwidth= rright - fAtpt.x;
  1510.                                 astyle->pixleft= fAtpt.x;
  1511.  
  1512. #if 0
  1513.     // this looks too messy !!
  1514.     // ?? quick fix for html text that is off screen to left or right ?
  1515.                                 if (rright > rpara->right) Nlm_OffsetRect( &fDrawr, rpara->right-rright, 0);
  1516.                                 if (fDrawr.left < rpara->left) fDrawr.left= rpara->left;
  1517. #endif
  1518.                                 
  1519.                      Nlm_MoveTo(fDrawr.left, yfont);  // yfont == adjust for leading
  1520.                      if (fDodraw) {
  1521.                          csave= ptext[num]; ptext[num]= 0;
  1522.                          Nlm_PaintString(ptext);
  1523.                      ptext[num]= csave;                                    
  1524.                               }
  1525.  
  1526.                      else if (mapPoint && Nlm_PtInRect( *mapPoint, &fDrawr)) {
  1527.                          if (astyle->ispict) {
  1528. #if 0
  1529.                                         astyle->fPict->FindPt( fDrawr, pt);
  1530.                                         // return isInPict && point-rel to pict && astyle or styleid !!
  1531. #endif
  1532.                                 fAtpt.x= rright;
  1533.                              fDrawr.left= fAtpt.x;  
  1534.                              gMapOfs= (short)(ptext - text); // pict point ??
  1535.                            fMapStyle= astyle;
  1536.                              return gMapOfs; // text point..
  1537.                              }
  1538.                          else {
  1539.                              // return also num chars !?
  1540.                              short atx= mapPoint->x - fDrawr.left;
  1541.                              short    i= num;
  1542.                              if (Nlm_TextWidth(ptext, i) >= atx) {
  1543.                                  while (i>0 && Nlm_TextWidth(ptext, i) > atx) i--;
  1544.                                  gMapOfs= (short)(ptext + i - text);
  1545.                                             fMapStyle= astyle;
  1546.     
  1547.                                      // !! not finding proper style (for links)
  1548.                                  short ist= istyle;
  1549.                                  short nof= nextofs;
  1550.                                  short sid= styleid;
  1551.                                  while ( gMapOfs >= nof && ist < numStyles-1 ) {
  1552.                                              ist++;
  1553.                                              sid= itemPtr->fStyleIndex[ist].styleid;
  1554.                                              nof= itemPtr->fStyleIndex[ist].nextofs;
  1555.                                                 fMapStyle= GetStyle(sid);
  1556.                                                 }
  1557.                                  return gMapOfs; // text point..
  1558.                                  }
  1559.                              else {
  1560.                                  // ??? continue on for more of ptext, if proper line ...
  1561.                                  // there must be some mistake in fDrawr if we get here??
  1562.                                  }
  1563.                              }
  1564.                          }
  1565.  
  1566.                                 if (astyle->linkid && fDodraw) {
  1567.                                   if (!forPrinter) {
  1568.                                          Nlm_SetColor(astyle->color);
  1569. #if 1
  1570.                                         Nlm_WidePen(2);
  1571.                                         /* Nlm_Dotted(); /* Nlm_Dashed(); */
  1572.                                         Nlm_MoveTo( fDrawr.left, fDrawr.bottom-2);
  1573.                                         Nlm_LineTo( rright-1, fDrawr.bottom-2);
  1574.                                         Nlm_WidePen(1);
  1575.                                         Nlm_Solid();
  1576. #else
  1577.                                         fDrawr.right= rright-1;
  1578.                                         Nlm_FrameRect( &fDrawr);
  1579. #endif
  1580.                                         Nlm_SetColor(fCurrentStyle->color);
  1581.                                         }
  1582.                                     }
  1583.                                 else if (astyle->boxed && fDodraw) {
  1584.                                     fDrawr.right= rright-1;
  1585.                                     Nlm_FrameRect( &fDrawr);
  1586.                                     }
  1587.  
  1588.                                 Nlm_Black(); /* need this or something like to fix color bug in XWin */
  1589.  
  1590.                                 if (drawSelection) {
  1591.                                     short textofs= ptext - text; 
  1592.                                     short textend= textofs + num; 
  1593.                                     Nlm_RecT selr= fDrawr;
  1594.                                     Boolean showsel= true;
  1595.                                     short  baseleft= selr.left;
  1596.                                     
  1597.                                     if (item == fSelParag) {
  1598.                                         if (textend < fSelChar) showsel= false;
  1599.                                         if (showsel && textofs < fSelChar) 
  1600.                                             selr.left = MIN( selr.right, 
  1601.                                                 baseleft + Nlm_TextWidth( ptext, fSelChar - textofs));
  1602.                                         }
  1603.                                         
  1604.                                     if (showsel && item == fSelEndParag) {
  1605.                                       if (textofs > fSelEndChar) showsel= false;
  1606.                                         if (showsel && textofs < fSelEndChar) //textend > fSelEndChar
  1607.                                             selr.right = MAX(selr.left, 
  1608.                                                 baseleft + Nlm_TextWidth( ptext, fSelEndChar - textofs));
  1609.                                         }
  1610.  
  1611.                                     if (showsel) Nlm_InvertRect( &selr);
  1612.                                     }
  1613.                                     
  1614.                                     
  1615.                         fAtpt.x= rright;
  1616.  
  1617.                    if (astyle->strikeout && fDodraw) {
  1618.                        short dmid= (fDrawr.top + fDrawr.bottom) / 2;
  1619.                        Nlm_MoveTo( fDrawr.left, dmid);
  1620.                        Nlm_LineTo( fAtpt.x, dmid);
  1621.                        }
  1622.                      fDrawr.left= fAtpt.x;  
  1623.  
  1624.                                 if (astyle->ispict) {
  1625.                                     fDrawr.right = fDrawr.left + astyle->pixwidth;
  1626.                                     fDrawr.bottom= fDrawr.top + astyle->pixheight;
  1627.                                   fAtpt.x= fDrawr.right+1;
  1628.                                     if (fDodraw) {
  1629.                                         if (astyle->fPict) astyle->fPict->Draw( fDrawr);
  1630.                                         Nlm_ResetDrawingTools();
  1631.                                         }
  1632.                                     fDrawr.left= fAtpt.x;
  1633.                                     }
  1634.                    }
  1635.                  fDrawr.right = rct.right;
  1636.               
  1637.                                 // !! top/bottom borders need to be turned off when adjacent parags also have them 
  1638.                             if (doborder && fDodraw) {
  1639.  
  1640.                                 switch (itemPtr->borderstyle) {
  1641.                                     case DParagraph::kBorderThick    : Nlm_WidePen(3); break;
  1642.                                     case DParagraph::kBorderDot        : Nlm_Dotted(); break;
  1643.                                     case DParagraph::kBorderDash    : Nlm_Dashed(); break;
  1644.                                     case DParagraph::kBorderDouble: break;
  1645.                                     case DParagraph::kBorderSingle: break;
  1646.                                     case DParagraph::kBorderShadow: break;
  1647.                                     case DParagraph::kBorderHair    : break;
  1648.                                     }
  1649.  
  1650.                                 if (!aBorderLast && (itemPtr->bordertop || itemPtr->borderbox) && row==0) {
  1651.                                     /* respect borderstyle...*/
  1652.                                     pt1.x= rpara->left;
  1653.                                     pt2.x= rpara->right-1;
  1654.                                     pt1.y= pt2.y= rct.top;
  1655.                                     Nlm_DrawLine(pt1,pt2);
  1656.                                     if (itemPtr->borderstyle == DParagraph::kBorderDouble) {
  1657.                                         pt1.y= pt2.y= rct.top-2;
  1658.                                         Nlm_DrawLine(pt1,pt2);
  1659.                                         }
  1660.                                     }
  1661.                                 if (!aBorderNext && row == itemPtr->numRows-1 && (itemPtr->borderbottom || itemPtr->borderbox)) {
  1662.                                     pt1.x= rpara->left;
  1663.                                     pt2.x= rpara->right-1;
  1664.                                     pt1.y= pt2.y= rct.bottom;
  1665.                                     Nlm_DrawLine(pt1,pt2);
  1666.                                     if (itemPtr->borderstyle == DParagraph::kBorderDouble) {
  1667.                                         pt1.y= pt2.y= rct.bottom+2;
  1668.                                         Nlm_DrawLine(pt1,pt2);
  1669.                                         }
  1670.                                     }
  1671.                                 if ((itemPtr->borderleft || itemPtr->borderbox)) {
  1672.                                     pt1.x= pt2.x= rpara->left;
  1673.                                     pt1.y= rct.top;
  1674.                                     pt2.y= rct.bottom;
  1675.                                     Nlm_DrawLine(pt1,pt2);
  1676.                                     if (itemPtr->borderstyle == DParagraph::kBorderDouble) {
  1677.                                         pt1.x= pt2.x= rpara->left-2;
  1678.                                         Nlm_DrawLine(pt1,pt2);
  1679.                                         }
  1680.                                     }
  1681.                                 if ((itemPtr->borderright || itemPtr->borderbox)) {
  1682.                                     pt1.x= pt2.x= rpara->right-1; /* past scrollbar...*/
  1683.                                     pt1.y= rct.top;
  1684.                                     pt2.y= rct.bottom;
  1685.                                     Nlm_DrawLine(pt1,pt2);
  1686.                                     if (itemPtr->borderstyle == DParagraph::kBorderDouble) {
  1687.                                         pt1.x= pt2.x= rpara->right+2;
  1688.                                         Nlm_DrawLine(pt1,pt2);
  1689.                                         }
  1690.                                     }
  1691.                                 Nlm_ResetDrawingTools();
  1692.                                  doborder= FALSE;
  1693.                                 }
  1694.               }
  1695.               }
  1696.                     if (!num) ptext++; else ptext += num;
  1697.             }
  1698.         ch = *ptext;
  1699.              }
  1700.       rct.top = rct.bottom;
  1701.       rsult = rct.top - rpara->top;
  1702.         }
  1703.     Nlm_SelectFont(Nlm_programFont);  //Nlm_systemFont
  1704.       }
  1705.   if (mapPt) return -1;   // couldn't find mapPoint if we got here
  1706.   else return rsult;
  1707. }
  1708.  
  1709.  
  1710.  
  1711.  
  1712.  
  1713. char* DRichView::DataToChar(char* ptr)  
  1714. {
  1715.   if (ptr) 
  1716.     return Nlm_StringSave((char*)ptr);
  1717.   else 
  1718.     return NULL;
  1719. }
  1720.  
  1721.  
  1722. void DRichView::FormatText( short item, DParagraph* itemPtr, Boolean byPixels)
  1723. {
  1724.         // parses and rearranges the text so that it can be displayed, saved, or printed
  1725.   char           ch;
  1726.   Boolean        needToParse;
  1727.   short       numRows;
  1728.   char*            text;
  1729.     Nlm_RecT        r;
  1730.     
  1731.     /* dgg &fix this */
  1732.  
  1733.   if (itemPtr && itemPtr->fText == NULL) {
  1734.         this->ViewRect( r);
  1735.     needToParse = TRUE;
  1736.         text = this->DataToChar(itemPtr->fDataPtr);
  1737.         
  1738.     if (needToParse && text && *text != '\0') {
  1739.       ParseText(itemPtr, text, byPixels, r);
  1740.       itemPtr->notCached = FALSE;
  1741.       itemPtr->neverCached = FALSE;
  1742.       MemFree(text);
  1743.         } 
  1744.     else  
  1745.       itemPtr->fText = text;
  1746.      
  1747.     text = itemPtr->fText;
  1748.     if (text == NULL || *text == '\0') {
  1749.       MemFree(itemPtr->fText);
  1750.       itemPtr->fText = StringSave(" \n");
  1751.       itemPtr->numRows = 1;
  1752.       itemPtr->notCached = FALSE;
  1753.       itemPtr->neverCached = FALSE;
  1754.       needToParse = TRUE;
  1755.         } 
  1756.     else if (fIsVirtual) {
  1757.       numRows = 0;
  1758.       ch = *text;
  1759.       while (ch != '\0') {
  1760.         if (ch == '\n') numRows++;
  1761.         text++;
  1762.         ch = *text;
  1763.           }
  1764.       numRows = MAX (1, numRows);
  1765.       itemPtr->numRows = MAX (numRows, itemPtr->minLines);
  1766.         }
  1767.   }
  1768. }
  1769.  
  1770.  
  1771. short DRichView::GetLineStart(short item)
  1772. {
  1773.             // Returns the first line of the item
  1774.   DParagraph*  itemPtr = GetParaPtr(item);  
  1775.   if (itemPtr) return itemPtr->startsAt;
  1776.   else return 0;
  1777. }
  1778.  
  1779. short DRichView::GetNumRows(short item)
  1780. {
  1781.                 //   Returns the number of rows in the item
  1782.   DParagraph*  itemPtr  = GetParaPtr( item);  
  1783.   if (itemPtr)  return itemPtr->numRows;
  1784.   else return 0;
  1785. }
  1786.  
  1787. short DRichView::GetLineHeight(short item)
  1788. {
  1789.         //     Returns the pixel height of the item
  1790.   DParagraph*  itemPtr  = GetParaPtr( item);  
  1791.   if (itemPtr)  return itemPtr->lineHeight;
  1792.   else return 0;
  1793. }
  1794.  
  1795.  
  1796.  
  1797.  
  1798.     
  1799. Boolean DRichView::Doc2ViewOffset(short& xoff, short& yoff)
  1800. {
  1801.   Nlm_RecT             viewr, rct;
  1802.   short             atline, itemNum, leadHeight, lineHeight, numRows, off;
  1803.   Nlm_BaR          sb;
  1804.   DParagraph*      itemPtr;
  1805.     
  1806.     ViewRect( viewr);
  1807.     Nlm_LoadRect( &rct, 0, 0, viewr.right - viewr.left, 0);
  1808.   sb = Nlm_GetSlateVScrollBar((Nlm_SlatE) fPanel);
  1809.     if (sb) off = Nlm_GetValue(sb); // line offset of view
  1810.     else off= 0;
  1811.     
  1812.     //for (atline=0; atline<= off; atline++)  
  1813.     atline = 0;
  1814.     leadHeight = 0;
  1815.     itemNum = 0; //= GetItemNum( atline);
  1816.     while (itemNum < fNumItems && atline < off) {
  1817.         itemPtr = GetParaPtr( itemNum);
  1818.       if (itemPtr) {
  1819.             rct.top = rct.bottom + leadHeight;
  1820.       CacheIfNever( itemNum + 1, itemPtr, &viewr);
  1821.           if (atline>0) rct.top += itemPtr->spaceBefore;
  1822.       lineHeight = itemPtr->lineHeight;
  1823.       rct.top += leadHeight;
  1824.       numRows = itemPtr->numRows;
  1825.       rct.bottom = rct.top + lineHeight * (numRows) + itemPtr->spaceAfter;
  1826.            leadHeight = itemPtr->leadHeight;
  1827.           atline += numRows;
  1828.             }
  1829.         itemNum++;
  1830.         }
  1831.  
  1832.     xoff = rct.left;
  1833.     yoff = rct.top; // - viewr.top; // ??? was +top
  1834.     return true;
  1835. }    
  1836.  
  1837.     
  1838. Boolean DRichView::MapDoc2View( Nlm_RecT& selr)
  1839. {
  1840.   Nlm_RecT     viewr, rct;
  1841.     short        xoff, yoff;
  1842.  
  1843.     Doc2ViewOffset(xoff, yoff);
  1844.     selr.left         -= xoff;
  1845.     selr.right     -= xoff;
  1846.     selr.top         -= yoff;
  1847.     selr.bottom -= yoff;
  1848.     
  1849.     ViewRect( viewr);
  1850. #ifdef DBUG
  1851.     return true;        // !! SectRect always false for WIN_MOTIF !!!!!        
  1852. #else
  1853.     Boolean visible= Nlm_SectRect( &selr, &viewr, &rct);
  1854.     return visible;
  1855. #endif
  1856. }
  1857.  
  1858. void DRichView::MapView2Doc( Nlm_RecT& selr)
  1859. {
  1860.     short        xoff, yoff;
  1861.     
  1862.     Doc2ViewOffset(xoff, yoff);
  1863.     selr.left         += xoff;
  1864.     selr.right     += xoff;
  1865.     selr.top         += yoff;
  1866.     selr.bottom += yoff;
  1867. }
  1868.     
  1869. void DRichView::MapView2Doc( Nlm_PoinT& mpt)
  1870. {
  1871.     short        xoff, yoff;
  1872.     
  1873.     Doc2ViewOffset(xoff, yoff);
  1874.     mpt.x         += xoff;
  1875.     mpt.y         += yoff;
  1876. }
  1877.  
  1878.  
  1879. Boolean    DRichView::HiliteText(short startparag, short startchar, 
  1880.                                                             short endparag, short endchar, Boolean turnon) 
  1881. { 
  1882.             // Finds the visible region of an startparag in a document
  1883.   short             firstItem, fstLine, itemNum, leadHeight,lineHeight, numRows, off;
  1884.   Nlm_RecT         viewr, rct;
  1885.   Boolean              goOn, rsult;
  1886.   Nlm_BaR          sb;
  1887.   DParagraph*      itemPtr;
  1888.  
  1889.   rsult = FALSE;
  1890.      //top = 0;
  1891.      //bottom = 0;
  1892.   //firstline = 0;
  1893.  
  1894.     ViewRect( viewr);
  1895.   sb = Nlm_GetSlateVScrollBar((Nlm_SlatE) fPanel);
  1896.   if (sb) off = Nlm_GetValue(sb);
  1897.   else off= 0;
  1898.   if (startparag >= 0 && startparag < fNumItems) {
  1899.     goOn = TRUE;
  1900.     Nlm_LoadRect(&rct, viewr.left, viewr.top, viewr.right, viewr.top);
  1901.     itemNum = GetItemNum( off);
  1902.     itemPtr = GetParaPtr( itemNum);
  1903.     if (itemPtr) {
  1904.       fstLine = off - itemPtr->startsAt;
  1905.       firstItem = itemNum;
  1906.       lineHeight = 0;
  1907.       leadHeight = 0;
  1908.       numRows = 0;
  1909.       while (goOn && itemNum < fNumItems && itemNum <= startparag) {
  1910.         itemPtr = GetParaPtr( itemNum);
  1911.         if (itemPtr) {
  1912.           CacheIfNever( itemNum + 1, itemPtr, &viewr);
  1913.           if (itemNum > firstItem)  
  1914.             leadHeight = itemPtr->leadHeight;
  1915.             else  
  1916.             leadHeight = 0;
  1917.               if (fstLine==0) rct.top += itemPtr->spaceBefore;
  1918.           
  1919.           lineHeight = itemPtr->lineHeight;
  1920.           rct.top += leadHeight;
  1921.           numRows = MIN (itemPtr->numRows,
  1922.                          MAX ((viewr.bottom - rct.top) / lineHeight, 0));
  1923.           rct.bottom = rct.top + lineHeight * (numRows - fstLine);
  1924.               rct.bottom += itemPtr->spaceAfter;
  1925.           if (itemNum == startparag) {
  1926.             //goOn = FALSE;
  1927.             if (numRows > 0) {
  1928.                 //top = rct.top;
  1929.                 //bottom = rct.bottom;
  1930.                 //firstline = fstLine;
  1931.                 fSelRect.top= rct.top;
  1932.                 fSelRect.bottom= rct.bottom;
  1933.                 //gMapOfs
  1934.                 fSelRect.left= rct.left; // this is bogus, just is left edge...
  1935.                 fSelRect.right= rct.right; // this also is bogus
  1936.               rsult = TRUE;
  1937.                 }
  1938.               } 
  1939.           else  
  1940.             rct.top = rct.bottom;
  1941.           if (numRows < itemPtr->numRows)  
  1942.             goOn = FALSE;
  1943.             }
  1944.         itemNum++;
  1945.         fstLine = 0;
  1946.           }
  1947.         }
  1948.       }
  1949.     fSelRect.bottom= rct.bottom; //????
  1950.      MapView2Doc( fSelRect); //?? need to get it working ??
  1951.   return rsult;
  1952. }
  1953.  
  1954.  
  1955.  
  1956.  
  1957. void DRichView::HiliteSelection(Boolean turnon)
  1958. {
  1959.     if (fSelected) {
  1960.         Nlm_RecT viewr, selr;
  1961.         
  1962.         selr= fSelRect;
  1963.         Boolean visible= MapDoc2View( selr);
  1964.         // !! must map sel location to current view (w/ sb) and see if it
  1965.         // is in view window !!
  1966.         
  1967.         if (!visible) 
  1968.             return;
  1969.         else {
  1970.                 // getting cases where this is called when this view's window is NOT front
  1971.             //DWindow* savewin=  gWindowManager->SavePort(this);
  1972.             if (fSelInPict) {
  1973.                 //Nlm_InvertRect( &selr);
  1974.                 Nlm_InvertMode();
  1975.                 Nlm_FrameRect( &selr);
  1976.                 Nlm_CopyMode();
  1977.                 }
  1978.             else {
  1979.                 ViewRect( viewr);
  1980.                 selr.left= viewr.left;
  1981.                 selr.right= viewr.right;
  1982.                 selr.top= MAX( viewr.top, selr.top - 20);  // expand inval area for full line
  1983.                 selr.bottom = MIN( viewr.bottom, selr.bottom ); 
  1984.                 InvalRect( selr); // let DrawStyledItem do work ?
  1985.                 Boolean savesel= fSelected;
  1986.                 fSelected= turnon;
  1987.                 Nlm_Update();  // this->Draw();
  1988.                 fSelected= savesel;
  1989.                 }
  1990.             //if (savewin) gWindowManager->RestorePort(savewin);
  1991.             }
  1992.         }
  1993. }
  1994.  
  1995. void DRichView::ClearSelection()
  1996. {
  1997.         //?? before unHilite to cure draw bug ??
  1998.     fSelParag= fSelChar= fSelEndParag= fSelEndChar= 0;
  1999.     HiliteSelection(false);
  2000.     //fSelParag= fSelChar= fSelEndParag= fSelEndChar= 0;
  2001.     fSelInPict= false;
  2002.     fSelected= false;
  2003. }
  2004.  
  2005.  
  2006. void DRichView::SetSelectedText( short startparag, short startchar, 
  2007.                                                                     short endparag, short endchar)
  2008. {
  2009.     ClearSelection(); // clear any old sel -- i.e., wipe view markings
  2010.     fSelInPict= false; //!! check if selrect is in a picture !!
  2011.     fSelParag    = Max(0, Min(startparag, fNumItems));      
  2012.     fSelChar    = Max(0, startchar);          // check max !? 
  2013.     
  2014.     fSelEndParag    = Max(0, Min(endparag, fNumItems));      
  2015.     // if endchar==0 endchar== maxchar ??
  2016.     fSelEndChar      = Max(0, endchar);     // check max !? 
  2017.     fSelected= (fSelParag > 0 || fSelChar > 0 || fSelEndChar > 0);
  2018.  
  2019.             // !! NEED THIS parag/char -> fSelRect mapper !!
  2020.     if (HiliteText( fSelParag, fSelChar, fSelEndParag, fSelEndChar, false) ) ;
  2021.  
  2022.     HiliteSelection(fSelected);
  2023. }
  2024.  
  2025. void DRichView::SelectAll()
  2026. {
  2027.     short                    itemNum, leadHeight, atline;
  2028.   Nlm_RecT            viewr, rct;
  2029.   DParagraph*      itemPtr;
  2030.     
  2031.     ClearSelection(); // clear any old sel -- i.e., wipe view markings
  2032.     ViewRect( viewr);
  2033.     Nlm_LoadRect( &rct, 0, 0, viewr.right - viewr.left, 0);
  2034.     atline = 0;
  2035.     leadHeight = 0; 
  2036.     itemNum = 0; //= GetItemNum( atline);
  2037.     while (itemNum < fNumItems) {
  2038.         itemPtr = GetParaPtr( itemNum);
  2039.       if (itemPtr) {
  2040.       CacheIfNever( itemNum + 1, itemPtr, &viewr); // this counts item->numRows
  2041.       if (atline>0) rct.bottom += itemPtr->spaceBefore; 
  2042.       rct.bottom += leadHeight  
  2043.                               + itemPtr->lineHeight * (itemPtr->numRows) 
  2044.                               + itemPtr->spaceAfter;
  2045.            leadHeight = itemPtr->leadHeight;
  2046.           atline += itemPtr->numRows;
  2047.             }
  2048.         itemNum++;
  2049.         }
  2050.  
  2051.     fSelRect= rct;  
  2052.     //MapView2Doc( fSelRect);
  2053.     fSelInPict= false; //!! check if selrect is in a picture !!
  2054.     fSelParag= 1;     // parag # are +1 from MapPoint !!
  2055.     fSelChar= 0;      
  2056.     fSelEndParag= fNumItems;         // parag # are +1 of item# from MapPoint !!
  2057.     fSelEndChar= 0;       
  2058.     fSelected= (fSelParag > 0 && fSelEndParag > 0);
  2059.     HiliteSelection(fSelected);
  2060. }
  2061.  
  2062.  
  2063. void DRichView::MarkSelection( Nlm_RecT selrect)
  2064. {
  2065.     Nlm_PoinT pt;
  2066.     short            row, parag;
  2067.     Nlm_RecT    arect;
  2068.     char            word[50];
  2069.     
  2070.     ClearSelection(); // clear any old sel -- i.e., wipe view markings
  2071.     fSelRect= selrect; // ?? don't we need to map selrect in view coords to doc coords !?
  2072.     MapView2Doc( fSelRect);
  2073.     fSelInPict= false; //!! check if selrect is in a picture !!
  2074.  
  2075.     pt.x= selrect.left;
  2076.     pt.y= selrect.top;
  2077.     MapPoint( pt, parag, row, &arect, word, 40, &fSelStyle);
  2078.     fSelParag= parag;     // parag # are +1 from MapPoint !!
  2079.     fSelChar= gMapOfs;     // dang global... fix mappoint to return it!
  2080.                         // fSelChar was correct
  2081.     if (fSelStyle.ispict) {
  2082.         fSelInPict= true;
  2083.             // ??? must make fSelRect relative to pict frame
  2084.         //fSelRect.left -= fDrawr.left;
  2085.         //fSelRect.right -= fDrawr.left;
  2086.         //fSelRect.top -= fDrawr.top;
  2087.         //fSelRect.bottom -= fDrawr.top;
  2088.         fSelEndParag= 0;
  2089.         fSelEndChar= 0;
  2090.         fSelected= (fSelParag > 0);
  2091.         }
  2092.     else {    
  2093.         pt.x= selrect.right;
  2094.         pt.y= selrect.bottom;
  2095.         MapPoint( pt, parag, row, &arect, word, 40, NULL);
  2096.         fSelEndParag= parag;         // parag # are +1 of item# from MapPoint !!
  2097.         fSelEndChar= gMapOfs;      // fSelEndChar is too large ???
  2098.         fSelected= (fSelParag > 0 && fSelEndParag > 0);
  2099.         }
  2100.     HiliteSelection(fSelected);
  2101. }
  2102.  
  2103.  
  2104. Boolean DRichView::GetSelection( Boolean& inpict,
  2105.                     short& selparag, short& selchar, 
  2106.                     short& selendparag, short& selendchar,
  2107.                     Nlm_RecT& selrect, DRichStyle* selstyle)
  2108. {
  2109.     inpict= fSelInPict;
  2110.     selparag= fSelParag - 1; // !!!!!! FIX DAMN +1 used above !!!!!!
  2111.     selchar= fSelChar;
  2112.     selendparag= fSelEndParag - 1; // !!!!!! FIX DAMN +1 used above !!!!!!
  2113.     selendchar= fSelEndChar;
  2114.     selrect= fSelRect; // !? must we map from doc coords to view coords ??
  2115.     if (selstyle) { *selstyle = fSelStyle; } //style at start of selection (for pict !?)
  2116.     return fSelected;
  2117. }
  2118.  
  2119. char* DRichView::GetSelectedText()
  2120. {
  2121.     long startp, endp, startc, endc;
  2122.     char* theText= NULL;
  2123.  
  2124.     if (fSelInPict) {
  2125.         return NULL; // for now, fix to copy pict to system clipboard
  2126.         }
  2127.         
  2128.     if (fSelParag) {
  2129.         // if selection == NULL ?? return all of text ????
  2130.         startp= fSelParag - 1; 
  2131.         endp= fSelEndParag - 1;
  2132.         startc= fSelChar;
  2133.         endc= fSelEndChar;
  2134.         }
  2135.     else {
  2136.         startp= 0; 
  2137.         endp= fNumItems-1;
  2138.         startc= 0;
  2139.         endc= 0;
  2140.         }
  2141.     
  2142.     for (short par= startp; par<= endp; par++) {
  2143.             // need to handle start/end chars ...
  2144.         DParagraph* itemPtr = GetParaPtr( par);
  2145.         if (itemPtr) {
  2146.             Boolean first= (par == startp);
  2147.             Boolean last = (par == endp);
  2148.             char  savec = 0;
  2149.             char* partext= (char*) itemPtr->fDataPtr;
  2150. #if 1
  2151.             if (first) partext += startc;
  2152.             if (last && endc) {
  2153.                 savec= partext[endc+1];
  2154.                 partext[endc+1]= 0;
  2155.                 }
  2156. #endif
  2157.             if (theText) StrExtendCat( &theText, partext);
  2158.             else theText= StrDup( partext);
  2159.             StrExtendCat( &theText, LINEEND); // append newline for each parag ?
  2160.             if (savec) partext[endc+1]= savec;
  2161.             }
  2162.         }
  2163.          
  2164.     return theText;
  2165. }
  2166.  
  2167.  
  2168.  
  2169. short DRichView::UpdateLineStarts(short first)
  2170. {
  2171.             //  Recalculates the first lines as a running sum of the number of rows
  2172.   short     i;
  2173.   DParagraph*  itemPtr;
  2174.   short     totalNumLines;
  2175.  
  2176.   totalNumLines = 0;
  2177.     itemPtr  = GetParaPtr( first);
  2178.   if (itemPtr) totalNumLines = itemPtr->startsAt;
  2179.   for (i = first; i < fNumItems; i++) {
  2180.     itemPtr = GetParaPtr( i);
  2181.     if (itemPtr) {
  2182.       itemPtr->startsAt = totalNumLines;
  2183.       totalNumLines += itemPtr->numRows;
  2184.         }
  2185.       }
  2186.   return totalNumLines;
  2187. }
  2188.  
  2189.  
  2190. void DRichView::CollectRange(short item, short& lowest, short& highest)
  2191. {
  2192.   lowest  = MIN(lowest, item);
  2193.   highest = MAX(highest, item);
  2194. }
  2195.  
  2196.  
  2197.  
  2198. void DRichView::CacheAndFormat(short item, DParagraph* itemPtr, Nlm_RectPtr r)
  2199. {
  2200.                 //  Formats text (for drawing) if the item text is not currently cached
  2201.   if (itemPtr && r && itemPtr->notCached) FormatText(item, itemPtr, TRUE);
  2202. }
  2203.  
  2204. void DRichView::CacheIfNever( short item, DParagraph* itemPtr, Nlm_RectPtr r)
  2205. {
  2206.         //     Formats text (for obtaining the correct number of rows) if the item
  2207.         //     text has never been cached
  2208.   if (itemPtr && r && itemPtr->neverCached) FormatText(item, itemPtr, TRUE);
  2209. }
  2210.  
  2211.  
  2212. void DRichView::FreeCachedItem( short item, short& lowest, short& highest)
  2213. {
  2214.         // Frees the formatted text string for an item that is not currently visible
  2215.   DParagraph*  itemPtr = GetParaPtr( item);
  2216.   if (itemPtr) {
  2217.     itemPtr->fText = (char*) MemFree (itemPtr->fText);
  2218.     itemPtr->notCached = TRUE;
  2219.     if (fIsVirtual && fNumItems > 0) {
  2220.       itemPtr->numRows = 30000 / fNumItems;
  2221.       CollectRange(item, lowest, highest);
  2222.         }
  2223.       }
  2224. }
  2225.  
  2226.  
  2227. short DRichView::VisLinesAbove(Nlm_RectPtr r, short item,
  2228.                            short line, short& lowest, short& highest)
  2229. {
  2230.         //    Returns the number of lines visible on the screen if the given line
  2231.         //    in the given item is the last line visible
  2232.   DParagraph*  itemPtr;
  2233.   short     pixels, vis;
  2234.  
  2235.   vis = 0;
  2236.   if ( r && item < fNumItems) {
  2237.     pixels = r->bottom - r->top;
  2238.     while (pixels > 0 && item >= 0) {
  2239.       itemPtr = GetParaPtr( item);
  2240.       if (itemPtr) {
  2241.         CollectRange( item, lowest, highest);
  2242.         CacheIfNever( item + 1, itemPtr, r);
  2243.         if (line < 0)  line = itemPtr->numRows - 1;
  2244.         while (pixels > 0 && line >= 0 && line < itemPtr->numRows) {
  2245.           pixels -= itemPtr->lineHeight;
  2246.           if (pixels >= 0)  vis++;
  2247.           line--;
  2248.             }
  2249.         pixels -= itemPtr->leadHeight;
  2250.         pixels -= itemPtr->spaceBefore + itemPtr->spaceAfter;
  2251.           }
  2252.       item--;
  2253.         }
  2254.       }
  2255.   return vis;
  2256. }
  2257.  
  2258.  
  2259.  
  2260. short DRichView::VisLinesBelow( Nlm_RectPtr r, short item,
  2261.                                        short line, short& lowest, short& highest)
  2262. {
  2263.         //    Returns the number of lines visible on the screen if the given line
  2264.         //    in the given item is the first line visible
  2265.   DParagraph*  itemPtr;
  2266.   short     pixels, vis;
  2267.  
  2268.   vis = 0;
  2269.   if (r && item < fNumItems && item >= 0) {
  2270.     pixels = r->bottom - r->top;
  2271.     while (pixels > 0 && item < fNumItems) {
  2272.       itemPtr = GetParaPtr( item);
  2273.       if (itemPtr) {
  2274.         CollectRange(item, lowest, highest);
  2275.         CacheIfNever(item + 1, itemPtr, r);
  2276.         if (line  < 0) {
  2277.           line = 0;
  2278.           pixels -= itemPtr->leadHeight;
  2279.             pixels -= itemPtr->spaceBefore + itemPtr->spaceAfter;
  2280.             }
  2281.         while (pixels > 0 && line >= 0 && line < itemPtr->numRows) {
  2282.           pixels -= itemPtr->lineHeight;
  2283.           if (pixels >= 0) vis++;
  2284.           line++;
  2285.             }
  2286.         line = -1;
  2287.           }
  2288.       item++;
  2289.         }
  2290.       }
  2291.   return vis;
  2292. }
  2293.  
  2294.  
  2295.  
  2296. short DRichView::PixelsBetween( Nlm_RectPtr r, short firstLine,
  2297.                            short lastLine, short& lowest, short& highest)
  2298. {
  2299.              //   Returns the number of pixels between two lines
  2300.      short     count;
  2301.   short     item;
  2302.   DParagraph*  itemPtr;
  2303.   short     line;
  2304.   short     numLines;
  2305.   short     onItem;
  2306.   short     pixels;
  2307.  
  2308.   pixels = 0;
  2309.   if ( r ) {
  2310.       // dgg -- are these line no.s off by one??  came from Scroll()
  2311.       // firstLine--; lastLine--;
  2312.     count = ABS (lastLine - firstLine);
  2313.     item = GetItemNum( MIN (firstLine, lastLine));
  2314.     itemPtr = GetParaPtr( item);
  2315.     onItem = item;
  2316.     if (itemPtr != NULL && item >= 0) {
  2317.       CollectRange( item, lowest, highest);
  2318.       CacheIfNever( item + 1, itemPtr, r);
  2319.       line = MIN (firstLine, lastLine) - itemPtr->startsAt;
  2320.       while (count > 0 && item < fNumItems) {
  2321.         if (item != onItem) {
  2322.           itemPtr = GetParaPtr( item);
  2323.           onItem = item;
  2324.             }
  2325.         if ( itemPtr ) {
  2326.           CollectRange (item, lowest, highest);
  2327.           CacheIfNever ( item + 1, itemPtr, r);
  2328.           numLines = itemPtr->numRows;
  2329. #if 1
  2330.                     if (line == 0) pixels += itemPtr->spaceBefore;
  2331.                     if (MAX(firstLine,lastLine) >= numLines + itemPtr->startsAt)
  2332.                         pixels += itemPtr->spaceAfter;
  2333. #else
  2334.         // ?? old here is bad -- don't do spaceBefore unless this is 1st line in parag
  2335.         // likewise spaceafter if this is last
  2336.                 pixels += itemPtr->spaceBefore + itemPtr->spaceAfter;  
  2337. #endif
  2338.           while (count > 0 && line >= 0 && line < numLines) {
  2339.             pixels += itemPtr->lineHeight;
  2340.             line++;
  2341.             count--;
  2342.               }
  2343.             }
  2344.         item++;
  2345.         if (line >= numLines) {
  2346.           itemPtr = GetParaPtr( item);
  2347.           onItem = item;
  2348.           if (itemPtr != NULL) {
  2349.             CollectRange (item, lowest, highest);
  2350.             CacheIfNever ( item + 1, itemPtr, r);
  2351.             pixels += itemPtr->leadHeight;
  2352.               }
  2353.             }
  2354.         line = 0;
  2355.           }
  2356.       if (lastLine < firstLine)  pixels = -pixels;
  2357.         }
  2358.       }
  2359.   return pixels;
  2360. }
  2361.  
  2362.  
  2363.  
  2364. void DRichView::Draw()
  2365. {
  2366.             //    Panel callback that traverses the item list and draws visible items
  2367.             //    Clipping is to the intersection of the Nlm_updateRgn (the portion of the
  2368.             //    panel exposed) and the inset area of the document, leaving a four-
  2369.             //    pixel margin
  2370.  
  2371.   Nlm_RegioN   dst;
  2372.   DParagraph*  itemPtr;
  2373.   short          firstLine, highest, item, lowest, off, pixels;
  2374.   Nlm_RecT     r, rct;
  2375.   Nlm_BaR      sb;
  2376.   Nlm_RegioN   src;
  2377.  
  2378.   if (fNumItems > 0) {
  2379. //Debug("DRichView::Draw\n");
  2380.         ViewRect( r);
  2381.     sb = Nlm_GetSlateVScrollBar((Nlm_SlatE) fPanel);
  2382.         if (sb) off = Nlm_GetValue(sb);
  2383.         else off= 0;
  2384.     src = Nlm_CreateRgn ();
  2385.     dst = Nlm_CreateRgn ();
  2386.     Nlm_LoadRectRgn (src, r.left, r.top, r.right, r.bottom);
  2387.     Nlm_SectRgn (src, Nlm_updateRgn, dst);
  2388.     Nlm_ClipRgn (dst);
  2389.     Nlm_DestroyRgn (src);
  2390.     Nlm_DestroyRgn (dst);
  2391.     pixels = 0;
  2392.     lowest = INT2_MAX;
  2393.     highest = INT2_MIN;
  2394.     item = GetItemNum( off);
  2395.     itemPtr = GetParaPtr( item);
  2396.     if (itemPtr) {
  2397.       firstLine = off - itemPtr->startsAt;
  2398.       do {
  2399.         if (itemPtr) {
  2400.           if (itemPtr->neverCached)  CollectRange(item, lowest, highest);
  2401.           CacheAndFormat( item+1, itemPtr, &r);
  2402.           if (pixels != 0)  r.top += itemPtr->leadHeight;
  2403.                   if (firstLine == 0) r.top += itemPtr->spaceBefore;
  2404.           rct = r;
  2405.           rct.bottom = rct.top + itemPtr->lineHeight * (itemPtr->numRows - firstLine);
  2406.           Boolean inrgn= (Nlm_updateRgn == NULL || Nlm_RectInRgn (&rct, Nlm_updateRgn));
  2407.           if (inrgn) {
  2408. //Debug(".");
  2409.             pixels = DrawStyledItem( itemPtr, &r, item+1, firstLine, FALSE, NULL);
  2410.               } 
  2411.           else  
  2412.             pixels = rct.bottom - rct.top;
  2413.            
  2414.           r.top += pixels;
  2415.                   r.top += itemPtr->spaceAfter;
  2416.             }
  2417.         item++;
  2418.         firstLine = 0;
  2419.         itemPtr = GetParaPtr( item);
  2420.       } while (r.top < r.bottom && item < fNumItems);
  2421.       if (lowest < INT2_MAX) 
  2422.         fNumLines = UpdateLineStarts( lowest);
  2423.      
  2424.     }
  2425.     Nlm_ResetClip ();
  2426.      
  2427.   }
  2428.     Nlm_SelectFont(Nlm_programFont);  //Nlm_systemFont
  2429. //Debug("DRichView::Draw done\n");
  2430. }
  2431.  
  2432.  
  2433.  
  2434.  
  2435.  
  2436.  
  2437.  
  2438.  
  2439. void  DRichView::AdjustScroll() 
  2440. {
  2441.             // Calculates an estimate for the scroll bar maximum
  2442.   short     barmax,barval,firstShown,highest, item;
  2443.   short     line,lineInto,lowest;
  2444.   short     pgDn, pgUp, vis;
  2445.   DParagraph*  itemPtr;
  2446.   Nlm_RecT     r;
  2447.   Nlm_BaR      sb;
  2448.  
  2449.   sb = Nlm_GetSlateVScrollBar((Nlm_SlatE) fPanel);
  2450.   if (sb) {
  2451.     if (fNumLines > 0 && fNumItems > 0) {
  2452.           Nlm_SelectFont(Nlm_programFont);  //Nlm_systemFont
  2453.             ViewRect( r);
  2454.       barval = Nlm_GetValue (sb);
  2455.       item = GetItemNum ( barval);
  2456.       line = barval - GetLineStart( item);
  2457.       firstShown = item;
  2458.       lineInto = line;
  2459.       lowest = INT2_MAX;
  2460.       highest = INT2_MIN;
  2461.       itemPtr = GetParaPtr(fNumItems - 1);
  2462.       if (itemPtr) 
  2463.         vis = VisLinesAbove ( &r, fNumItems - 1,
  2464.                              itemPtr->numRows - 1, lowest, highest);
  2465.       pgUp = VisLinesAbove ( &r, item, line, lowest, highest) - 1;
  2466.       pgDn = VisLinesBelow ( &r, item, line, lowest, highest) - 1;
  2467.       if (pgDn < 1) pgDn = 1;
  2468.       if (pgUp < 1) pgUp = 1;
  2469.       if (lowest < INT2_MAX) 
  2470.         fNumLines = UpdateLineStarts( lowest);
  2471.       
  2472.       itemPtr = GetParaPtr(fNumItems - 1);
  2473.       if (itemPtr) {
  2474.         barmax = 0;
  2475.               ViewRect( r);
  2476.         lowest = INT2_MAX;
  2477.         highest = INT2_MIN;
  2478.         vis = VisLinesAbove ( &r, fNumItems - 1,
  2479.                              itemPtr->numRows - 1, lowest,  highest);
  2480.         if (lowest < INT2_MAX) 
  2481.           fNumLines = UpdateLineStarts ( lowest);
  2482.          
  2483.         barmax = fNumLines - vis;
  2484.         barval = GetLineStart(firstShown) + lineInto;
  2485.         Nlm_CorrectBarPage (sb, pgUp, pgDn);
  2486.         if (barval > fBarmax) {
  2487.           Nlm_CorrectBarMax (sb, barmax);
  2488.           Nlm_CorrectBarValue (sb, barval);
  2489.             } 
  2490.         else {
  2491.           Nlm_CorrectBarValue (sb, barval);
  2492.           Nlm_CorrectBarMax (sb, barmax);
  2493.             }
  2494.         fBarmax = barmax;
  2495.           }
  2496.         } 
  2497.     else  
  2498.       Nlm_Reset (sb);
  2499.       }
  2500. }
  2501.  
  2502.  
  2503.  
  2504.  
  2505.  
  2506.  
  2507. void  DRichView::UpdateItemHeights(DParagraph* aParag)
  2508. {
  2509.             // Returns the maximum height of all fonts used in an item
  2510.   short         i, linhgt,maxhgt;
  2511.  
  2512.   if (aParag) {
  2513.     maxhgt = 0;
  2514.     i = aParag->fNumStyles;
  2515.     while (i > 0) {
  2516.       i--;
  2517.       DRichStyle* st= GetStyleAtIndex(aParag, i);
  2518.       if (st->ispict) 
  2519.                  linhgt = st->pixheight + 4; // add a few pixels for leading !?
  2520.       else  
  2521.           linhgt = GetFontHeight(st->font) + abs(st->superSub); 
  2522.       if (linhgt > maxhgt) maxhgt = linhgt;
  2523.         }
  2524.     if (maxhgt == 0)  maxhgt = Nlm_stdLineHeight;
  2525.     aParag->lineHeight = MAX(maxhgt, aParag->minHeight);
  2526.     if ( aParag->openSpace)  
  2527.       aParag->leadHeight = maxhgt;
  2528.     else 
  2529.       aParag->leadHeight = 0;
  2530.       }
  2531. }
  2532.  
  2533.  
  2534. short DRichView::SkipPastNewLine(char* text, short cnt)
  2535. {
  2536.   char  ch;
  2537.   ch = *(text + cnt);
  2538.   while (ch != '\0' && ch != '\n' && cnt < 16380) {
  2539.     cnt++;
  2540.     ch = *(text + cnt);
  2541.       }
  2542.   while ((ch == '\n' || ch == '\r') && cnt < 16380) {
  2543.     cnt++;
  2544.     ch = *(text + cnt);
  2545.       }
  2546.   return cnt;
  2547. }
  2548.  
  2549. void     DRichView::HandleAddInsRep( handleMode mode, short item, char* text, 
  2550.                     DParagraph* parFormat, DRichStyle* styles, short nstyles, Nlm_FonT aFont) 
  2551. {
  2552.     DRichStyle    * aStyle = NULL;
  2553.   DParagraph     * para = NULL;
  2554.     
  2555.     if (!parFormat) {
  2556.         para= new DParagraph();
  2557.         parFormat= para;
  2558.         }
  2559.     
  2560.     if (!styles) {
  2561.         aStyle= new DRichStyle();
  2562.         if (aFont) aStyle->font= aFont;
  2563.         aStyle->last= true;
  2564.         styles= aStyle;
  2565.         nstyles= 1;
  2566.         }
  2567.         
  2568.     if (text && *text != '\0') {
  2569.       long start = 0;
  2570.       short atstyle= 0;
  2571.       long cntr = StringLen (text);
  2572.       long cnt = MIN (cntr, 16000);
  2573.       cnt = SkipPastNewLine (text + start, cnt);
  2574.       while (cnt > 0) {
  2575.         char* txt = (char*) MemNew(cnt + 1);
  2576.         MemCopy(txt, text + start, cnt);
  2577.         
  2578.         // damn !!! have to fiddle w/ styles[...].nextofs for this newline cutting stuff !!
  2579.         short ist= atstyle, nst= 0;
  2580.         if (nstyles) {
  2581.             do ist++; 
  2582.             while (ist<nstyles && styles[ist].nextofs <= start + cnt);
  2583.             nst= ist - atstyle;     
  2584.             }
  2585.             
  2586.         switch (mode) {
  2587.             case kAppend: 
  2588.                 Append( txt, (cnt / 50) + 1, parFormat, &styles[atstyle], nst, true);
  2589.                 break;
  2590.             case kReplace:
  2591.                     Replace( item, txt, (cnt / 50) + 1, parFormat, &styles[atstyle], nst, true);
  2592.                 break;
  2593.             case kInsert:
  2594.                     Insert( item, txt, (cnt / 50) + 1, parFormat, &styles[atstyle], nst, true);
  2595.                 break;
  2596.             }
  2597.             
  2598.         atstyle += nst - 1;
  2599.         start += cnt;
  2600.         cntr -= cnt;
  2601.         cnt = MIN (cntr, 16000);
  2602.         cnt = SkipPastNewLine (text + start, cnt);
  2603.           }
  2604.         } 
  2605.     else switch (mode) {
  2606.       case kAppend: 
  2607.             Append( "", 1, parFormat, styles, nstyles, false);
  2608.           break;
  2609.       case kReplace:
  2610.             Replace( item, "", 1, parFormat, styles, nstyles, false);
  2611.           break;
  2612.         case kInsert:
  2613.             Insert( item, "", 1, parFormat, styles, nstyles, false);
  2614.           break;
  2615.       }
  2616.       
  2617.   if (para) delete para;
  2618.   //if (aStyle) delete aStyle;
  2619. }
  2620.  
  2621.  
  2622. void     DRichView::Append( char* text, DParagraph* parFormat, DRichStyle* styles, 
  2623.                     short nstyles, Nlm_FonT aFont) 
  2624. {
  2625.     HandleAddInsRep( kAppend, 0,  text, parFormat, styles, nstyles, aFont);
  2626. }
  2627.  
  2628. void     DRichView::Replace( short item, char* text, DParagraph* parFormat, 
  2629.                                 DRichStyle* styles, short nstyles, Nlm_FonT aFont) 
  2630. {
  2631.     HandleAddInsRep( kReplace, item, text, parFormat, styles, nstyles, aFont);
  2632. }
  2633.  
  2634. void     DRichView::Insert( short item, char* text, DParagraph* parFormat,
  2635.              DRichStyle* styles, short nstyles, Nlm_FonT aFont) 
  2636. {
  2637.     HandleAddInsRep( kInsert, item, text, parFormat, styles, nstyles, aFont);
  2638. }
  2639.  
  2640.  
  2641.  
  2642. void  DRichView::Delete( short item) 
  2643. {
  2644.                 //  Deletes an item from a document
  2645.   if (item >= 0 && item < fNumItems) {
  2646.         fParags->AtDelete(item);
  2647.     fNumItems = fParags->GetSize(); 
  2648.     fNumLines = UpdateLineStarts( item);
  2649.     if (fAutoAdjust) AdjustScroll();
  2650.     }
  2651. }
  2652.  
  2653.  
  2654. void  DRichView::GetDocStats( short& numParags, short& numLines) 
  2655. {
  2656.   numParags = fNumItems;
  2657.   numLines = fNumLines;  
  2658. }
  2659.  
  2660.  
  2661.  
  2662. void  DRichView::GetItemStats( short item, short& startsAt, short& numRows, 
  2663.                                                              short& lineHeight) 
  2664. {
  2665.     DParagraph* itemPtr = GetParaPtr( item );  // item starts at 0
  2666.   if (itemPtr) {
  2667.     startsAt = itemPtr->startsAt;
  2668.     numRows = itemPtr->numRows;
  2669.     lineHeight = itemPtr->lineHeight;
  2670.       }
  2671.   else {
  2672.       startsAt = 0;
  2673.       numRows = 0;
  2674.       lineHeight = 0;  
  2675.       }
  2676. }
  2677.  
  2678.  
  2679.  
  2680.  
  2681.  
  2682. void     DRichView::MapPoint( Nlm_PoinT pt, short& item, short& row, Nlm_RectPtr rct,
  2683.                     char* wordAt, short maxword, DRichStyle* styleAt) 
  2684. {
  2685.                 // Converts a mouse point to a item, row positions  within a document
  2686.   short     cl,firstItem,firstLine;
  2687.   short     itemNum,rw,itm,leadHeight,lineHeight,numRows,off;
  2688.   Boolean      goOn;
  2689.   Nlm_RecT     viewr, paragr, rc;
  2690.   Nlm_BaR      sb;
  2691.   DParagraph*  itemPtr;
  2692.  
  2693.   itm = 0;
  2694.   rw = 0;
  2695.   cl = 0;
  2696.   Nlm_LoadRect (&rc, 0, 0, 0, 0);
  2697.  
  2698.     ViewRect( viewr);
  2699.   if (Nlm_PtInRect (pt, &viewr)) {
  2700.     sb = Nlm_GetSlateVScrollBar ((Nlm_SlatE) fPanel);
  2701.         if (sb) off = Nlm_GetValue(sb);
  2702.         else off= 0;
  2703.     goOn = TRUE;
  2704.     itemNum = GetItemNum( off);
  2705.     itemPtr = GetParaPtr( itemNum);
  2706.     if (itemPtr) {
  2707.             paragr= viewr;
  2708.       firstLine = off - itemPtr->startsAt;
  2709.       firstItem = itemNum;
  2710.       while (goOn && itemNum < fNumItems) {
  2711.         itemPtr = GetParaPtr( itemNum);
  2712.         if (itemPtr) {
  2713.           CacheIfNever( itemNum + 1, itemPtr, ¶gr);
  2714.           if (itemNum > firstItem)  
  2715.             leadHeight = itemPtr->leadHeight;
  2716.             else 
  2717.             leadHeight = 0;
  2718.           if (firstLine==0) paragr.top += itemPtr->spaceBefore;
  2719.        
  2720.           lineHeight = itemPtr->lineHeight;
  2721.           numRows = MIN (itemPtr->numRows - firstLine,
  2722.                          MAX ((viewr.bottom - paragr.top - leadHeight) / lineHeight, 1));
  2723.           paragr.bottom = paragr.top + leadHeight + lineHeight * numRows;
  2724.                paragr.bottom += itemPtr->spaceAfter;
  2725.                
  2726.              if (Nlm_PtInRect(pt, ¶gr) && numRows > 0) {
  2727.             goOn = FALSE;
  2728.             itm = itemNum + 1;
  2729.             if (pt.y <= paragr.top + leadHeight)  
  2730.               rw = 0;
  2731.             else  
  2732.               rw = firstLine + ((pt.y - paragr.top - leadHeight) / lineHeight) + 1;
  2733.  
  2734.               rc = paragr;
  2735.               if (rw) rc.top += (rw-1) * lineHeight;
  2736.               rc.bottom = rc.top + lineHeight;
  2737.               
  2738.             // dgg -- map to style section                 
  2739.             if (wordAt || styleAt) {
  2740.                       short textofs = DrawStyledItem( itemPtr, ¶gr, itm/*itemNum+1*/, 
  2741.                                                   firstLine/*rw*/, FALSE, &pt);
  2742.                             if (wordAt) {
  2743.                                 if (textofs<0) {
  2744.                                     StrNCpy(wordAt, "**not found", maxword);
  2745.                          wordAt[maxword-1]= 0;
  2746.                                     }
  2747.                                 else {
  2748.                                     char *cbase= itemPtr->fText;
  2749.                                     char *cstart= cbase + textofs;
  2750.                                     if (*cstart <= ' ') {
  2751.                                         if (cstart[1] > ' ') cstart++;
  2752.                                         else if (cstart[-1] > ' ') cstart--;
  2753.                                         }
  2754.                                     char *cend= cstart;
  2755.                        while (cstart > cbase && cstart[-1] > ' ') cstart--;
  2756.                           while (*cend > ' ') cend++;
  2757.                        short len= MAX(1, MIN( maxword-1, cend - cstart));
  2758.                          StrNCpy(wordAt, cstart, len);
  2759.                          wordAt[len]= 0;
  2760.                          }
  2761.                        }
  2762.               if (styleAt && fMapStyle) {
  2763.                   *styleAt= *fMapStyle; // GetStyleAtChar( itemPtr, textofs);
  2764.                   }
  2765.                    }
  2766.                    
  2767.               } 
  2768.           else  
  2769.             paragr.top = paragr.bottom;
  2770.            
  2771.           if (numRows < itemPtr->numRows - firstLine)  
  2772.             goOn = FALSE;
  2773.             }
  2774.         itemNum++;
  2775.         firstLine = 0;
  2776.         }
  2777.       }
  2778.     }
  2779.  
  2780.     item = itm;
  2781.     row = rw;
  2782.     if (rct) *rct = rc;
  2783. }
  2784.  
  2785.  
  2786.  
  2787.  
  2788. Boolean DRichView::Find( char* match, short& itemat, short& charat,
  2789.                             short startitem, short startchar, Boolean caseSensitive) 
  2790. {
  2791.   DParagraph*        itemPtr;
  2792.   short            i, stop;
  2793.     
  2794.   if (match) {
  2795.         char* tempmatch= StrDup( match);
  2796.     if (fNumItems > 0) {
  2797.           stop = fNumItems;
  2798.         if (startitem < 0) startitem = 0;
  2799.         for (i = startitem; i < stop; i++) {
  2800.           itemPtr = GetParaPtr( i);
  2801.           if (itemPtr) {
  2802.                          char* text;
  2803.                         text= (char*) itemPtr->fDataPtr;
  2804.             if (text) {
  2805.                             Nlm_Uint4        foundat;
  2806.                             Boolean         found 
  2807.                                     = Nlm_StrngPos(text, tempmatch, startchar, caseSensitive, &foundat);
  2808.               if (found) {
  2809.                   itemat= i;
  2810.                     charat= foundat;
  2811.                                 MemFree( tempmatch);
  2812.                   return TRUE;
  2813.                   }      
  2814.                   }
  2815.               }
  2816.           startchar= 0; // ! zero it !! or we miss others ! 
  2817.           }
  2818.                 }
  2819.         MemFree( tempmatch);
  2820.         }
  2821.     return FALSE;
  2822. }
  2823.  
  2824.  
  2825.  
  2826.  
  2827. Boolean     DRichView::FindURL(short& itemat, short& charat, short& charlen,
  2828.                                                         short startitem, short startchar) 
  2829. {
  2830.   DParagraph*     itemPtr;
  2831.   short            i, stop;
  2832.     
  2833.     if (fNumItems > 0) {
  2834.       stop = fNumItems;
  2835.     if (startitem < 0) startitem = 0;
  2836.     for (i = startitem; i < stop; i++) {
  2837.       itemPtr = GetParaPtr( i);
  2838.       if (itemPtr) {
  2839.                 char* text;
  2840.                 // text= (char*) itemPtr->fDataPtr; << this is bad, need fText !
  2841.                 FormatText( i, itemPtr, TRUE);
  2842.                 text = itemPtr->fText;
  2843.           if (text) {
  2844.                     char             *cp, *ep;
  2845.  
  2846.                     for (cp= text+startchar+3; *cp; cp++) { 
  2847.                         if (*cp == ':') {
  2848.                             if ( (cp[1] == '/' && cp[2] == '/') 
  2849.                                 || (0 == Nlm_StringNICmp( MAX(text, cp-6), "mailto", 6))
  2850.                                 || (0 == Nlm_StringNICmp( MAX(text, cp-4), "news", 4))
  2851.                                 /* ^^^^ Should use DURL::IsURL(cp) !! */
  2852.                                 ) {
  2853.                                   cp--;
  2854.                                     while (isalnum(*cp) && cp>text) cp--;
  2855.                                     if (*cp == '"') ep= strchr(cp+1,'"');
  2856.                                     else if (*cp == '\'') ep= strchr(cp+1,'\'');
  2857.                                     else if (*cp == '<') ep= strchr(cp+1,'>');
  2858.                                     else if (*cp == '=' 
  2859.                                         && 0 == Nlm_StringNICmp( MAX(text,cp-4), "href=", 4 )) 
  2860.                                             ep= strchr(cp+1,'>');
  2861.                                     else ep= NULL;
  2862.                                     if (!isalnum(*cp)) cp++;
  2863.                                   if (ep == NULL) for (ep=cp; isgraph(*ep); ep++) ;
  2864.                       itemat= i;
  2865.                       charat= cp - text;
  2866.                                     charlen= ep ? ep - cp : 0;
  2867.                       return TRUE;
  2868.                       }
  2869.                             } 
  2870.                         }     
  2871.               }
  2872.           }
  2873.       startchar= 0; // ! zero it !! or we miss others ! 
  2874.       }
  2875.         }
  2876.  
  2877.     return FALSE;
  2878. }
  2879.  
  2880.  
  2881.  
  2882.  
  2883.  
  2884. void     DRichView::InsertStyle( short atitem, short atchar, short atlength, 
  2885.                                                             DRichStyle* theStyle)
  2886. {
  2887.   DParagraph*     itemPtr;
  2888.     short                    numStyles;
  2889.     
  2890.     itemPtr = GetParaPtr( atitem);
  2891.   if (theStyle && itemPtr) {
  2892.         short ist, jst;
  2893.         numStyles= itemPtr->fNumStyles;
  2894.         StyleIndex* si = itemPtr->fStyleIndex;
  2895.         short newofs= atchar + atlength;
  2896.         short newnum= numStyles + 2;
  2897.         StyleIndex* sinew=    
  2898.             (StyleIndex*) MemNew( newnum*sizeof(StyleIndex)); 
  2899.  
  2900.         short styleid= FindOrAddStyle(theStyle);
  2901.         Boolean notat= true, notnew= true;
  2902.         for (ist=0, jst= 0; ist<numStyles && jst<newnum; ist++) {
  2903.             short ofs= si[ist].nextofs;
  2904.             
  2905.             if (atchar <= ofs && notat) {
  2906.                 if (atchar < ofs) {
  2907.                     sinew[jst]= si[ist];
  2908.                     sinew[jst].nextofs= atchar;
  2909.                     if (jst<newnum) jst++;
  2910.                     }
  2911.                 else {
  2912.                     sinew[jst]= si[ist];
  2913.                     if (jst<newnum) jst++;
  2914.                     }
  2915.                 sinew[jst].nextofs= newofs;
  2916.                 sinew[jst].styleid= styleid;
  2917.                 if (jst<newnum) jst++;
  2918.                 notat= false;
  2919.                 }
  2920.             else {  // atchar > ofs
  2921.                 sinew[jst]= si[ist];
  2922.                 if (jst<newnum) jst++;
  2923.                 }
  2924.             
  2925.             if (newofs <= ofs && notnew) {
  2926.                 sinew[jst]= si[ist];
  2927.                 if (jst<newnum) jst++;
  2928.                 notnew= false;
  2929.                 }
  2930.             }
  2931.             
  2932.         itemPtr->fStyleIndex= sinew;
  2933.         itemPtr->fNumStyles = jst; // newnum
  2934.         MemFree( si);
  2935.         
  2936.         
  2937.       }
  2938.      
  2939. }
  2940.  
  2941.  
  2942.  
  2943.  
  2944.  
  2945.  
  2946.  
  2947. char* DRichView::GetText(short item, short row) 
  2948. {
  2949.             //   Returns a string with text from a document.  If item, row
  2950.             //   parameters are 0, text is taken from any item, row,
  2951.             //   respectively.  The string must be freed by the application
  2952.   ByteStorePtr      bsp;
  2953.   char              ch;
  2954.   short              cl, i;
  2955.   short              k, num;
  2956.   short              rw, start, stop;
  2957.   char                    * text;
  2958.   char                    * ptr;
  2959.   Nlm_RecT            r;
  2960.   DParagraph*        itemPtr;
  2961.  
  2962.   text = NULL;
  2963.   if (item >= 0) {
  2964.         ViewRect( r);
  2965.     if (fNumItems > 0) {
  2966.       bsp = BSNew (0);
  2967.       if (bsp != NULL) {
  2968.         if (item == 0) {
  2969.           start = 0;
  2970.           stop = fNumItems;
  2971.             } 
  2972.         else if (item <= fNumItems) {
  2973.           start = item - 1;
  2974.           stop = item;
  2975.             } 
  2976.         else {
  2977.           start = 0;
  2978.           stop = 0;
  2979.             }
  2980.  
  2981. #if 1
  2982.             if (row < 0) {
  2983.         itemPtr = GetParaPtr( start);
  2984.         if (itemPtr) {
  2985.                     text= (char*) itemPtr->fDataPtr;
  2986.                       // if (text) text= MemDup(text);   //!? caller expects to own this data !? 
  2987.                     }
  2988.                 return text;
  2989.                 }
  2990. #else
  2991.             if (row < 0) {
  2992.         for (i = start; i < stop; i++) {
  2993.           itemPtr = GetParaPtr( i);
  2994.           if (itemPtr) {
  2995.                       if (!text) text = DataToChar(itemPtr->fDataPtr);
  2996.                         }
  2997.                     }
  2998.                   return text;
  2999.                 }
  3000. #endif
  3001.  
  3002.         for (i = start; i < stop; i++) {
  3003.           itemPtr = GetParaPtr( i);
  3004.           if (itemPtr) {
  3005.                         DParagraph itemData( itemPtr->fDataPtr, false, itemPtr->numRows, itemPtr, 
  3006.                                                 itemPtr->fStyleIndex, itemPtr->fNumStyles, false);
  3007.             FormatText(i, &itemData, TRUE);
  3008.             text = itemData.fText;
  3009.             if (text && *text != '\0') {
  3010.               if (i > start && itemPtr->openSpace > 0 && item == 0) 
  3011.                 BSPutByte (bsp, (short) '\n');
  3012.               rw = 0;
  3013.               cl = 0;
  3014.               ptr = text;
  3015.               ch = *ptr;
  3016.               while (ch != '\0') {
  3017.                 if (ch == '\n') {
  3018.                   if ((rw + 1 == row) || row == 0)  
  3019.                     BSPutByte (bsp, (short) '\n');
  3020.                   cl = 0;
  3021.                   rw++;
  3022.                   ptr++;
  3023.                     } 
  3024.                 else if (ch == '\t') {
  3025.                   if ((rw + 1 == row || row == 0)) 
  3026.                     BSPutByte (bsp, (short) '\t');
  3027.                    
  3028.                   cl++;
  3029.                   ptr++;
  3030.                     } 
  3031.                 else {
  3032.                   num = 0;
  3033.                   while (ch != '\0' && ch != '\t' && ch != '\n') {
  3034.                     num++;
  3035.                     ch = ptr [num];
  3036.                       }
  3037.                   if (num > 0  &&
  3038.                       (rw + 1 == row || row == 0)) {
  3039.                     for (k = 0; k < num; k++) 
  3040.                       BSPutByte (bsp, (short) ptr [k]);
  3041.                     }
  3042.                   ptr += num;
  3043.                     }
  3044.                 ch = *ptr;
  3045.                   }
  3046.                 }
  3047.               }
  3048.             }
  3049.         text = (char*) BSMerge (bsp, NULL);
  3050.         BSFree (bsp);
  3051.           }
  3052.         }
  3053.       }
  3054.   return text;
  3055. }
  3056.  
  3057.  
  3058.  
  3059.  
  3060.  
  3061. Boolean    DRichView::IsVisible( short item, short& top, short& bottom, short& firstline) 
  3062. {
  3063.             // Finds the visible region of an item in a document
  3064.   short             firstItem, fstLine, itemNum, leadHeight,lineHeight, numRows,off;
  3065.   Nlm_RecT         r, rct;
  3066.   Boolean              goOn, rsult;
  3067.   Nlm_BaR          sb;
  3068.   DParagraph*      itemPtr;
  3069.  
  3070.   rsult = FALSE;
  3071.      top = 0;
  3072.      bottom = 0;
  3073.   firstline = 0;
  3074.  
  3075.     ViewRect(  r);
  3076.   sb = Nlm_GetSlateVScrollBar ((Nlm_SlatE) fPanel);
  3077.   if (sb) off = Nlm_GetValue (sb);
  3078.   else off= 0;
  3079.   if (item > 0 && item <= fNumItems) {
  3080.     item--;
  3081.     goOn = TRUE;
  3082.     Nlm_LoadRect (&rct, r.left, r.top, r.right, r.top);
  3083.     itemNum = GetItemNum ( off);
  3084.     itemPtr = GetParaPtr( itemNum);
  3085.     if (itemPtr) {
  3086.       fstLine = off - itemPtr->startsAt;
  3087.       firstItem = itemNum;
  3088.       lineHeight = 0;
  3089.       leadHeight = 0;
  3090.       numRows = 0;
  3091.       while (goOn && itemNum < fNumItems && itemNum <= item) {
  3092.         itemPtr = GetParaPtr( itemNum);
  3093.         if (itemPtr ) {
  3094.           CacheIfNever ( itemNum + 1, itemPtr, &r);
  3095.           if (itemNum > firstItem)  
  3096.             leadHeight = itemPtr->leadHeight;
  3097.             else  
  3098.             leadHeight = 0;
  3099.               if (fstLine==0) rct.top += itemPtr->spaceBefore;
  3100.           
  3101.           lineHeight = itemPtr->lineHeight;
  3102.           rct.top += leadHeight;
  3103.           numRows = MIN (itemPtr->numRows,
  3104.                          MAX ((r.bottom - rct.top) / lineHeight, 0));
  3105.           rct.bottom = rct.top + lineHeight * (numRows - fstLine);
  3106.               rct.bottom += itemPtr->spaceAfter;
  3107.           if (itemNum == item) {
  3108.             goOn = FALSE;
  3109.             if (numRows > 0) {
  3110.                 top = rct.top;
  3111.                 bottom = rct.bottom;
  3112.                 firstline = fstLine;
  3113.               rsult = TRUE;
  3114.                 }
  3115.               } 
  3116.           else  
  3117.             rct.top = rct.bottom;
  3118.           if (numRows < itemPtr->numRows)  
  3119.             goOn = FALSE;
  3120.             }
  3121.         itemNum++;
  3122.         fstLine = 0;
  3123.           }
  3124.         }
  3125.       }
  3126.   
  3127.   return rsult;
  3128. }
  3129.  
  3130.  
  3131.  
  3132.  
  3133.  
  3134. Boolean DRichView::GetScrollStats( short& offset, short& firstShown, short& firstLine) 
  3135. {
  3136.   short     item, line,off;
  3137.   Boolean      rsult;
  3138.   Nlm_BaR        sb;
  3139.  
  3140.   sb = Nlm_GetSlateVScrollBar((Nlm_SlatE)fPanel);
  3141.   if (sb) {
  3142.     off = Nlm_GetValue (sb);
  3143.     item = GetItemNum ( off);
  3144.     line = off - GetLineStart(item);
  3145.     rsult = TRUE;
  3146.       }
  3147.   else {
  3148.       off = 0;
  3149.       item = 0;
  3150.       line = 0;  
  3151.       rsult = FALSE;
  3152.       }
  3153.   offset = off;
  3154.   firstShown = item + 1;
  3155.   firstLine = line;
  3156.   return rsult;
  3157. }
  3158.  
  3159.  
  3160.  
  3161.  
  3162.  
  3163.  
  3164. void  DRichView::Update( short from, short to) 
  3165. {
  3166.             // Invalidates and updates items in a document
  3167.   short         bottom,item,start,stop,swap,top, f1;
  3168.   DParagraph*  itemPtr;
  3169.   Nlm_RecT     r;
  3170.   Nlm_WindoW   tempPort;
  3171.  
  3172.   if (from >= 0 && to >= 0) {
  3173.     if (from == 0 || from > fNumItems) {
  3174.       start = 0;
  3175.       from = 0;
  3176.         } 
  3177.     else  
  3178.       start = from - 1;
  3179.      
  3180.     if (to == 0 || to > fNumItems) 
  3181.       stop = to = fNumItems;
  3182.     else  
  3183.       stop = to;
  3184.     
  3185.     for (item = start; item < stop; item++) {
  3186.       itemPtr = GetParaPtr(item);
  3187.       if (itemPtr) {
  3188.         itemPtr->fText = (char*) MemFree (itemPtr->fText);
  3189.         itemPtr->notCached = TRUE;
  3190.         itemPtr->neverCached = TRUE;
  3191.           }
  3192.         }
  3193.     if (Nlm_Enabled(fPanel) && Nlm_AllParentsEnabled(fPanel) &&
  3194.         Nlm_Visible(fPanel) && Nlm_AllParentsVisible(fPanel)) {
  3195.       tempPort = Nlm_SavePort(fPanel);
  3196.             ViewRect( r);
  3197.       Nlm_Select(fPanel);
  3198.       if (from > to && from != 0 && to != fNumItems) {
  3199.         swap = from;
  3200.         from = to;
  3201.         to = swap;
  3202.           }
  3203.       if (from > 0 && from <= fNumItems && IsVisible( from, top, bottom, f1))  
  3204.         r.top = top;
  3205.       if (to > 0 && to < fNumItems && IsVisible( to, top, bottom, f1))  
  3206.         r.bottom = bottom;
  3207.       Nlm_InsetRect(&r, -1, -1);
  3208.       Nlm_InvalRect(&r);
  3209.       if (tempPort) Nlm_RestorePort(tempPort);
  3210.         }
  3211.     AdjustScroll();
  3212.       }
  3213. }
  3214.  
  3215.  
  3216.  
  3217. void DRichView::SaveTableItem(DParagraph* itemPtr, FILE *f, Boolean tabStops)
  3218. {
  3219.                 //    Reformats and saves an item to a file
  3220.   char         ch;
  3221.   short     i;
  3222.   short     next,num,pos,row;
  3223.   char    *     ptr;
  3224.   char    *        text;
  3225.  
  3226.   next= 0;
  3227.   if (itemPtr && f) {
  3228.     text = itemPtr->fText;
  3229.     if (text && *text != '\0') {
  3230.       pos = 0;
  3231.       row = 0;
  3232.       ptr = text;
  3233.       ch = *ptr;
  3234.       while (ch != '\0') {
  3235.         if (ch == '\n') {
  3236.           row++;
  3237.           ptr++;
  3238.           pos = 0;
  3239.           fputc ('\n', f);
  3240.             } 
  3241.         else  {
  3242.           num = 0;
  3243.           while (ch != '\0' && ch != '\n') {
  3244.             num++;
  3245.             ch = ptr [num];
  3246.               }
  3247.           if (num > 0) {
  3248.             while (num > 0 && *ptr == '\t') {
  3249.               num--;
  3250.               ptr++;
  3251.               next += fTabCount;
  3252.                 }
  3253.             while (pos < next) {
  3254.               fputc (' ', f);
  3255.               pos++;
  3256.                 }
  3257.             for (i = 0; i < num; i++) {
  3258.               fputc (ptr [i], f);
  3259.               pos++;
  3260.                 }
  3261.               }
  3262.           ptr += num;
  3263.             }
  3264.         ch = *ptr;
  3265.       }
  3266.     }
  3267.   }
  3268. }
  3269.  
  3270.  
  3271.  
  3272.  
  3273. void DRichView::Save(DFile* f) 
  3274. { 
  3275.   if ( f ) {
  3276.     Boolean savevirt= fIsVirtual;
  3277.     fIsVirtual = FALSE;
  3278.     for (short i = 0; i < fNumItems; i++) {
  3279.       DParagraph* itemPtr = GetParaPtr( i);
  3280.       if (itemPtr) {
  3281.                 DParagraph itemData( itemPtr->fDataPtr, false, itemPtr->numRows, itemPtr, 
  3282.                                         itemPtr->fStyleIndex, itemPtr->fNumStyles, false);
  3283.            FormatText(0, &itemData, FALSE);
  3284.                 if (i > 0 && itemData.openSpace > 0) fputc ('\n', f->fFile);
  3285.            SaveTableItem(&itemData, f->fFile,  TRUE);
  3286.         }
  3287.       }
  3288.         fIsVirtual= savevirt;
  3289.     }
  3290. }
  3291.  
  3292.  
  3293.  
  3294.  
  3295.  
  3296. void DRichView::Print()    
  3297. { 
  3298. #if (defined(WIN_MAC) || defined (WIN_MSWIN))
  3299.   Boolean   goOn;
  3300.   short      i, item, line,pixels, visBelow;
  3301.   DParagraph*   itemPtr;
  3302.   Boolean   newPage;
  3303.   Nlm_RecT      r, rct;
  3304.   FloatHi           scale;
  3305.   Nlm_WindoW    w;
  3306.  
  3307.   Boolean savevirt= fIsVirtual;
  3308.   fIsVirtual = FALSE;
  3309.     if (fNumItems > 0) {
  3310.         ViewRect( rct);
  3311.     w = Nlm_StartPrinting ();
  3312.     if (w != NULL) {
  3313.       for (i = 0; i < MAXFONTS; i++) {
  3314.         gFontHeights[i].font = NULL;
  3315.         gFontHeights[i].height = 0;
  3316.           }
  3317.       goOn = TRUE;
  3318.       pixels = 0;
  3319.       item = 0;
  3320.       newPage = TRUE;
  3321.       while (item < fNumItems && goOn) {
  3322.         if (newPage) {
  3323.           goOn = Nlm_StartPage ();
  3324.           newPage = FALSE;
  3325.           Nlm_PrintingRect (&r);
  3326.             }
  3327.         if (goOn) {
  3328.           itemPtr = GetParaPtr( item);
  3329.           if (itemPtr) {
  3330.                         DParagraph itemData( itemPtr->fDataPtr, false, itemPtr->numRows, itemPtr, 
  3331.                                                                 itemPtr->fStyleIndex, itemPtr->fNumStyles, false);
  3332.             UpdateItemHeights (&itemData);
  3333.             scale = (FloatHi) (r.right - r.left) / (FloatHi) (rct.right - rct.left);
  3334.                    FormatText(0, &itemData, TRUE);
  3335.  
  3336.             if (pixels != 0)  r.top += itemData.leadHeight;
  3337.                 r.top += itemData.spaceBefore;
  3338.              
  3339.             visBelow = (r.bottom - r.top) / itemData.lineHeight;
  3340.             if ((itemData.keepTogether && visBelow < itemData.numRows) ||
  3341.                 itemData.newPage) {
  3342.               goOn = Nlm_EndPage ();
  3343.               if (goOn)  goOn = Nlm_StartPage ();
  3344.               newPage = FALSE;
  3345.               Nlm_PrintingRect (&r);
  3346.               visBelow = (r.bottom - r.top) / itemData.lineHeight;
  3347.                 }
  3348.             line = 0;
  3349.             while (visBelow + line < itemData.numRows && goOn) {
  3350.                   pixels = DrawStyledItem( &itemData, &r, item+1, line, TRUE, NULL);
  3351.               r.top += pixels;
  3352.                     r.top += itemData.spaceAfter;
  3353.               line += visBelow;
  3354.               goOn = Nlm_EndPage ();
  3355.               if (goOn) Nlm_StartPage ();
  3356.               newPage = FALSE;
  3357.               Nlm_PrintingRect (&r);
  3358.               visBelow = (r.bottom - r.top) / itemData.lineHeight;
  3359.                 }
  3360.             if (visBelow > 0 && goOn) {
  3361.                   pixels = DrawStyledItem( &itemData, &r, item+1, line, TRUE, NULL);
  3362.               r.top += pixels;
  3363.                     r.top += itemData.spaceAfter;
  3364.                 }
  3365.                
  3366.               }
  3367.             }
  3368.         item++;
  3369.         if (r.top >= r.bottom) {
  3370.           goOn = Nlm_EndPage ();
  3371.           newPage = TRUE;
  3372.             }
  3373.           }
  3374.       if ((!newPage) && goOn) 
  3375.         goOn = Nlm_EndPage ();
  3376.        
  3377.       Nlm_EndPrinting (w);
  3378.       for (i = 0; i < MAXFONTS; i++) {
  3379.         gFontHeights [i].font = NULL;
  3380.         gFontHeights [i].height = 0;
  3381.         }
  3382.         }
  3383.         }
  3384.     fIsVirtual= savevirt;
  3385.    
  3386. #else
  3387.     Nlm_Message(MSG_OK,"Printing is not yet defined for this window system");
  3388. #endif
  3389. }
  3390.  
  3391.  
  3392.  
  3393. void  DRichView::SetTabs( short theTabstops) 
  3394. { 
  3395.     fTabCount= theTabstops;
  3396. }
  3397.  
  3398.  
  3399. #if 0
  3400. enum docFormats {
  3401.     kUnknownformat,
  3402.     kTextformat,
  3403.     kRTFformat,
  3404.     kPICTformat,
  3405.     kHTMLformat,
  3406.     kMaxDocformat
  3407.     };
  3408. #endif
  3409.  
  3410. void  DRichView::ShowFile( char* filename, Nlm_FonT font) 
  3411. {
  3412.     fDocFormat= DRichHandler::kUnknownformat;
  3413.     DRTFHandler rtfhandler( this, NULL);
  3414.     if ( rtfhandler.ProcessFile( filename) ) 
  3415.         fDocFormat= rtfhandler.Format();
  3416.     else {
  3417.         DPICTHandler picthandler( this, NULL);
  3418.         if ( picthandler.ProcessFile( filename) )
  3419.             fDocFormat= picthandler.Format();
  3420.         else  { 
  3421.           DGIFHandler gifhandler( this, NULL);
  3422.           if ( gifhandler.ProcessFile( filename) ) 
  3423.               fDocFormat= gifhandler.Format(); 
  3424.           else {
  3425.               DHTMLHandler htmlhandler( this, NULL);
  3426.               if ( htmlhandler.ProcessFile( filename) ) 
  3427.                   fDocFormat= htmlhandler.Format(); 
  3428.               else {
  3429. #if 1
  3430.                   DRichHandler texthandler( this, NULL);
  3431.                   if ( texthandler.ProcessFile( filename) ) 
  3432.                       fDocFormat= texthandler.Format(); 
  3433. #else
  3434.                 ShowTextFile( filename, font);
  3435.                   fDocFormat= DRichHandler::kTextformat; 
  3436. #endif
  3437.                   }
  3438.               }
  3439.           }
  3440.         }
  3441. }
  3442.  
  3443.  
  3444. void DRichView::ShowTextFile( char* filename, Nlm_FonT font)
  3445. {    
  3446.     DParagraph    para;
  3447.     DRichStyle    aStyle;
  3448.     if (font) aStyle.font= font;
  3449.     aStyle.last= true;
  3450.   ShowFileFancy( filename, ¶, &aStyle, 1);
  3451. }
  3452.  
  3453.  
  3454.  
  3455.  
  3456.  
  3457. void  DRichView::ShowFileFancy( char* filename, DParagraph* parFormat,  
  3458.                                                                 DRichStyle* styles, short nstyles, short tabStops) 
  3459. {
  3460.   char         ch;
  3461.   short       actual, cnt, leftOver;
  3462.   long         cntr;
  3463.   FILE         *fp;
  3464.   Nlm_RecT     r;
  3465.   Nlm_WindoW   tempPort;
  3466.   char      * text,  * txt;
  3467.   Nlm_FonT         font;
  3468. #ifdef COMP_MPW
  3469.   char*  p;
  3470. #endif
  3471. #if (defined(OS_DOS) || defined (OS_NT))
  3472.   char*  p;
  3473.   char*  q;
  3474. #endif
  3475.     DParagraph    para;
  3476.  
  3477.   if ( filename  && filename [0] != '\0') {
  3478.          fTabCount = tabStops;
  3479.     if (parFormat == NULL) parFormat = ¶
  3480.     Nlm_Reset (fPanel);
  3481.     tempPort = Nlm_SavePort (fPanel);
  3482.         ViewRect( r);
  3483.     if (styles) font= styles->font;
  3484.     if (font == NULL) font = Nlm_programFont; //Nlm_systemFont;
  3485.      
  3486.     text = (char*) MemNew (16000);
  3487.     if (text) {
  3488.       fp = FileOpen (filename, "r");
  3489.       if (fp) {
  3490.         leftOver = 0;
  3491.         cntr = FileLength (filename);
  3492.         cnt = (short) MIN (cntr, 15000L);
  3493.  
  3494.         while (cnt > 0 && cntr > 0) {
  3495.           txt = text + leftOver;
  3496.           actual = (short) FileRead (txt, 1, cnt, fp);
  3497.           if (actual > 0) {
  3498.             cnt = actual;
  3499.             txt [cnt] = '\0';
  3500.             ch = fgetc (fp);
  3501.             while (ch != '\0' && ch != '\n' && cnt < 15900) {
  3502.               txt [cnt] = ch;
  3503.               cnt++;
  3504.               ch = fgetc (fp);
  3505.                 }
  3506.             while ((ch == '\n' || ch == '\r') && cnt < 15900) {
  3507.               txt [cnt] = ch;
  3508.               cnt++;
  3509.               ch = fgetc (fp);
  3510.                 }
  3511.             txt [cnt] = '\0';
  3512. #if (defined(OS_DOS) || defined (OS_NT))
  3513.             p = text;
  3514.             q = text;
  3515.             while (*p) {
  3516.               if (*p == '\r') {
  3517.                 p++;
  3518.               } else {
  3519.                 *q = *p;
  3520.                 p++;
  3521.                 q++;
  3522.               }
  3523.             }
  3524.             *q = '\0';
  3525. #endif
  3526. #ifdef COMP_MPW
  3527.             p = text;
  3528.             while (*p) {
  3529.               if (*p == '\r') {
  3530.                 *p = '\n';
  3531.               }
  3532.               p++;
  3533.             }
  3534. #endif
  3535.             Append( text, parFormat, styles, nstyles, NULL); 
  3536.                 /* dgg -- need to fiddle w/ styles to match to subset of text !! */
  3537.             leftOver = 1;
  3538.             text [0] = ch;
  3539.             cntr -= cnt;
  3540.             cnt = (short) MIN (cntr, 15000L);
  3541.               } 
  3542.           else {
  3543.             cnt = 0;
  3544.             cntr = 0;
  3545.               }
  3546.             }
  3547.         FileClose (fp);
  3548.           }
  3549.       text = (char*) MemFree (text);
  3550.         }
  3551.     if (!fAutoAdjust) AdjustScroll();
  3552.     if (tempPort) Nlm_RestorePort (tempPort);
  3553.       }
  3554. }
  3555.  
  3556.  
  3557.  
  3558.         
  3559.     
  3560.     
  3561. void DRichView::DoubleClick(Nlm_PoinT mouse)
  3562. {
  3563.     short                 item, row, atch;
  3564.     Nlm_RecT        rct;
  3565.     char                wordAt[512];
  3566.     DRichStyle     * styleAt = NULL;
  3567.  
  3568.         // sickly demo
  3569.     wordAt[0]= 0;
  3570.     MapPoint( mouse, item, row, &rct, wordAt, 512, NULL/*styleAt*/);
  3571.     atch= gMapOfs;  
  3572.     SetSelectedText( item, atch, item, atch); 
  3573.     if (fMapStyle) {
  3574.         if (fMapStyle->ispict) {
  3575.             Nlm_PoinT atp;
  3576.             atp.x= mouse.x - fDrawr.left;
  3577.             atp.y= mouse.y - fDrawr.top;
  3578.             // if fMapStyle->ismap, do things w/ gopher link
  3579. #if 0
  3580.             Message(MSG_OK, "dblClik in picture x=%d y=%d, picwd=%d picht=%d", 
  3581.                     atp.x, atp.y, fMapStyle->pixwidth, fMapStyle->pixheight);
  3582. #endif
  3583.             }
  3584.         else {
  3585.             Nlm_InvertRect(&rct);
  3586. #if 0
  3587.             Message(MSG_OK, "dblClik text at prg=%d row=%d sto=%d '%s'",
  3588.                              item, row, fMapStyle->nextofs, wordAt);
  3589. #endif
  3590.             InvalRect( rct);
  3591.             }
  3592.         }
  3593.     //this->Select();
  3594.     this->GetWindow()->Select();
  3595. }
  3596.  
  3597. void DRichView::SingleClick(Nlm_PoinT mouse) 
  3598. {
  3599.     short             item, row, atch;
  3600.     Nlm_RecT        rct;
  3601.     char                wordAt[512];
  3602.  
  3603.     wordAt[0]= 0;
  3604.     MapPoint( mouse, item, row, &rct, wordAt, 512, NULL/*styleAt*/);
  3605.     atch= gMapOfs;  
  3606.     SetSelectedText( item, atch, item, atch); 
  3607. }
  3608.  
  3609. void DRichView::Click(Nlm_PoinT mouse)
  3610. {
  3611.     if (Nlm_dblClick) DoubleClick( mouse);
  3612.     else SingleClick(mouse);        
  3613. }
  3614.     
  3615. void  DRichView::SetAutoAdjust( Boolean autoAdjust) 
  3616. {
  3617.     fAutoAdjust= autoAdjust;
  3618. }
  3619.  
  3620.  
  3621. #if 0
  3622. void DRichView::Show()
  3623. {
  3624.   Nlm_Update(); //!? need since took out vibwnds autoupdate for RestorePort
  3625. }
  3626. #endif
  3627.  
  3628. // this is DPanel form:
  3629. //void DRichView::Scroll( Boolean vertical, DView* scrollee, short newval, short oldval)
  3630.  
  3631. void DRichView::ScrollDoc(Nlm_BaR sb, short newval, short oldval)
  3632. {
  3633.         // Scroll bar callback that takes suppressed partial lines into account
  3634.         // this is good only for vertical==true
  3635.   Boolean      goToEnd;
  3636.   short     barmax, barval, firstShown;
  3637.   short     height,highest,highFree,item, lo1, hi1;
  3638.   short     line, lineInto,lowest,lowFree;
  3639.   short     pixels,pgDn,pgUp,vis;
  3640.   Nlm_RecT     r;
  3641.   DParagraph*  itemPtr;
  3642.     
  3643.     // Nlm_SlatE s= (Nlm_SlatE) fPanel;
  3644.     
  3645.   if (oldval != newval) {
  3646.     if (Nlm_Visible (fPanel) && Nlm_AllParentsVisible (fPanel)) {
  3647.             ViewRect( r);
  3648.       height = r.bottom - r.top;
  3649.       item = GetItemNum ( newval);
  3650.       line = newval - GetLineStart( item);
  3651.       firstShown = item;
  3652.       lineInto = line;
  3653.       lowest = INT2_MAX;
  3654.       highest = INT2_MIN;
  3655.       pgUp = VisLinesAbove ( &r, item, line, lowest, highest) - 1;
  3656.       pgDn = VisLinesBelow ( &r, item, line, lowest, highest) - 1;
  3657.       if (pgDn < 1)  pgDn = 1;
  3658.       if (pgUp < 1)  pgUp = 1;
  3659.       if (lowest < INT2_MAX)  
  3660.         fNumLines = UpdateLineStarts ( lowest);
  3661.       Nlm_Select (fPanel);
  3662.       if ((newval > oldval && newval - pgUp <= oldval) ||
  3663.           (newval < oldval && newval + pgDn >= oldval)) {
  3664.         pixels = PixelsBetween ( &r, newval, oldval, lo1, hi1);
  3665.         if (ABS (pixels) < height) {
  3666.           Nlm_ScrollRect (&r, 0, pixels);
  3667.           if (pixels<0) r.top = r.bottom + pixels; // - 5;
  3668.           else r.bottom = r.top + pixels; // + 5;
  3669.           Nlm_InsetRect (&r, -1, -1);
  3670.           Nlm_InvalRect (&r);
  3671.             } 
  3672.         else {
  3673.           Nlm_InsetRect (&r, -1, -1);
  3674.           Nlm_InvalRect (&r);
  3675.             }
  3676.           } 
  3677.       else {
  3678.         Nlm_InsetRect (&r, -1, -1);
  3679.         Nlm_InvalRect (&r);
  3680.           }
  3681.       lowFree = INT2_MAX;
  3682.       highFree = INT2_MIN;
  3683.       for (item = 0; item < lowest; item++)  
  3684.         FreeCachedItem ( item, lowFree, highFree);
  3685.       for (item = highest + 1; item < fNumItems; item++) 
  3686.         FreeCachedItem ( item, lowFree, highFree);
  3687.       if (lowFree < INT2_MAX) 
  3688.         fNumLines = UpdateLineStarts ( lowFree);
  3689.       
  3690.       barmax = 0;
  3691.       goToEnd = (Boolean) (newval == fBarmax);
  3692.       if (fNumLines > 0 && fNumItems > 0) {
  3693.         itemPtr = GetParaPtr( fNumItems - 1);
  3694.         if (itemPtr) {
  3695.                     ViewRect( r);
  3696.           lowest = INT2_MAX;
  3697.           highest = INT2_MIN;
  3698.           vis = VisLinesAbove ( &r, fNumItems - 1,
  3699.                                itemPtr->numRows - 1, lowest, highest);
  3700.           if (lowest < INT2_MAX)  
  3701.             fNumLines = UpdateLineStarts ( lowest);
  3702.           barmax = fNumLines - vis;
  3703.             }
  3704.           }
  3705.       barval = GetLineStart( firstShown) + lineInto;
  3706.       if (goToEnd) barval = barmax;
  3707.     
  3708.       if (barval > fBarmax) {
  3709.         Nlm_CorrectBarMax (sb, barmax);
  3710.         Nlm_CorrectBarValue (sb, barval);
  3711.           } 
  3712.       else {
  3713.         Nlm_CorrectBarValue (sb, barval);
  3714.         Nlm_CorrectBarMax (sb, barmax);
  3715.           }
  3716.       Nlm_CorrectBarPage (sb, pgUp, pgDn);
  3717.       fBarmax = barmax;
  3718.       Nlm_Update ();
  3719.     }
  3720.   }
  3721. }
  3722.  
  3723.  
  3724.  
  3725. // Performs garbage collection on document data
  3726.  
  3727. void DRichView::ResetDoc()
  3728. {
  3729.     DeleteAll();
  3730.   fNumItems = 0;
  3731.   fNumLines = 0;
  3732.   fBarmax = 0;
  3733.   //DRichView::InitRichView();
  3734. }
  3735.  
  3736.  
  3737.  
  3738.  
  3739.  
  3740.  
  3741.  
  3742.  
  3743.  
  3744. // class DRichFindDialog
  3745.  
  3746. class DRichFindDialog : public DFindDialog {
  3747. public:
  3748.     DRichView* fView;
  3749.     char    * fLastTarget;
  3750.     short        fLastParag, fLastChar;
  3751.     DRichFindDialog(  DRichView* itsView);
  3752.     virtual void DoFind();
  3753.     virtual void BuildDlog();
  3754. };
  3755.  
  3756. DRichFindDialog::DRichFindDialog(  DRichView* itsView) :
  3757.         fView( itsView), fLastTarget(NULL),  fLastParag(-1), fLastChar(-1)
  3758. {
  3759. }
  3760.  
  3761.  
  3762. void DRichFindDialog::BuildDlog()
  3763. {
  3764.     DFindDialog::BuildDlog();
  3765.  
  3766.     DView* av;
  3767.     av= FindSubview(replaceId); if (av) { av->Disable(); } //av->Hide();
  3768.     av= FindSubview(replaceFindId); if (av) { av->Disable();  }
  3769.     av= FindSubview(replaceAllId); if (av) { av->Disable(); }
  3770.     av= FindSubview(cBackwards);     if (av) { av->Disable(); }
  3771.     av= FindSubview(cFullWord); if (av) { av->Disable(); }
  3772.     //av= FindSubview(cCaseSense); if (av) { av->Disable(); }
  3773.     if (fReplaceText) fReplaceText->Disable();
  3774. }
  3775.  
  3776. void DRichFindDialog::DoFind() 
  3777. {
  3778.     const char    *target;
  3779.     Boolean     casesense, back, fullword, found;
  3780.     short            paragat, charat;
  3781.     long            len;
  3782.     
  3783.     target= this->GetFind();
  3784.     if (target && *target) {
  3785.         casesense    = this->CaseSensitive();
  3786.         back= this->Backwards();         // not yet supported
  3787.         fullword= this->FullWord(); // not yet supported
  3788.         paragat= fView->fSelParag - 1; // offset by -1 for real parag# -- MESS !
  3789.         charat= fView->fSelChar;
  3790.         len= StrLen(target);
  3791.         if (fLastTarget && StringCmp(target, fLastTarget)==0 
  3792.          && paragat == fLastParag && charat == fLastChar) {
  3793.             charat += len;
  3794.             found= fView->Find( (char*)target, paragat, charat, paragat, charat, casesense); 
  3795.             }
  3796.         else {
  3797.             if (fLastTarget) MemFree(fLastTarget);
  3798.             fLastTarget= StrDup(target);
  3799.             found= fView->Find( (char*)target, paragat, charat, paragat, charat, casesense); 
  3800.             }
  3801.         fLastParag= paragat;
  3802.         fLastChar = charat;
  3803.         if (found) {
  3804.             fView->SetSelectedText( paragat+1, charat, paragat+1, charat + len);
  3805.             }
  3806.         }
  3807. }                
  3808.  
  3809.  
  3810.  
  3811. //class    DRichTextDoc : public DWindow
  3812.  
  3813.  
  3814.  
  3815. Nlm_RecT DRichTextDoc::gRichDocRect = { 0, 0, 0, 0 };
  3816.  
  3817.  
  3818. DRichTextDoc::DRichTextDoc( long id, Boolean makeRichView, Nlm_FonT itsFont) :
  3819.         DWindow( id, gApplication, document),
  3820.         fRichView(NULL), fFloatingEditText(NULL)
  3821. {     
  3822.     Nlm_PoinT nps;
  3823.     fFont= itsFont;
  3824.     this->GetNextPosition( &nps);
  3825.     fFloatingEditText= (DDialogText*) new DHiddenText(0,this,"");
  3826.     this->SetNextPosition( nps);
  3827.     fFloatingEditText->Hide();
  3828.     //this->SetEditText(fFloatingEditText);
  3829.     
  3830.     if (makeRichView) {
  3831.         this->GetNextPosition( &nps);
  3832.         nps.x= 0; // fix for odd offset
  3833.         this->SetNextPosition( nps);
  3834.         fRichView= new DRichView( 0, this, gPrintManager->PageWidth(), 0);
  3835.         fRichView->SetSlateBorder( true);
  3836.         fRichView->SetResize( DView::matchsuper, DView::relsuper);
  3837.         //fRichView->SetTabs( gTextTabStops);
  3838.         //fRichView->SizeToSuperview( fWindow, true, false); // this needs to adjust for if view has scrollbar !
  3839.         //fSaveHandler= fRichView; //DRichView() installs these handlers !
  3840.         //fPrintHandler= fRichView;
  3841.         }
  3842. }
  3843.  
  3844.                               
  3845. void DRichTextDoc::Open()
  3846. {
  3847.     this->CalcWindowSize();
  3848.     if (!fFindDlog) fFindDlog= new DRichFindDialog( fRichView);
  3849.     fRichView->SizeToSuperview( this, true, false); // this needs to adjust for if view has scrollbar !
  3850.     DWindow::Open();
  3851. }
  3852.  
  3853. void DRichTextDoc::Open( DFile* aFile)
  3854. {
  3855.     if (aFile) fRichView->ShowFile( (char*)aFile->GetName(), fFont);
  3856.     SetTitle( (char*)aFile->GetShortname());
  3857.     Open();
  3858. }
  3859.  
  3860. void  DRichTextDoc::Open( char* filename) 
  3861. {
  3862.     fRichView->ShowFile( filename, fFont);
  3863.     SetTitle( (char*)DFileManager::FilenameFromPath(filename));
  3864.   Open();
  3865. }
  3866.  
  3867. void DRichTextDoc::Close()
  3868. {
  3869.     //if (!Nlm_EmptyRect(&fViewrect)) gRichDocRect= fViewrect;  
  3870.     if (fRichView) fRichView->ViewRect( gRichDocRect);  // GetPosition
  3871.     DWindow::Close();
  3872. }
  3873.  
  3874. void DRichTextDoc::ResizeWin()
  3875. {
  3876.     DWindow::ResizeWin();
  3877.     if (fRichView) fRichView->ViewRect( gRichDocRect);
  3878.     //if (!Nlm_EmptyRect(&fViewrect)) gRichDocRect= fViewrect;  
  3879. }
  3880.  
  3881. Boolean DRichTextDoc::IsMyAction(DTaskMaster* action) 
  3882. {
  3883.     switch(action->Id()) {
  3884.         case DApplication::kUndo:
  3885.             Message(MSG_OK,"DRichTextDoc::Undo not ready.");
  3886.             return true;
  3887.         case DApplication::kCut:
  3888.             Message(MSG_OK,"DRichTextDoc::Cut not ready.");
  3889.             //this->CutText(); 
  3890.             return true;
  3891.             
  3892.         case DApplication::kCopy: {
  3893.             char* theText= NULL;
  3894.             if (fRichView) theText= fRichView->GetSelectedText();
  3895.             if (theText) {
  3896.                 fFloatingEditText->SetText(theText);
  3897.                 fFloatingEditText->SetSelection(0,32000); 
  3898.           fFloatingEditText->CopyText(); 
  3899.           MemFree( theText);
  3900.                 fFloatingEditText->SetText(""); // don't need to keep extra copies around
  3901.                 //Message(MSG_OK,"DRichTextDoc::Copied text selection.");
  3902.           }
  3903.         }
  3904.             return true;
  3905.             
  3906.         case DApplication::kPaste:
  3907.             Message(MSG_OK,"DRichTextDoc::Paste not ready.");
  3908.             //this->PasteText(); 
  3909.             return true;
  3910.         case DApplication::kClear:
  3911.             Message(MSG_OK,"DRichTextDoc::Clear not ready.");
  3912.             //this->ClearText(); 
  3913.             return true;
  3914.         case DApplication::kSelectAll:
  3915.             //Message(MSG_OK,"DRichTextDoc::Select all not ready.");
  3916.             if (fRichView) fRichView->SelectAll();
  3917.             //this->SetSelection(0,0,32000,32000); 
  3918.             return true;
  3919.         default:
  3920.             return DWindow::IsMyAction(action);
  3921.         }
  3922. }
  3923.  
  3924.  
  3925. // class DRichApplication : public DApplication
  3926.  
  3927.  
  3928. DRichApplication::DRichApplication()
  3929. {
  3930.     //fAcceptableFileTypes= "TEXTPICTGIFfRTF "; /* up to 4 types, or null for all types */
  3931.     // ^^ not working, only 1st seen !?
  3932.     //fAcceptableFileTypes= NULL;
  3933. }
  3934.  
  3935.  
  3936. void DRichApplication::OpenDocument(DFile* aFile)
  3937. {
  3938.     if (aFile && aFile->Exists()) {
  3939.         gCursor->watch();
  3940.         DRichTextDoc* aDoc= new DRichTextDoc();
  3941.         aDoc->Open( aFile);
  3942.         gCursor->arrow();
  3943.         }
  3944. }
  3945.  
  3946.  
  3947.