home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Demos / A.D. Software / OOFILE / Buildable, limited OOFILE / source / GUI / Mac / PPlant / oofpp.cpp < prev    next >
Encoding:
Text File  |  1996-03-23  |  17.1 KB  |  867 lines  |  [TEXT/CWIE]
  1. // COPYRIGHT 1995 A.D. Software, All rights reserved
  2.  
  3. // PowerPlant Integration layer of OOFILE database
  4. #include "oofppx.hpp"  // private interface, includes public
  5. #include "oof4.hpp"    // extra field definitions
  6. #include "oofview.hpp"
  7.  
  8. #include "stdlib.h"
  9. #ifdef _Windows
  10.     #include <strstrea.h>
  11. #else
  12.     #include <strstream.h>
  13. #endif
  14. #include "fstream.h"
  15.  
  16.  
  17.  
  18.  
  19. // include PowerPlant definitions
  20. #include <LEditField.h>
  21. #include <LListBox.h>
  22. #include <LTextEdit.h>
  23. #include <UMemoryMgr.h>
  24. #include <PP_Messages.h>
  25.  
  26.  
  27. // static variables
  28. dbDocHelper*  dbDocHelper::sCurrentDoc = 0;
  29.  
  30. // -------------------------------------------------------
  31. //                 d b D o c H e l p e r
  32. // -------------------------------------------------------
  33. dbDocHelper::dbDocHelper() :
  34.     mAddFactory(0), 
  35.     mEditFactory(0), 
  36.     mBrowseFactory(0),
  37.     mInterestedInRecordChanges(0)
  38. {};
  39.  
  40.  
  41. dbDocHelper::~dbDocHelper()
  42. {
  43.     delete mAddFactory;
  44.     delete mEditFactory;
  45.     delete mBrowseFactory;
  46.     
  47. }
  48.  
  49.  
  50. // the following pair of methods hint at a need to have some more 
  51. // general dependency mechanism, probably as a mixin.
  52. // it WILL happen, once we've used this approach for a couple of apps
  53. // but will be transparent to clients of these classes anyway
  54. // as these dependencies are only within the framework
  55.  
  56. void dbDocHelper::recordHasBeenChanged(dbWindowHelper* changedBy)
  57. {
  58.     if (mInterestedInRecordChanges) {
  59.         mInterestedInRecordChanges->recordHasBeenChanged(changedBy);
  60.     }
  61. }
  62.  
  63.  
  64. void dbDocHelper::interestedInRecordChanges(dbWindowHelper* interestedParty)
  65. {
  66.     mInterestedInRecordChanges = interestedParty;  // this would later be a list
  67. }
  68.  
  69.  
  70. // slightly sloppy duplicated code for now, this area is likely to change
  71. // so not worth investing time simplifying
  72. void dbDocHelper::AdoptAddDialogFactory(dbWindowFactory* factory)
  73. {
  74. #ifdef OOF_Debug
  75.     if (mAddFactory)
  76.         dbConnect::raise("dbDocHelper::adoptAddDialogFactory replacing current factory");
  77. #endif
  78.     delete mAddFactory;
  79.     mAddFactory = factory;
  80. }
  81.  
  82.  
  83. void dbDocHelper::AdoptEditDialogFactory(dbWindowFactory* factory)
  84. {
  85. #ifdef OOF_Debug
  86.     if (mEditFactory)
  87.         dbConnect::raise("dbDocHelper::adoptEditDialogFactory replacing current factory");
  88. #endif
  89.     delete mEditFactory;
  90.     mEditFactory = factory;
  91. }
  92.  
  93.  
  94.  
  95. void dbDocHelper::AdoptBrowseWindowFactory(dbWindowFactory* factory)
  96. {
  97. #ifdef OOF_Debug
  98.     if (mBrowseFactory)
  99.         dbConnect::raise("dbDocHelper::adoptBrowseWindowFactory replacing current factory");
  100. #endif
  101.     delete mBrowseFactory;
  102.     mBrowseFactory = factory;
  103.     mMainTable = factory->mainTable();
  104. }
  105.  
  106.  
  107. bool dbDocHelper::OOFILEhandlesMessage(const Int32    inMessage, void     *ioParam)
  108. {
  109.     switch (inMessage) {
  110.     case 'dNew':
  111.         NewRecord();
  112.         return true;
  113.  
  114.     default:
  115.         return false;
  116.     }
  117.     return false;
  118. }
  119.  
  120.  
  121. LWindow* dbDocHelper::MakeBrowser()
  122. {
  123.     if (mBrowseFactory) {
  124.         sCurrentDoc = this;
  125.         return mBrowseFactory->makeWindow();
  126.     }
  127.     else
  128.         return NULL;
  129. }
  130.  
  131.  
  132. LWindow* dbDocHelper::NewRecord()
  133. {
  134.     if (mAddFactory) {
  135.         sCurrentDoc = this;
  136.         mMainTable->newRecord();
  137.         return mAddFactory->makeWindow(false);
  138.     }
  139.     else
  140.         return NULL;
  141. }
  142.  
  143.  
  144. LWindow* dbDocHelper::MakeEditor()
  145. {
  146.     if (mEditFactory) {
  147.         sCurrentDoc = this;
  148.         return mEditFactory->makeWindow(true);
  149.     }
  150.     else
  151.         return NULL;
  152. }
  153.  
  154.  
  155.  
  156. // -------------------------------------------------------
  157. //                 d b W i n d o w H e l p e r
  158. // -------------------------------------------------------
  159.  
  160. dbWindowHelper::dbWindowHelper()
  161. {
  162.     LinkToDoc();
  163. }
  164.                             
  165.  
  166. void dbWindowHelper::LinkToDoc()
  167. {
  168.     mBossDoc = dbDocHelper::sCurrentDoc;
  169. }
  170.  
  171.  
  172. // -------------------------------------------------------
  173. //                 d b B r o w s e H e l p e r
  174. // -------------------------------------------------------
  175.  
  176. dbBrowseHelper::dbBrowseHelper() : 
  177.     mBrowsingView(0),
  178.     mBrowserDisplay(0)
  179. {
  180.     mBossDoc->interestedInRecordChanges(this);
  181. }
  182.  
  183.  
  184. dbBrowseHelper::~dbBrowseHelper() 
  185. {
  186.     delete mBrowsingView;
  187.     delete mBrowserDisplay;
  188. }
  189.  
  190.  
  191. void dbBrowseHelper::recordHasBeenChanged(dbWindowHelper* changedBy)
  192. {
  193.     RefreshBrowser();
  194. }
  195.  
  196.  
  197. bool dbBrowseHelper::OOFILEhandlesMessage(
  198.     const Int32    inMessage,
  199.     void        *ioParam)
  200. {
  201.     switch (inMessage) {
  202.     case cmd_dbNew:
  203.         mBossDoc->NewRecord();
  204.         // scope for us to react afterwards
  205.         return true;
  206.  
  207.     case cmd_dbDoubleClick:
  208.     case cmd_dbEdit:
  209.         if (mBrowserDisplay)
  210.             mBrowsingView->source()->gotoRecord(mBrowserDisplay->selectedRow());
  211.         mBossDoc->MakeEditor();
  212.         // scope for us to react afterwards
  213.         return true;
  214.  
  215.     case cmd_dbDel:
  216.         DelRecord();
  217.         return true;
  218.  
  219.     default:
  220.         return false;
  221.     }
  222.     return false;
  223. }
  224.  
  225.  
  226. void dbBrowseHelper::DelRecord()
  227. {
  228.     SysBeep(30);  // not implemented in demo
  229. }
  230.  
  231.  
  232. void dbBrowseHelper::AdoptView(dbView* theView)
  233. {
  234.     if (mBrowsingView)
  235.         if (mBrowserDisplay)
  236.             mBrowserDisplay->changeViewTo(theView);
  237.     delete mBrowsingView;
  238.     mBrowsingView = theView;
  239. }
  240.  
  241.  
  242. void dbBrowseHelper::BrowseViewWithListBox(LListBox* inLB)
  243. {
  244. #ifdef OOF_Debug
  245.     if (mBrowserDisplay)
  246.         dbConnect::raise("dbBrowseHelper::BrowseViewWithListBox replacing current browser display");
  247. #endif
  248.     delete mBrowserDisplay;
  249.     mBrowserDisplay = new dbListBoxDisplay(inLB, mBrowsingView);
  250. }
  251.  
  252.  
  253. void dbBrowseHelper::BrowseViewWithTable(LStrTableView* inTable)
  254. {
  255. #ifdef OOF_Debug
  256.     if (mBrowserDisplay)
  257.         dbConnect::raise("dbBrowseHelper::BrowseViewWithTable replacing current browser display");
  258. #endif
  259.     delete mBrowserDisplay;
  260.     mBrowserDisplay = new dbTableViewDisplay(inTable, mBrowsingView);
  261. }
  262.  
  263.  
  264. void dbBrowseHelper::LoadBrowseData()
  265. {
  266.     if (mBrowserDisplay) 
  267.         mBrowserDisplay->loadData();
  268. }
  269.  
  270.  
  271. void dbBrowseHelper::RefreshBrowser()
  272. {
  273.     if (mBrowserDisplay) 
  274.         mBrowserDisplay->loadData();  // force reload as only way to reset num rows
  275. }
  276.  
  277.  
  278. // -------------------------------------------------------
  279. //                 d b E d i t H e l p e r
  280. // -------------------------------------------------------
  281.  
  282. dbEditHelper::dbEditHelper() :
  283.                             mNew(false),
  284.                             mChangingPages(false),
  285.                             mAutoSaveOnMoving(true),
  286.                             mMainTable(0)
  287. {
  288. }
  289.  
  290.  
  291. dbEditHelper::~dbEditHelper()
  292. {
  293.     mLinks.deleteAll();
  294.     delete mMainTable;
  295. }
  296.  
  297.  
  298. void dbEditHelper::LinkField(dbChar* fld, LEditField* ctl)
  299. {
  300.     mLinks.append(new dbCharLink2EditField(fld, ctl));
  301. }
  302.  
  303.  
  304. void dbEditHelper::LinkField(dbChar* fld, LTextEdit* ctl)
  305. {
  306.     mLinks.append(new dbCharLink2TextEdit(fld, ctl));
  307. }
  308.  
  309.  
  310. void dbEditHelper::LinkField(dbText* fld, LTextEdit* ctl)
  311. {
  312.     mLinks.append(new dbTextLink2TextEdit(fld, ctl));
  313. }
  314.  
  315.  
  316. void dbEditHelper::LinkField(dbLong* fld, LEditField* ctl)
  317. {
  318.     mLinks.append(new dbLongLink2EditField(fld, ctl));
  319. }
  320.  
  321.  
  322. void dbEditHelper::LinkField(dbShort* fld, LEditField* ctl)
  323. {
  324.     mLinks.append(new dbShortLink2EditField(fld, ctl));
  325. }
  326.  
  327.  
  328. void dbEditHelper::LinkField(dbDate* fld, LEditField* ctl)
  329. {
  330.     mLinks.append(new dbDateLink2EditField(fld, ctl));
  331. }
  332.  
  333.  
  334. void dbEditHelper::GoFirstRecord()
  335. {
  336.     assert(mMainTable);
  337.     if (mMainTable->atFirst()) 
  338.         SysBeep(30);
  339.     else
  340.     {
  341.         if(LeaveRecord()) {
  342.             mMainTable->first();
  343.             LoadData();
  344.         }
  345.     }
  346. }
  347.  
  348.  
  349. void dbEditHelper::GoNextRecord()
  350. {
  351.     assert(mMainTable);
  352.     if (mMainTable->atLast()) 
  353.         SysBeep(30);
  354.     else
  355.     {
  356.         if(LeaveRecord()) {
  357.             mMainTable->next();
  358.             LoadData();
  359.         }
  360.     }
  361. }
  362.  
  363.  
  364. void dbEditHelper::GoPrevRecord()
  365. {
  366.     assert(mMainTable);
  367.     if (mMainTable->atFirst()) 
  368.         SysBeep(30);
  369.     else
  370.     {
  371.         if(LeaveRecord()) {
  372.             mMainTable->prev();
  373.             LoadData();
  374.         }
  375.     }
  376. }
  377.  
  378.  
  379. void dbEditHelper::GoLastRecord()
  380. {
  381.     assert(mMainTable);
  382.     if (mMainTable->atLast()) 
  383.         SysBeep(30);
  384.     else
  385.     {
  386.         if(LeaveRecord()) {
  387.             mMainTable->last();
  388.             LoadData();
  389.         }
  390.     }
  391. }
  392.  
  393.  
  394. bool dbEditHelper::LeaveRecord()
  395. {
  396.     if(CanLeaveRecord()) {
  397.         if (mAutoSaveOnMoving)
  398.             SaveRecord();
  399.         return true;
  400.     }
  401.     else
  402.         return false;  // user-override says NO
  403. }
  404.  
  405.  
  406. void dbEditHelper::LoadData()
  407. {
  408.     assert(mMainTable);        // should be setup by now!
  409.     EnteringAboutToLoad();    // user hook
  410.     CopyFieldsToLinks();
  411.     EnteringAfterLoad();    // user hook
  412. }
  413.  
  414.  
  415. void dbEditHelper::SaveRecord()
  416. {
  417.     assert(mMainTable);        // should be setup by now!
  418.     LeavingAboutToSave();    // user hook
  419.     CopyLinksToFields();
  420.     mMainTable->saveRecord();
  421.     LeavingAfterSave();        // user hook
  422.     mBossDoc->recordHasBeenChanged(this);  // will be more intelligent later about if record is REALLY changed
  423. }
  424.  
  425.  
  426. void dbEditHelper::warnUser(ostream& os)
  427. {
  428. #ifdef _Windows
  429.     strstream oss;
  430.     oss << os.rdbuf() << ends;
  431.     char* s = oss.str();
  432.     ::MessageBox(0, s, "Warning", MB_ICONEXCLAMATION);
  433.     oss.rdbuf()->freeze(0);  // leave buffer for stream to delete
  434. #else
  435.     cout << os.rdbuf();
  436. #endif
  437. }
  438.  
  439.  
  440.  
  441. void dbEditHelper::CopyLinksToFields()
  442. {
  443.     int numLinks = mLinks.count();
  444.     for (int i=0; i<numLinks; i++) {
  445.         dbFieldLink* fl = (dbFieldLink*) (mLinks[i]);  // safe downcast
  446.         fl->copyLinkToField();        
  447.         mLinks.next();
  448.     }
  449. }
  450.  
  451.  
  452. void dbEditHelper::CopyFieldsToLinks()
  453. {
  454.     int numLinks = mLinks.count();
  455.     for (int i=0; i<numLinks; i++) {
  456.         dbFieldLink* fl = (dbFieldLink*) (mLinks[i]);  // safe downcast
  457.         fl->copyFieldToLink();
  458.         mLinks.next();
  459.     }
  460. }
  461.  
  462.  
  463. bool dbEditHelper::OOFILEhandlesMessage(
  464.     const Int32    inMessage,
  465.     void        *ioParam)
  466. {
  467.     switch (inMessage) {
  468.     case msg_OK:
  469.         if(CanLeaveRecord()) {
  470.             SaveRecord();
  471.             LCommander::GetDefaultCommander()->ProcessCommand(cmd_Close, ioParam);
  472.         }
  473.         return true;
  474.  
  475.     case msg_Cancel:
  476.             LCommander::GetDefaultCommander()->ProcessCommand(cmd_Close, ioParam);
  477.         return true;
  478.  
  479.     case cmd_dbFirst:
  480.         GoFirstRecord();
  481.         return true;
  482.  
  483.     case cmd_dbPrev:
  484.         GoPrevRecord();
  485.         return true;
  486.  
  487.     case cmd_dbNext:
  488.         GoNextRecord();
  489.         return true;
  490.  
  491.     case cmd_dbLast:
  492.         GoLastRecord();
  493.         return true;
  494.  
  495.     default:
  496.         return false;
  497.     }
  498.     return false;
  499. }
  500.  
  501.  
  502.  
  503. // -------------------------------------------------------
  504. //        d b C h a r  L i n k 2 E d i t F i e l d
  505. // -------------------------------------------------------
  506. void dbCharLink2EditField::copyFieldToLink()
  507. {
  508.     Str255 str;
  509.     mField->asStr255(str);
  510.     mLinkTo->SetDescriptor(str);
  511. }
  512.  
  513.  
  514. void dbCharLink2EditField::copyLinkToField()
  515. {
  516.     Str255 str;
  517.     mLinkTo->GetDescriptor(str);
  518.     mField->setStr255(str);
  519. }
  520.  
  521.  
  522.  
  523. // -------------------------------------------------------
  524. //        d b C h a r L i n k 2 T e x t E d i t
  525. // -------------------------------------------------------
  526. void dbCharLink2TextEdit::copyFieldToLink()
  527. {
  528.     const char* c = *mField;
  529.     Ptr p = const_cast<Ptr>(c);
  530.     mLinkTo->SetTextPtr(p, mField->fieldDataLen());
  531. }
  532.  
  533.  
  534. void dbCharLink2TextEdit::copyLinkToField()
  535. {
  536.     TEHandle th = mLinkTo->GetMacTEH();
  537.     Handle h = (Handle) ::TEGetText(th);
  538.     StHandleLocker playSafe(h);
  539.     mField->setChars((char*) *h, (*th)->teLength);
  540. }
  541.  
  542.  
  543. // -------------------------------------------------------
  544. //        d b T e x t L i n k 2 T e x t E d i t
  545. // -------------------------------------------------------
  546. void dbTextLink2TextEdit::copyFieldToLink()
  547. {
  548.     const char* c = *mField;
  549.     Ptr p = const_cast<Ptr>(c);
  550.     mLinkTo->SetTextPtr(p, mField->fieldDataLen());
  551. }
  552.  
  553.  
  554. void dbTextLink2TextEdit::copyLinkToField()
  555. {
  556.     Handle h = mLinkTo->GetTextHandle();
  557.     StHandleLocker playSafe(h);
  558.     mField->setChars((char*) *h, GetHandleSize(h));
  559. }
  560.  
  561.  
  562.  
  563. // -------------------------------------------------------
  564. //        d b L o n g  L i n k 2 E d i t F i e l d
  565. // -------------------------------------------------------
  566. void dbLongLink2EditField::copyFieldToLink()
  567. {
  568.     mLinkTo->SetValue(*mField);
  569. }
  570.  
  571.  
  572. void dbLongLink2EditField::copyLinkToField()
  573. {
  574.     *mField = mLinkTo->GetValue();
  575. }
  576.  
  577.  
  578.  
  579. // -------------------------------------------------------
  580. //        d b S h o r t  L i n k 2 E d i t F i e l d
  581. // -------------------------------------------------------
  582. void dbShortLink2EditField::copyFieldToLink()
  583. {
  584.     mLinkTo->SetValue(*mField);
  585. }
  586.  
  587.  
  588. void dbShortLink2EditField::copyLinkToField()
  589. {
  590.     *mField = mLinkTo->GetValue();
  591. }
  592.  
  593.  
  594.  
  595. // -------------------------------------------------------
  596. //        d b D a t e  L i n k 2 E d i t F i e l d
  597. // -------------------------------------------------------
  598. void dbDateLink2EditField::copyFieldToLink()
  599. {
  600.     Str255 str;
  601.     mField->asStr255(str);
  602.     mLinkTo->SetDescriptor(str);
  603. }
  604.  
  605.  
  606. void dbDateLink2EditField::copyLinkToField()
  607. {
  608.     Str255 str;
  609.     mLinkTo->GetDescriptor(str);
  610.     mField->setStr255(str);
  611. }
  612.  
  613.  
  614.  
  615. // -------------------------------------------------------
  616. //            d b L i s t B o x D i s p l a y
  617. // -------------------------------------------------------
  618. dbListBoxDisplay::dbListBoxDisplay(LListBox* theLB, dbView* theView) : 
  619.         mDisplay(theLB),
  620.         mView(theView),
  621.         mLoadedData(false)
  622. {
  623.     theLB->SetDoubleClickMessage(cmd_dbDoubleClick);
  624.     if (mView && theLB)
  625.         SetColWidths();
  626.  
  627. }
  628.  
  629.  
  630. void dbListBoxDisplay::refresh()
  631. {
  632.     loadData();
  633. }
  634.  
  635.  
  636. void dbListBoxDisplay::loadData()
  637. // VERY, VERY coarse first attempt just to get a demo working
  638. {
  639.     mDisplay->Hide();
  640.     mLoadedData = true;
  641.     DeleteAllData();
  642.     ListHandle lh = mDisplay->GetMacListH();
  643.     ::LAddColumn(mView->count(), 0, lh);
  644.     int numRows = mView->source()->count();
  645.     ::LAddRow(numRows, 0, lh);
  646.  
  647.     mView->source()->start();  
  648.     for (int i=0; i<numRows; i++) {
  649.         LoadRow(i, false);
  650.         mView->source()->next();
  651.     }
  652.     mView->source()->start();  
  653.     mDisplay->SetValue(0);
  654.     mDisplay->Show();
  655. }
  656.  
  657.  
  658. void dbListBoxDisplay::LoadRow(const int row, bool insertTheRow)
  659. // again, some very inefficient code to get the demo working
  660. {
  661.     ListHandle lh = mDisplay->GetMacListH();
  662.     if (insertTheRow) 
  663.         ::LAddRow(1, row, lh);
  664.     mView->start();
  665.     Cell theCell;
  666.     theCell.v = row;
  667.     for (int col = 0; mView->more(); col++) {
  668.         dbField  *theField = (dbField  *) (mView->item(col));           // safe downcast
  669.         char* str = theField->copyAsChars();  // good test of allocator, in this loop!
  670.         theCell.h = col;
  671.         ::LSetCell(str, strlen(str), theCell, lh);
  672.         delete str;
  673.         mView->next();
  674.     }
  675. }
  676.  
  677.  
  678. void dbListBoxDisplay::DeleteAllData()
  679. {
  680.     ListHandle lh = mDisplay->GetMacListH();
  681.     ::LDelColumn(0, 0, lh);  // all cols in one go
  682.     ::LDelRow(0, 0, lh);  // all rows in one go
  683. }
  684.  
  685.  
  686. void dbListBoxDisplay::changeViewTo(dbView* theView)
  687. {
  688.     mView = theView;
  689.     SetColWidths();
  690.     if (mLoadedData)  // don't load yet if hadn't loaded other view
  691.         loadData();
  692. }
  693.  
  694.  
  695. long dbListBoxDisplay::selectedRow() const
  696. {
  697.     return mDisplay->GetValue();
  698. }
  699.  
  700.  
  701. void dbListBoxDisplay::SetColWidths()
  702. {
  703. // logic copied from LListBox::ResizeFrameBy
  704. // which unfortunately we can't just call as it has a test to see if the cells are 
  705. // already at the default width
  706.     assert(mDisplay);
  707.     assert(mView);
  708.     ListHandle lh = mDisplay->GetMacListH();
  709.     Rect    displayRect = (**lh).rView;
  710.     Point    cellSize = (**lh).cellSize;
  711.     cellSize.h = (displayRect.right - displayRect.left) / mView->count();
  712.     ::LCellSize(cellSize, lh);
  713. }
  714.  
  715.  
  716.  
  717. // -------------------------------------------------------
  718. //             d b T a b l e V i e w D i s p l a y 
  719. // -------------------------------------------------------
  720. dbTableViewDisplay::dbTableViewDisplay(LStrTableView* inTable, dbView* inView) : 
  721.         mDisplay(inTable),
  722.         mView(inView),
  723.         mLoadedData(false),
  724.         mStorage(0)
  725. {
  726.     inTable->SetDoubleClickMessage(cmd_dbDoubleClick);
  727. //    if (mView && theLB)
  728. //        SetColWidths();
  729.  
  730. }
  731.  
  732.  
  733. void dbTableViewDisplay::refresh()
  734. {
  735.     mDisplay->Refresh();
  736. }
  737.  
  738.  
  739. void dbTableViewDisplay::loadData()
  740. {
  741.     mLoadedData = true;
  742.     if (mStorage==0) 
  743.     {
  744.         mStorage = new dbViewAsTableStorage(mDisplay, mView);
  745.         assert(mStorage);
  746.     }
  747.     mDisplay->SetTableStorage(mStorage);
  748.     mDisplay->Refresh();
  749. }
  750.  
  751.  
  752. void dbTableViewDisplay::changeViewTo(dbView* inView)
  753. {
  754.     mView = inView;
  755. //    SetColWidths();
  756.     if (mLoadedData)  // don't load yet if hadn't loaded other view
  757.         loadData();
  758. }
  759.  
  760.  
  761. long dbTableViewDisplay::selectedRow() const
  762. {
  763.     return 0;  // NOT YET IMPLEMENTED, later maybe create a LTableRowSelector subclass of LTableSelector
  764. }
  765.  
  766.  
  767. // -------------------------------------------------------
  768. //       d b V i e w A s T a b l e S t o r a g e
  769. // -------------------------------------------------------
  770.  
  771. dbViewAsTableStorage::dbViewAsTableStorage(
  772.                                 LTableView            *inTableView,
  773.                                 dbView                *inView) : 
  774. LTableStorage(inTableView), mView(inView) 
  775. {
  776. }
  777.  
  778.  
  779. void dbViewAsTableStorage::SetCellData(
  780.                                 const STableCell    &inCell,
  781.                                 const void            *inDataPtr,
  782.                                 Uint32                inDataSize)
  783. {
  784. // NOT YET IMPLEMENTED
  785. }
  786.  
  787.  
  788. void dbViewAsTableStorage::GetCellData(
  789.                                 const STableCell    &inCell,
  790.                                 void                *outDataPtr,
  791.                                 Uint32                &ioDataSize) const
  792. {
  793. // not very satisfactory, but a hack that should work for now
  794.     if (ioDataSize==0)
  795.         return;  // early exit for trivial case
  796.         
  797.     mView->source()->gotoRecord(inCell.row-1); // from 1-based rows
  798.     dbField& fld = mView->field(inCell.col-1); // from 1-based columns
  799.     char* str = fld.copyAsChars();
  800.     char* dest = (char*)outDataPtr;
  801.     unsigned long fieldLen = strlen(str);
  802.     if (ioDataSize<fieldLen)
  803.         fieldLen = ioDataSize;
  804.     else
  805.         ioDataSize = fieldLen;    // adjust caller length
  806.     memcpy(dest, str, fieldLen);  // NOTE no terminating null - the caller knows the length
  807.     delete[] str;
  808. }
  809.  
  810.  
  811. Boolean dbViewAsTableStorage::FindCellData(
  812.                                 STableCell            &outCell, 
  813.                                 const void            *inDataPtr,
  814.                                 Uint32                inDataSize) const
  815. {
  816. // NOT YET IMPLEMENTED
  817.     return false;
  818. }
  819.  
  820.  
  821. void dbViewAsTableStorage::InsertRows(
  822.                                 Uint32                inHowMany,
  823.                                 TableIndexT            inAfterRow,
  824.                                 const void            *inDataPtr,
  825.                                 Uint32                inDataSize)
  826. {
  827. // NOT YET IMPLEMENTED
  828. }
  829.  
  830.  
  831. void dbViewAsTableStorage::InsertCols(
  832.                                 Uint32                inHowMany,
  833.                                 TableIndexT            inAfterCol,
  834.                                 const void            *inDataPtr,
  835.                                 Uint32                inDataSize)
  836.                                 
  837. {
  838. // NOT YET IMPLEMENTED
  839. }
  840.  
  841.  
  842. void dbViewAsTableStorage::RemoveRows(
  843.                                 Uint32                inHowMany,
  844.                                 TableIndexT            inFromRow)
  845. {
  846. // NOT YET IMPLEMENTED
  847. }
  848.  
  849.  
  850. void dbViewAsTableStorage::RemoveCols(
  851.                                 Uint32                inHowMany,
  852.                                 TableIndexT            inFromCol)
  853. {
  854. // NOT YET IMPLEMENTED
  855. }
  856.  
  857.  
  858. void dbViewAsTableStorage::GetStorageSize(
  859.                                 TableIndexT            &outRows,
  860.                                 TableIndexT            &outCols)
  861. {
  862.     outRows = mView->source()->count();
  863.     outCols = mView->count();
  864. }
  865.  
  866.  
  867.