home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 4 / Apprentice-Release4.iso / Source Code / Libraries / DCLAP 4j / DClap / DTableView.cpp < prev    next >
Encoding:
Text File  |  1995-12-17  |  28.1 KB  |  1,210 lines  |  [TEXT/R*ch]
  1. // DTableView.cp
  2. // d.g.gilbert
  3.  
  4. // this class is used a lot for various display/user interaction arrays of items
  5. // still needs work for multiple selections, run arrays for height/width?
  6. // 
  7.  
  8. #include "DTableView.h"
  9. #include <DPanel.h>
  10. #include <DUtil.h>
  11. #include <Dvibrant.h>
  12. #include <DTracker.h>
  13. #include <ncbi.h>
  14. #include <dgg.h>
  15.  
  16.  
  17.  
  18.  
  19. DTabSelector::DTabSelector( DTableView* itsTable)
  20. {
  21.     ITabSelector( itsTable); // in constructor !?
  22. }
  23.  
  24. DTabSelector::~DTabSelector() 
  25. {
  26. #if 0
  27.     fOldSelection= Nlm_DestroyRgn( fOldSelection);
  28.     fNewSelection= Nlm_DestroyRgn( fNewSelection);
  29. #endif
  30. }
  31.  
  32. void DTabSelector::ITabSelector( DTableView* itsTable)
  33. {
  34.     ITracker( cTabSelCmd, itsTable, "selection", true, false, itsTable); 
  35.     // ITracker() calls Reset()
  36. }
  37.  
  38.  
  39. void DTabSelector::Reset()
  40. {
  41.     DTracker::Reset();
  42.     fDoExtend= gKeys->shift();
  43. #if 1
  44.     fOldSelection= ((DTableView*)fView)->GetSelRect();
  45.     fNewSelection= fOldSelection;
  46. #else
  47.     fOldSelection= Nlm_NewRgn(); 
  48.     fNewSelection= Nlm_NewRgn();  
  49.     CopyRgn( ((DTableView*)fView)->fSelections, fOldSelection);
  50.     CopyRgn( fOldSelection, fNewSelection);
  51. #endif
  52. }
  53.  
  54.  
  55. void DTabSelector::DoItWork()  
  56. {
  57.     if (fMovedOnce || fDoExtend) {
  58.         ((DTableView*)fView)->SelectCells( fNewSelection, 
  59.                 fDoExtend, DTableView::kHighlight, DTableView::kSelect);
  60.         }
  61. }
  62.  
  63. void DTabSelector::UndoWork()  
  64. {
  65. #if 1
  66.     Nlm_RecT tmpRect= fNewSelection;
  67.     fNewSelection= fOldSelection;
  68.     fOldSelection= tmpRect;
  69. #else
  70.     Nlm_RgN tmpRgn= fNewSelection;
  71.     fNewSelection= fOldSelection;
  72.     fOldSelection= tmpRgn;
  73. #endif
  74.     DoItWork();
  75. }
  76.  
  77.  
  78. void DTabSelector::DoIt()  
  79. {
  80.     DCommand::DoIt();
  81.     
  82.     Nlm_PoinT pt1, pt2;
  83.     Nlm_RecT    selr;
  84.         // +1 is messy fix to stop left/top -1 creap !
  85.     pt1.x= MIN( fAnchorPoint.x+1, fNextPoint.x);
  86.     pt2.x= MAX( fAnchorPoint.x-1, fNextPoint.x);
  87.     pt1.y= MIN( fAnchorPoint.y+1, fNextPoint.y);
  88.     pt2.y= MAX( fAnchorPoint.y-1, fNextPoint.y);
  89.  
  90.     ((DTableView*)fView)->PointToCell( pt1, selr.top, selr.left);
  91.     ((DTableView*)fView)->PointToCell( pt2, selr.bottom, selr.right);
  92.     selr.bottom++;
  93.     selr.right++;
  94.     fNewSelection= selr;
  95.     if (!fDoExtend) fDoExtend= gKeys->shift(); // give'em another chance to shift
  96.     
  97.     DoItWork();
  98. }
  99.  
  100. void DTabSelector::Undo()  
  101. {
  102.     DCommand::Undo();
  103.     Boolean saveext= fDoExtend;
  104.     fDoExtend= false;
  105.     UndoWork();
  106.     fDoExtend= saveext;
  107. }
  108.  
  109. void DTabSelector::Redo()  
  110. {
  111.     DCommand::Redo();
  112.     UndoWork();
  113. }
  114.  
  115.  
  116.  
  117.  
  118.  
  119.  
  120.  
  121. //class DTableView : public DPanel
  122.  
  123.  
  124. DTableView::DTableView(long id, DView* itsSuperior, short pixwidth, short pixheight, 
  125.                                                 short nrows, short ncols, short itemwidth, short itemheight,
  126.                                                 Boolean hasVscroll, Boolean hasHscroll):
  127.         DAutoPanel( id, itsSuperior, pixwidth, pixheight, hasVscroll, hasHscroll),
  128.         fItemWidth(itemwidth), fItemHeight(itemheight),
  129.         fTop(0), fLeft(0), fColsDrawn(0), fMaxRows(nrows), fMaxCols(ncols), 
  130.         fSelectedRow(kNoSelection), fSelectedCol(kNoSelection),
  131.         fCanSelectRow(true), fCanSelectCol(false),fIsPrinting(false),
  132.         fWidths(NULL), fHeights(NULL),
  133.         fFont(Nlm_programFont)
  134. {
  135.     Nlm_BaR sb;
  136.     sb = Nlm_GetSlateVScrollBar((Nlm_SlatE) GetNlmObject());
  137.   fHasVbar= (sb != NULL);
  138.   sb = Nlm_GetSlateHScrollBar((Nlm_SlatE) GetNlmObject());
  139.   fHasHbar= (sb != NULL);
  140.   FindLocation();
  141.   SetTableSize( fMaxRows, fMaxCols);
  142.     SetEmptySelection(false); 
  143.     
  144.     fTabSelector= new DTabSelector( this);
  145.     //fTabSelector->ITabSelector( this);
  146.     fCurrentTracker= fTabSelector;
  147. }
  148.         
  149. DTableView::~DTableView()
  150. {
  151.     if (fWidths) MemFree(fWidths);
  152.     if (fHeights) MemFree(fHeights);
  153.     //if (fTabSelector) delete fTabSelector; //<< causing Motif crashes !?
  154. }
  155.  
  156. void DTableView::SetCanSelect(Boolean canrow, Boolean cancol)
  157. {
  158.     fCanSelectRow= canrow;
  159.     fCanSelectCol= cancol;
  160. }
  161.  
  162.  
  163. static Boolean didscroll;
  164.  
  165. void DTableView::SelectCells( short row, short col, 
  166.                         Nlm_Boolean extend, Nlm_Boolean highlight, Nlm_Boolean select)
  167. {
  168.     if (row>=fMaxRows || row<0 || col>=fMaxCols || col<0) return;
  169.  
  170.     if (highlight) InvertSelection(); // hide old
  171.     if (fCanSelectRow) fSelectedRow= row; 
  172.     if (fCanSelectCol) fSelectedCol= col;
  173.          
  174.     if (!select) ; // deselect cells !!
  175.     
  176.     if (extend) {
  177.         if (fSelrect.top == kNoSelection) fSelrect.top= row;
  178.         else if (fSelrect.top > row) fSelrect.top= row;
  179.         if (fSelrect.bottom <= row) fSelrect.bottom= row+1; 
  180.     
  181.         if (fSelrect.left == kNoSelection) fSelrect.left= col;
  182.         else if (fSelrect.left > col) fSelrect.left= col;
  183.         if (fSelrect.right <= col) fSelrect.right= col+1; 
  184.         }
  185.     else {
  186.         fSelrect.left= col;
  187.         fSelrect.right= col+1; 
  188.         fSelrect.top= row;
  189.         fSelrect.bottom= row+1; 
  190.         }
  191.         
  192.     didscroll= false;
  193.     ScrollIntoView( fSelrect);
  194.     if (!didscroll && highlight) InvertSelection(); // show new
  195. }
  196.  
  197. void DTableView::SelectCells( Nlm_RecT selrect,  
  198.                         Nlm_Boolean extend, Nlm_Boolean highlight, Nlm_Boolean select)
  199. {
  200.     if (selrect.top>= fMaxRows || selrect.bottom<0 
  201.      || selrect.left>=fMaxCols || selrect.right<0) return;
  202.     selrect.left= Max(0,selrect.left);
  203.     selrect.right= Min(fMaxCols, selrect.right);
  204.     selrect.top= Max(0,selrect.top);
  205.     selrect.bottom= Min(fMaxRows, selrect.bottom);
  206.     
  207.     if (highlight) InvertSelection();  
  208.     if (fCanSelectRow) fSelectedRow= selrect.top; 
  209.     if (fCanSelectCol) fSelectedCol= selrect.left;
  210.     
  211.     if (extend)  {
  212.         if (fSelrect.top == kNoSelection) fSelrect.top= selrect.top;
  213.         if (fSelrect.bottom == kNoSelection) fSelrect.bottom= selrect.bottom;
  214.         if (fSelrect.left == kNoSelection) fSelrect.left= selrect.left;
  215.         if (fSelrect.right == kNoSelection) fSelrect.right= selrect.right;
  216.       Nlm_UnionRect( &fSelrect, &selrect, &fSelrect);
  217.       }
  218.     else   
  219.         fSelrect= selrect; // ?? add +1 to .right & .bottom ??
  220.  
  221.     didscroll= false;
  222.     ScrollIntoView( fSelrect);
  223.     if (!didscroll && highlight) InvertSelection();  
  224. }
  225.  
  226.  
  227. void DTableView::ScrollIntoView(Nlm_RecT itemr)
  228. {
  229.     enum { horizontal= false, vertical= true };
  230.     short    lastitem;
  231.     long    atpix;
  232.     Nlm_BaR sb;
  233.  
  234.      // fItemWidth << this isn't accurate for variable width/height.
  235.     if (fWidths) {
  236.         for (lastitem= fLeft, atpix= 0; lastitem< fMaxCols; lastitem++) { 
  237.             atpix += fWidths[lastitem]; 
  238.             if (atpix > fRect.right) break;
  239.             }
  240.         }
  241.     else
  242.         lastitem= fLeft + (fRect.right - fRect.left)/fItemWidth;
  243.      
  244.     if (itemr.left > lastitem || itemr.left < fLeft) {
  245.          didscroll= true;
  246.         sb = Nlm_GetSlateHScrollBar((Nlm_SlatE) GetNlmObject());
  247.         if (sb) { 
  248.             //Nlm_ResetClip(); // ! TEST: are we losing scrollbar update due to cliprect?
  249.             Nlm_SetValue(sb, Max(0, itemr.left - 1));  // calls our scroll funct
  250.             }
  251.         }
  252.     
  253.     if (fHeights) {
  254.         for (lastitem= fTop, atpix= 0; lastitem< fMaxRows; lastitem++) { 
  255.             atpix += fHeights[lastitem]; 
  256.             if (atpix > fRect.bottom) break;
  257.             }
  258.         }
  259.     else
  260.         lastitem= fTop + (fRect.bottom - fRect.top)/fItemHeight;
  261.         
  262.     if (itemr.top > lastitem || itemr.top < fTop) {
  263.          didscroll= true;
  264.         sb = Nlm_GetSlateVScrollBar((Nlm_SlatE) GetNlmObject());
  265.         if (sb) Nlm_SetValue(sb,  Max(0, itemr.top - 1));  
  266.         }
  267. }
  268.  
  269.  
  270. void DTableView::SetEmptySelection(Boolean redraw)
  271. {
  272.     if (redraw) {
  273.         //InvertSelection();
  274.         InvalidateSelection();
  275.         }
  276.     fSelectedRow = kNoSelection;
  277.     fSelectedCol = kNoSelection;
  278.     //Nlm_SetRect
  279.     Nlm_LoadRect( &fSelrect, kNoSelection, kNoSelection, kNoSelection, kNoSelection);
  280. }
  281.  
  282. void DTableView::InvalidateSelection()
  283. {
  284.     Nlm_RecT r, r2;
  285.     if (!Nlm_EmptyRect(&fSelrect)) {
  286.         r2= fSelrect;
  287.         GetCellRect( r2, r);
  288.         InvalRect( r);
  289.         }
  290.     else if (fSelectedRow>=0 && fSelectedCol>=0) {
  291.         GetCellRect( fSelectedRow, fSelectedCol, r);
  292.         InvalRect( r);
  293.         }
  294.     else if (fSelectedRow>=0) {
  295.         GetRowRect( fSelectedRow, r);
  296.         InvalRect( r);
  297.         }
  298.     else if (fSelectedCol>=0) {
  299.         GetRowRect( fSelectedCol, r);
  300.         InvalRect( r);
  301.         }
  302. }
  303.  
  304.  
  305. Boolean DTableView::IsSelected()
  306. {
  307.     return (!Nlm_EmptyRect( &fSelrect));
  308.     //return (fSelectedRow == kNoSelection && fSelectedCol == kNoSelection);
  309. } 
  310.  
  311.  
  312. Boolean DTableView::IsSelected(short row, short col)
  313. {
  314.     Nlm_PoinT pt;
  315.     pt.y= row; pt.x= col;
  316.     Boolean issel= Nlm_PtInRect( pt, &fSelrect);
  317.     return issel;
  318. }  
  319.  
  320.  
  321.  
  322.  
  323. void DTableView::SetTableFont( Nlm_FonT itsFont)
  324. {
  325.     fFont= itsFont;
  326. }
  327.  
  328. void DTableView::SetTableSize( short rows, short cols)
  329. {
  330.     short i;
  331.     
  332.     if (fWidths && cols!=fMaxCols) {
  333.         fWidths= (short*)MemMore( fWidths, (cols+1) * sizeof(short));
  334.         for (i= fMaxCols; i<=cols; i++) fWidths[i]= fItemWidth;
  335.         }
  336.         
  337.     if (fHeights && rows!=fMaxRows) {
  338.         fHeights= (short*)MemMore( fHeights, (rows+1) * sizeof(short));
  339.         for (i= fMaxRows; i<=rows; i++) fHeights[i]= fItemHeight;
  340.         }
  341.     
  342.     fMaxRows= rows; 
  343.     fMaxCols= cols;
  344.  
  345.     SetScrollPage();
  346. }
  347.  
  348. void DTableView::ChangeRowSize( short atrow, short deltarows)
  349. {
  350.     Boolean needupdate;
  351.     short newrows= Max(0, fMaxRows + deltarows);
  352. #if 1
  353.     Nlm_RecT  r;
  354.     ViewRect(fRect); 
  355.     Nlm_InsetRect( &fRect, 1, 1);
  356.     GetRowRect( atrow, r, (fMaxRows - atrow));
  357.     needupdate= Nlm_SectRect( &r, &fRect, &r);
  358.     SetTableSize( newrows, fMaxCols);
  359.     if (needupdate) this->InvalRect( r);
  360. #else
  361.     short viewrows=  (fRect.bottom - fRect.top) / fItemHeight;
  362.     needupdate= (atrow >= fTop && atrow <= viewrows);
  363.         // ^^ needs work
  364.     SetTableSize( newrows, fMaxCols);
  365.     if (needupdate) {
  366.         //this->Invalidate(); // locate just update rect??    
  367.         Nlm_RecT r;
  368.         short nrows= viewrows - atrow;
  369.         GetRowRect( atrow, r, nrows);
  370.         this->InvalRect( r);
  371.         }
  372. #endif
  373. }
  374.  
  375. void DTableView::ChangeColSize( short atcol, short deltacols)
  376. {
  377.     short newcols= Max(0, fMaxCols + deltacols);
  378.     Boolean needupdate= (atcol >= fLeft && atcol <= (fRect.right - fRect.left) / fItemWidth);
  379.         // ^^ needs work
  380.     SetTableSize( fMaxRows, newcols);
  381.     if (needupdate) {
  382.         //this->Invalidate(); // locate just update rect??    
  383.         Nlm_RecT r;
  384.         short ncols= ((fRect.right - fRect.left) / fItemWidth) - atcol;
  385.         GetColRect( atcol, r, ncols);
  386.         this->InvalRect( r);
  387.         }
  388. }
  389.  
  390.         
  391. void DTableView::SetItemWidth(short atcol, short ncols, short itemwidth)
  392. {
  393.     short i;
  394.     if (ncols >= fMaxCols && !fWidths) {
  395.         fItemWidth= itemwidth;
  396.         }
  397.     else {
  398.         if (!fWidths) {
  399.             // make fWidths
  400.             fWidths= (short*)MemNew( (fMaxCols+1)*sizeof(short));
  401.             for (i= 0; i<=fMaxCols; i++) fWidths[i]= fItemWidth;
  402.             }
  403.         short ncol= Min(fMaxCols, atcol+ncols);
  404.         for (i= atcol; i<ncol; i++) fWidths[i]= itemwidth;
  405.     fItemWidth= Max( fItemWidth, itemwidth);
  406.         }
  407.   SetScrollPage();
  408. }
  409.  
  410. void DTableView::SetItemHeight(short atrow, short nrows, short itemheight)
  411. {
  412.     short i;
  413.     if (nrows >= fMaxRows && !fHeights) {
  414.         fItemHeight= itemheight;
  415.         }
  416.     else {
  417.         if (!fHeights) {
  418.             fHeights= (short*)MemNew( (fMaxRows+1)*sizeof(short));
  419.             for (i= 0; i<=fMaxRows; i++) fHeights[i]= fItemHeight;
  420.             }
  421.         short nrow= Min(fMaxRows, atrow+nrows);
  422.         for (i= atrow; i<nrow; i++) fHeights[i]= itemheight;
  423. #if 0
  424.     if (itemheight) fItemHeight= MIN( fItemHeight, itemheight);
  425. #else
  426.     fItemHeight= MAX( fItemHeight, itemheight);
  427. #endif
  428.         }
  429.   SetScrollPage();
  430. }
  431.         
  432. void DTableView::SetScrollPage()
  433. {
  434.     // set paging size of hor/vert sbars.. need to do on open & on resize
  435.     Nlm_BaR sb;
  436.     short pgDn, pg, maxn;
  437.     if (fHasHbar) {
  438.         pg= (fRect.right - fRect.left) / fItemWidth;
  439.         pgDn= Max(1, pg - 1);
  440.         maxn= Max( fMaxCols - pgDn, 1);
  441.         sb = Nlm_GetSlateHScrollBar((Nlm_SlatE) GetNlmObject());
  442.         if (sb) Nlm_SetRange(sb, pgDn, pgDn, maxn);
  443.         }
  444.     if (fHasVbar) {
  445.         pg= (fRect.bottom - fRect.top) / fItemHeight;
  446.         pgDn= Max(1, pg - 1);
  447.         maxn= Max( fMaxRows - pgDn, 1);
  448.         sb = Nlm_GetSlateVScrollBar((Nlm_SlatE) GetNlmObject());
  449.         if (sb) Nlm_SetRange(sb, pgDn, pgDn, maxn);
  450.         }
  451. }
  452.  
  453. void DTableView::FindLocation()
  454. {
  455.     ViewRect(fRect); //this->GetPosition(fRect); // ?? this isn't changing except w/ resize ??
  456.     Nlm_InsetRect( &fRect, 1, 1);
  457.     SetScrollPage();
  458. }
  459.         
  460. void DTableView::SizeToSuperview( DView* super, Boolean horiz, Boolean vert)
  461. {
  462. #ifndef WIN_MSWIN
  463.     DView::SizeToSuperview(super, horiz, vert);
  464. #else
  465.     Nlm_RecT r, myr;
  466.     super->ViewRect(r);
  467.     ViewRect(myr);
  468.             // these sizes draw off by -1... thus the +1
  469.     if (horiz) {
  470.         myr.left = 0;
  471.         myr.right= myr.left + (r.right - r.left) +1;
  472. #ifdef WIN_MSWIN
  473.         if (fHasVbar) myr.right -= (Nlm_vScrollBarWidth - 8);
  474. #endif
  475.         }
  476.     if (vert) {
  477.         myr.top = 0;
  478.         myr.bottom = myr.top + (r.bottom - r.top) +1;
  479. #ifdef WIN_MSWIN
  480.         if (fHasHbar) myr.bottom -= (Nlm_hScrollBarHeight + 10);
  481. #endif
  482.         }
  483.     SetPosition( myr);
  484. #endif
  485.     this->FindLocation(); //?? added 14Mar94, gopher tables were doing this
  486. }
  487.  
  488.  
  489. void DTableView::Resize(DView* superview, Nlm_PoinT sizechange)
  490. {
  491.         // !! need this fRect change to deal w/ Resize() update event, 
  492.         // which isn't put in a nice event queue, but is done immediately !!
  493.     fRect.right  += sizechange.x;
  494.     fRect.bottom += sizechange.y;
  495.     DPanel::Resize(superview, sizechange);
  496.     FindLocation();
  497. }
  498.  
  499. void DTableView::Scroll(Boolean vertical, DView* scrollee, short newval, short oldval)
  500. {
  501.     Nlm_RecT    r = fRect;
  502.     short delta, i;
  503.     short diff= newval-oldval;
  504.     this->Select(); // need for motif !
  505.     if (vertical) {
  506.  
  507.       if (fHeights) {
  508.         delta= 0;
  509.             if (oldval>newval) {
  510.                 for (i=oldval-1; i>=newval; i--) delta -= fHeights[i];
  511.                 }
  512.         else {
  513.                 for (i=oldval; i<newval; i++) delta += fHeights[i];
  514.                 }
  515.             }
  516.         else
  517.             delta= diff * fItemHeight;
  518.  
  519.         fTop += diff;
  520.         Nlm_ScrollRect (&r, 0, -delta);
  521.         if (diff<0) r.bottom= r.top - delta + Min(10,-delta/2);
  522.         else r.top= r.bottom - delta - Min(10,delta/2);
  523.         }
  524.         
  525.     else {
  526. #if 1
  527.       if (fWidths) {
  528.         delta= 0;
  529.             if (oldval>newval) {
  530.                 for (i=oldval-1; i>=newval; i--) delta -= fWidths[i];
  531.                 }
  532.         else {
  533.                 for (i=oldval; i<newval; i++) delta += fWidths[i];
  534.                 }
  535.             }
  536.         else
  537.             delta= diff * fItemWidth;
  538.             
  539.         fLeft += diff;
  540.         Nlm_ScrollRect (&r, -delta, 0);
  541.         if (diff<0) r.right= Min(r.right, r.left - delta + Min(20,-delta/2));
  542.         else r.left= Max(r.left, r.right - delta - Min(20,delta/2));
  543. #else
  544.         if (fWidths) {
  545.             // fix later, for now redraw all w/o bitscroll
  546.             fLeft += diff;
  547.             }
  548.         else {
  549.             fLeft += diff;
  550.             delta= diff * fItemWidth;
  551.             Nlm_ScrollRect (&r, -delta, 0);
  552.             if (diff<0) r.right= r.left - delta + Min(10,-delta/2);
  553.             else r.left= r.right - delta - Min(10,delta/2);
  554.             }
  555. #endif
  556.         }
  557.     this->InvalRect( r);
  558.   Nlm_Update(); //!? need since took out vibwnds autoupdate for RestorePort
  559. }
  560.             
  561.  
  562. void DTableView::GetRowRect( short row, Nlm_RecT& r, short nrows)
  563. {
  564.     short i;
  565.     r= fRect;
  566.     if (fHeights) {
  567.         for (i= fTop; i<row; i++) r.top += fHeights[i];
  568.         r.bottom= r.top;
  569.         for (i= 0; i<nrows; i++) r.bottom += fHeights[row+i];
  570.         }
  571.     else {
  572.         r.top += (row-fTop) * fItemHeight;
  573.         r.bottom = r.top + nrows*fItemHeight;
  574.         }
  575. }
  576.  
  577. void DTableView::GetColRect( short col, Nlm_RecT& r, short ncols)
  578. {
  579.     short i;
  580.     r= fRect;
  581.     if (fWidths) {
  582.         for (i= fLeft; i<col; i++) r.left += fWidths[i];
  583.         r.right= r.left;
  584.         for (i= 0; i<ncols; i++) r.right += fWidths[col+i];
  585.         }
  586.     else {
  587.         r.left += (col-fLeft) * fItemWidth;
  588.         r.right = r.left + ncols*fItemWidth;
  589.         }
  590. }
  591.  
  592. void DTableView::GetCellRect( short row, short col, Nlm_RecT& r)
  593. {
  594.     short i;
  595.     r= fRect;
  596.     if (fWidths) {
  597.         for (i= fLeft; i<col; i++) r.left += fWidths[i];
  598.         r.right= r.left + fWidths[col];
  599.         }
  600.     else {
  601.         r.left += (col-fLeft) * fItemWidth;
  602.         r.right = r.left + fItemWidth;
  603.         }
  604.     if (fHeights) {
  605.         for (i= fTop; i<row; i++) r.top += fHeights[i];
  606.         r.bottom= r.top + fHeights[row];
  607.         }
  608.     else {
  609.         r.top += (row-fTop) * fItemHeight;
  610.         r.bottom = r.top + fItemHeight;
  611.         }
  612. }
  613.  
  614. void DTableView::GetCellRect(Nlm_RecT cellr, Nlm_RecT& r)
  615. {
  616.     short i;
  617.     r= fRect;
  618.     if (fWidths) {
  619.         for (i= fLeft; i<cellr.left; i++) r.left += fWidths[i];
  620.         r.right= r.left;
  621.         for (i=cellr.left; i<cellr.right; i++) r.right += fWidths[i];
  622.         }
  623.     else {
  624.         r.left += (cellr.left-fLeft) * fItemWidth;
  625.         r.right = r.left + (cellr.right - cellr.left) * fItemWidth;
  626.         }
  627.         
  628.     if (fHeights) {
  629.         for (i= fTop; i<cellr.top; i++) r.top += fHeights[i];
  630.         r.bottom= r.top;
  631.         for (i=cellr.top; i<cellr.bottom; i++) r.bottom += fHeights[i];
  632.         }
  633.     else {
  634.         r.top += (cellr.top-fTop) * fItemHeight;
  635.         r.bottom = r.top + (cellr.bottom - cellr.top) * fItemHeight;
  636.         }
  637. }
  638.  
  639.     
  640. short DTableView::GetSelectedRow()
  641. { 
  642.     return fSelectedRow; 
  643. }
  644.  
  645. short DTableView::GetSelectedCol() 
  646. { 
  647.     return fSelectedCol; 
  648. }
  649.  
  650. void DTableView::GetFirstSelectedCell( short& row, short& col)
  651. { 
  652. #if 0
  653.     row= fSelectedRow; 
  654.     col= fSelectedCol; 
  655. #else
  656.     row= fSelrect.top;
  657.     col= fSelrect.left;
  658. #endif
  659. }
  660.  
  661. void DTableView::GetLastSelectedCell( short& row, short& col)
  662. { 
  663. #if 0
  664.     row= fSelectedRow; 
  665.     col= fSelectedCol; 
  666. #else
  667.     row= fSelrect.bottom;
  668.     col= fSelrect.right;
  669. #endif
  670. }
  671.     
  672.  
  673.  
  674. #ifdef WIN_MOTIF
  675.  
  676. #include <ncbi.h>
  677. #include <ncbidraw.h>
  678. //typedef unsigned long XID; // this is failing in X.h !?
  679. //#define XID  unsigned long
  680. #include <ncbiwin.h>
  681. #include <ncbiport.h>
  682.  
  683. extern Display      *Nlm_currentXDisplay;
  684. extern int          Nlm_currentXScreen;
  685. extern Window       Nlm_currentXWindow;
  686. extern GC           Nlm_currentXGC;
  687. extern Nlm_Uint4    Nlm_XbackColor;
  688. extern Nlm_Uint4    Nlm_XforeColor;
  689. extern Nlm_Int2     Nlm_XOffset;
  690. extern Nlm_Int2     Nlm_YOffset;
  691. extern Nlm_RegioN   Nlm_clpRgn;
  692.  
  693. #endif
  694.  
  695. inline void DTableInvertRect( Nlm_RecT& r)
  696. {    
  697. #ifdef WIN_MOTIF
  698. // vals: GXcopy  GXand  GXor GXequiv GXinvert GXorInverted
  699. // !! GXor looks GOOD for colored x -- makes gray rect
  700. // but isn't reverting to regular on deselect, unless click is in selrect !?? 
  701. // GXxor looks okay at start, but repeated calls mess it up (conflict??)
  702. #define newfunc  GXxor
  703. #define currentFunction  GXcopy
  704. // vals: FillStippled  FillOpaqueStippled  FillSolid  FillTiled
  705. #define newfill  FillStippled
  706. #define currentFillStyle   FillStippled
  707.   Nlm_RectTool  rtool;
  708.  
  709.   if (Nlm_currentXDisplay != NULL &&
  710.       Nlm_currentXWindow != 0 && Nlm_currentXGC != NULL) {
  711.     rtool.x = MIN (r.left, r.right);
  712.     rtool.y = MIN (r.top, r.bottom);
  713.     rtool.width = ABS (r.right - r.left);
  714.     rtool.height = ABS (r.bottom - r.top);
  715.  
  716.     XSetFunction (Nlm_currentXDisplay, Nlm_currentXGC, newfunc);
  717.     XSetFillStyle (Nlm_currentXDisplay, Nlm_currentXGC, newfill);
  718.     XFillRectangle (Nlm_currentXDisplay, Nlm_currentXWindow, Nlm_currentXGC,
  719.                     rtool.x - Nlm_XOffset, rtool.y - Nlm_YOffset,
  720.                     rtool.width, rtool.height);
  721.     XSetFunction (Nlm_currentXDisplay, Nlm_currentXGC, currentFunction);
  722.     XSetFillStyle (Nlm_currentXDisplay, Nlm_currentXGC, currentFillStyle);
  723.    }
  724.  
  725. #if 0
  726.     Nlm_InvertMode();
  727.     Nlm_FillRect( &r);
  728.     Nlm_CopyMode();
  729. #endif
  730.  
  731. #else
  732.     // patched both Nlm_InvertMode & Nlm_InvertRect for Motif
  733.   Nlm_InvertRect( &r);
  734. #endif 
  735. }
  736.  
  737. void DTableView::InvertRect( Nlm_RecT& r)
  738. {    
  739.     Nlm_WindoW w= Nlm_SavePort( fNlmObject);
  740. #ifdef WIN_MOTIF
  741.     this->Select();
  742. #endif
  743.     ::DTableInvertRect( r);
  744.     if (w) Nlm_UseWindow (w); 
  745. }
  746.  
  747. void DTableView::InvertSelection()
  748. {    
  749.     Nlm_RecT r, r2;
  750.     if (!Nlm_EmptyRect(&fSelrect)) {
  751.         r2= fSelrect;
  752.         //r2.bottom--;
  753.         //r2.right--;
  754.         GetCellRect( r2, r);
  755.         }
  756.     else if (fSelectedRow>=0 && fSelectedCol>=0) 
  757.         GetCellRect( fSelectedRow, fSelectedCol, r);
  758.     else if (fSelectedRow>=0) 
  759.         GetRowRect( fSelectedRow, r);
  760.     else if (fSelectedCol>=0) 
  761.         GetRowRect( fSelectedCol, r);
  762.   else
  763.       return;
  764.     InvertRect( r);
  765. }
  766.  
  767.  
  768.  
  769. void DTableView::DoubleClickAt(short row, short col)
  770. {
  771. }
  772.  
  773.  
  774. void DTableView::SingleClickAt(short row, short col)
  775. {
  776.     Nlm_PoinT pt;
  777.     pt.x= col; pt.y= row;
  778.     if (Nlm_PtInRect( pt, &fSelrect) && !gKeys->shift()) {
  779.         SetEmptySelection( true);
  780.         }
  781.     else {
  782.         SelectCells(  row, col, gKeys->shift(), kHighlight, kSelect);
  783.         }
  784. }
  785.             
  786.  
  787. void DTableView::PointToCell(Nlm_PoinT mouse, short& row, short& col)
  788. {
  789.     if (fHeights) {
  790.         row= fTop - 1;
  791.         short yrow= fRect.top;
  792.         do {
  793.             row++;
  794.             if (row<=fMaxRows) yrow += fHeights[row];
  795.             else yrow= mouse.y;
  796.             } while (yrow < mouse.y);
  797.         }
  798.     else
  799.         row= fTop  + (mouse.y - fRect.top)  / fItemHeight;
  800.  
  801.     if (fWidths) {
  802.         col= fLeft - 1;
  803.         short xcol= fRect.left;
  804.         do {
  805.             col++;
  806.             if (col<=fMaxCols) xcol += fWidths[col];
  807.             else xcol= mouse.x;
  808.             } while (xcol < mouse.x);
  809.         }
  810.     else
  811.         col= fLeft + (mouse.x - fRect.left) / fItemWidth;
  812. }
  813.  
  814.  
  815.  
  816. void DTableView::Click(Nlm_PoinT mouse)
  817. {
  818.     short row, col;
  819.     
  820.     //if (gLastCommand) gLastCommand->Commit();    //?? prevent bombs from prev. cmds ?
  821.     //if (fCurrentTracker) fCurrentTracker->Reset();
  822.     SetTracker( fCurrentTracker); // ??  make new one each click?
  823.     DAutoPanel::Click(mouse);         // sets fMouseStillDown= false
  824.  
  825.     if (!fCurrentTracker) {
  826.         // TrackMouse::trackEnd does this now, if click is tracked...
  827.         PointToCell( mouse, row, col);
  828.         if (row >=0 && row < fMaxRows && col >= 0 && col < fMaxCols) {
  829.             if (Nlm_dblClick) DoubleClickAt( row, col);
  830.             else SingleClickAt( row, col);
  831.             }
  832.         }
  833. }
  834.  
  835. void DTableView::Drag(Nlm_PoinT mouse)
  836. {
  837.     DAutoPanel::Drag(mouse); // sets fMouseStillDown= true,... 
  838. }
  839.  
  840. void DTableView::Release(Nlm_PoinT mouse)
  841. {
  842.     DAutoPanel::Release(mouse); // sets fMouseStillDown= false,... 
  843. }
  844.  
  845.  
  846. void DTableView::TrackMouse( short aTrackPhase,
  847.                     Nlm_PoinT& anchorPoint, Nlm_PoinT& previousPoint,
  848.                     Nlm_PoinT& nextPoint,    Nlm_Boolean mouseDidMove)
  849. {
  850.  
  851.     switch (aTrackPhase) {
  852.     
  853.         case DTracker::trackBegin:
  854.             if (gKeys->shift()) {  
  855.                 Nlm_PoinT pt;
  856.                 Nlm_RecT  pixr;
  857.                 short    diff1, diff2;
  858.                 
  859.                 GetCellRect( fSelrect, pixr);
  860.                 diff1= anchorPoint.x - pixr.left;
  861.                 diff2= anchorPoint.x - pixr.right;
  862.                 if (abs(diff1) > abs(diff2)) pt.x= pixr.left; 
  863.                 else pt.x= pixr.right;
  864.                 diff1= anchorPoint.y - pixr.top;
  865.                 diff2= anchorPoint.y - pixr.bottom;
  866.                 if (abs(diff1) > abs(diff2)) pt.y= pixr.top; 
  867.                 else pt.y= pixr.bottom;
  868.                 
  869.                 // tracker::Start makes 3 pts all same
  870.                 anchorPoint = pt;
  871.                 previousPoint = pt;
  872.                 nextPoint = pt;
  873.                 //fTracker->fMovedOnce= true; // force it for single-click extend?
  874.                 }
  875.              break;
  876.     
  877.         case DTracker::trackContinue:
  878.             break;
  879.             
  880.         case DTracker::trackEnd:
  881.             {
  882.             short row, col;
  883.             Boolean moved= gKeys->shift() // extend
  884.                     || abs(anchorPoint.x - nextPoint.x) > 2
  885.                     || abs(anchorPoint.y - nextPoint.y) > 2;
  886.             if (!moved) {
  887.                 PointToCell( nextPoint, row, col);
  888.                 if (row >=0 && row < fMaxRows && col >= 0 && col < fMaxCols) {
  889.                     if (Nlm_dblClick) DoubleClickAt( row, col);
  890.                     else SingleClickAt( row, col);
  891.                     }
  892.                 }
  893.             }
  894.             break;
  895.             
  896.         }
  897. }
  898.  
  899. void DTableView::TrackFeedback( short aTrackPhase,
  900.                     const Nlm_PoinT& anchorPoint, const Nlm_PoinT& previousPoint,
  901.                     const Nlm_PoinT& nextPoint, Nlm_Boolean mouseDidMove, Nlm_Boolean turnItOn)
  902. {
  903.     if (mouseDidMove) {
  904.         Nlm_RecT    pixr;
  905.  
  906.         pixr.left= MIN( anchorPoint.x, nextPoint.x);
  907.         pixr.right= MAX( anchorPoint.x, nextPoint.x);
  908.         pixr.top= MIN( anchorPoint.y, nextPoint.y);
  909.         pixr.bottom= MAX( anchorPoint.y, nextPoint.y);
  910.         
  911.         Nlm_InsetRect( &pixr, 1,1); //??
  912.         Nlm_InvertMode();
  913.         Nlm_FrameRect( &pixr);
  914.         Nlm_CopyMode();
  915.         }
  916. }
  917.  
  918.  
  919.  
  920.  
  921. void DTableView::DrawCell(Nlm_RecT r, short row, short col)
  922. {
  923.     char    snum[80];
  924.     sprintf(snum,"r%d,c%d", row, col);
  925.     Nlm_DrawString( &r, snum, 'c', false);
  926. }
  927.     
  928. void DTableView::DrawRow(Nlm_RecT r, short row)
  929. {
  930.     short col = fLeft; 
  931.     if (fWidths && col <= fMaxCols) r.right= r.left + fWidths[col];
  932.     else r.right= r.left + fItemWidth;
  933.     while (r.left < fRect.right && col < fMaxCols) {
  934.         if (Nlm_RectInRgn (&r, Nlm_updateRgn))  
  935.             DrawCell( r, row, col);
  936.         if (fWidths) {
  937.             Nlm_OffsetRect( &r, fWidths[col], 0);
  938.             r.right= r.left + fWidths[col+1];
  939.             }
  940.         else
  941.             Nlm_OffsetRect( &r, fItemWidth, 0);
  942.         col++;
  943.         }
  944.     fColsDrawn= col - fLeft;
  945. }
  946.  
  947.  
  948. void DTableView::GetPageCount(Nlm_RecT pagerect, short& rowpages, short& colpages)
  949. {
  950.     long left, top, row, col;     
  951.     rowpages= colpages= 1;
  952.     
  953.     for (col=0, left=0; col < fMaxCols; col++) {
  954.         if (fWidths) left += fWidths[col];  
  955.         else left += fItemWidth;
  956.         if (left >= pagerect.right) { 
  957.             colpages++; 
  958.             left= 0; 
  959.             }
  960.         }
  961.     for (row=0, top=0; row < fMaxRows; row++) {
  962.         if (fHeights) top += fHeights[row];  
  963.         else top += fItemHeight;
  964.         if (top >= pagerect.bottom) { 
  965.             rowpages++; 
  966.             top= 0; 
  967.             }
  968.         }
  969. }
  970.  
  971.  
  972. void DTableView::Draw()
  973. {
  974.     Nlm_RecT         r2, r = fRect;
  975.     Nlm_PoinT      pt;
  976.     short             row = fTop; 
  977.     Boolean            hasSel;
  978.     
  979.     if (fHeights) r.bottom= r.top + fHeights[row];
  980.     else r.bottom= r.top + fItemHeight;
  981.     Nlm_SelectFont(fFont); //?? here
  982.     hasSel= !Nlm_EmptyRect(&fSelrect);
  983.     if (hasSel) {
  984.         pt.x= fSelrect.left;
  985.         r2= fSelrect;
  986.         GetCellRect( r2, r2);
  987.         }
  988.         
  989.     while (r.top < fRect.bottom && row < fMaxRows) {
  990.         if (Nlm_RectInRgn (&r, Nlm_updateRgn)) { 
  991.             DrawRow( r, row);
  992.              pt.y= row;
  993.              if (hasSel && Nlm_PtInRect( pt, &fSelrect)) {
  994.                  Nlm_RecT ir= r;
  995.                  ir.left= r2.left;
  996.                  ir.right= r2.right;
  997.                 InvertRect( ir);
  998.                  }
  999.           }
  1000.         if (fHeights) {
  1001.             Nlm_OffsetRect( &r, 0, fHeights[row]);
  1002.             r.bottom= r.top + fHeights[row+1];
  1003.             }
  1004.         else
  1005.             Nlm_OffsetRect( &r, 0, fItemHeight);
  1006.         row++;
  1007.         }
  1008. }
  1009.         
  1010.  
  1011. enum { kWritingAsPICT = 9 };
  1012.  
  1013. void DTableView::ViewRect(Nlm_RecT& r) 
  1014. { 
  1015.     if (fIsPrinting == kWritingAsPICT) {
  1016.         r= fRect; // fRect is set at start of AsPICT
  1017.         }
  1018.     else if (fIsPrinting) {
  1019.         r= fRect; //fRect is set at start of Print 
  1020.         // Nlm_PrintingRect(&r);
  1021.         }
  1022.     else
  1023.         DView::ViewRect(r);  
  1024. }
  1025.         
  1026. void DTableView::Print()  
  1027. {
  1028. #if (defined(WIN_MAC) || defined (WIN_MSWIN))
  1029.   Nlm_WindoW    w;
  1030.   Boolean           goOn, newPage, widerThanPage;
  1031.   Nlm_RecT        pager, r, saverect;
  1032.     short                 row = 0, rowpages, colpages; 
  1033.     long                    saveleft;
  1034.     
  1035.     // problems: assumes each row < page height
  1036.     
  1037.   w = Nlm_StartPrinting();
  1038.   if (w) {
  1039.       fIsPrinting= true;
  1040.         gCursor->watch();    
  1041.         saverect= fRect;
  1042.         Nlm_PrintingRect(&pager);
  1043.         fRect= pager;
  1044.         Nlm_SelectFont(fFont); 
  1045.         saveleft= fLeft; fLeft= 0; 
  1046.         //savetop= fTop; fTop= 0; 
  1047.         GetPageCount( pager, rowpages, colpages);
  1048.         
  1049.     newPage = true;
  1050.     goOn = row < fMaxRows;
  1051.     widerThanPage= colpages > 1; 
  1052.     
  1053.     // make update region large...
  1054.     if (Nlm_updateRgn != NULL)  
  1055.             Nlm_LoadRectRgn(Nlm_updateRgn, -32767, -32767, 32767, 32767);
  1056.     
  1057.     while (goOn) {
  1058.     
  1059.       if (newPage) {
  1060.         goOn = Nlm_StartPage();
  1061.         newPage = false;
  1062.           r= pager;
  1063.           
  1064.                 if (fHeights) r.bottom= r.top + fHeights[row];
  1065.                 else r.bottom= r.top + fItemHeight;
  1066.            }
  1067.       
  1068.       if (goOn) {
  1069.                 fColsDrawn= fMaxCols; // in case DrawRow forgets to set this
  1070.                 DrawRow( r, row);
  1071.                 
  1072.                 if (widerThanPage) {
  1073.                   fLeft +=     fColsDrawn;
  1074.                     newPage = (fLeft < fMaxCols);
  1075.                     if (newPage) goOn = Nlm_EndPage();    
  1076.                     else fLeft= 0;
  1077.                     }
  1078.                 
  1079.                 if (!newPage) {    
  1080.                     if (fHeights) {
  1081.                         Nlm_OffsetRect( &r, 0, fHeights[row]);
  1082.                         r.bottom= r.top + fHeights[row+1];
  1083.                         }
  1084.                     else
  1085.                         Nlm_OffsetRect( &r, 0, fItemHeight);
  1086.                     newPage = (r.bottom > pager.bottom);
  1087.                     if (newPage) goOn = Nlm_EndPage();    
  1088.                     row++;
  1089.                     if (goOn) goOn= (row < fMaxRows);
  1090.                     }
  1091.                     
  1092.                 }
  1093.             }
  1094.             
  1095.           if (!newPage) (void) Nlm_EndPage();
  1096.       Nlm_EndPrinting(w);
  1097.         fIsPrinting= false;
  1098.         fRect= saverect;
  1099.         fLeft= saveleft;
  1100.         gCursor->arrow();
  1101.         }       
  1102. #else
  1103.     Nlm_Message(MSG_OK,"Printing is not yet defined for this window system");
  1104. #endif
  1105. }
  1106.  
  1107.  
  1108. #ifdef WIN_MAC
  1109. #undef Handle
  1110. #undef true
  1111. #undef false
  1112. #undef Rect
  1113. #include <QuickDraw.h>
  1114. #include <Memory.h>
  1115. #endif
  1116.  
  1117. #ifdef WIN_MSWIN
  1118. #include <windows.h>
  1119. extern "C" HWND         Nlm_currentHWnd;
  1120. extern "C" HDC          Nlm_currentHDC;
  1121. #endif
  1122.  
  1123. void DTableView::WriteToPICT(DFile* afile)  
  1124. {
  1125.     if (!afile) return;
  1126.     
  1127. #ifdef WIN_MAC
  1128.   Nlm_RecT        pager, saverect, cellr;
  1129.     
  1130.     gCursor->watch();    
  1131.     saverect= fRect;
  1132.      fIsPrinting= kWritingAsPICT;
  1133.      Nlm_LoadRect( &cellr, 0, 0, fMaxCols, fMaxRows);
  1134.     this->GetCellRect( cellr, pager);
  1135.     fRect= pager;
  1136.     
  1137.   Rect  picrect;
  1138.   picrect.left= pager.left;
  1139.   picrect.right= pager.right;
  1140.   picrect.top = pager.top;
  1141.   picrect.bottom= pager.bottom;
  1142.     Handle pic= (Handle) OpenPicture( &picrect); 
  1143.     
  1144.   if (pic) { 
  1145.       enum { kPicHeadsize = 512 };
  1146.       ulong count;
  1147.         // make update region large...
  1148.     if (Nlm_updateRgn != NULL)  
  1149.             Nlm_LoadRectRgn(Nlm_updateRgn, -32767, -32767, 32767, 32767);
  1150.     Draw();                
  1151.       ClosePicture();
  1152.       
  1153.           // now write pic to file
  1154.       afile->Delete();
  1155.       afile->Create("PICT","ttxt"); 
  1156.         afile->Open("wb"); // Damn "wb" -- must by BINARY 
  1157.       count= kPicHeadsize;
  1158.       char * header = (char *) Nlm_MemGet(kPicHeadsize,MGET_CLEAR);
  1159.       afile->WriteData( header, count);
  1160.       Nlm_MemFree( header);
  1161.         HLock(pic);
  1162.       count= GetHandleSize(pic);
  1163.       afile->WriteData( *pic, count);
  1164.       afile->Close();
  1165.       HUnlock(pic);
  1166.       KillPicture ( (PicHandle)pic);
  1167.         } 
  1168.     fIsPrinting= false;        
  1169.     fRect= saverect;
  1170.     gCursor->arrow();
  1171.     return;
  1172. #endif
  1173.  
  1174. #ifdef WIN_MSWIN
  1175.   Nlm_RecT        pager, saverect, cellr;
  1176.     
  1177.     gCursor->watch();    
  1178.     saverect= fRect;
  1179.      fIsPrinting= kWritingAsPICT;
  1180.      Nlm_LoadRect( &cellr, 0, 0, fMaxCols, fMaxRows);
  1181.     this->GetCellRect( cellr, pager);
  1182.     fRect= pager;
  1183.     
  1184.     char* fname= (char*) afile->GetName();
  1185.     HDC hdcMeta= CreateMetaFile(fname);
  1186.   if (hdcMeta) { 
  1187.       HDC savehdc= Nlm_currentHDC;
  1188.       Nlm_currentHDC= hdcMeta;  
  1189.       SetMapMode( hdcMeta, MM_ANISOTROPIC);
  1190.       Nlm_ResetDrawingTools();
  1191.       
  1192.         // make update region large...
  1193.     if (Nlm_updateRgn != NULL)  
  1194.             Nlm_LoadRectRgn(Nlm_updateRgn, -32767, -32767, 32767, 32767);
  1195.     Draw();  
  1196.       
  1197.       HMETAFILE hmf = CloseMetaFile( hdcMeta);
  1198.       DeleteMetaFile( hmf); // just deletes handle, not disk file !
  1199.       Nlm_currentHDC= savehdc;  
  1200.         }       
  1201.     fIsPrinting= false;        
  1202.     fRect= saverect;
  1203.     gCursor->arrow();
  1204.     return;
  1205. #endif
  1206.       
  1207.     Nlm_Message(MSG_OK,"DrawToPicture is not yet defined for this window system");
  1208. }
  1209.  
  1210.