开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数值算法/人工智能 > 生物技术 > 查看源码
dload_menu.cpp
资源名称：ncbi_cxx_win--Jul_08_2004.zip　[点击查看]
上传用户：yhdzpy8989
上传日期：2007-06-13
资源大小：13604k
文件大小：21k
源码类别：

生物技术

开发平台：

C/C++

dload_menu.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: dload_menu.cpp,v $
  4.  * PRODUCTION Revision 1000.3  2004/06/01 20:43:46  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.30
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: dload_menu.cpp,v 1000.3 2004/06/01 20:43:46 gouriano Exp $
  11.  * ===========================================================================
  12.  *
  13.  *                            PUBLIC DOMAIN NOTICE
  14.  *               National Center for Biotechnology Information
  15.  *
  16.  *  This software/database is a "United States Government Work" under the
  17.  *  terms of the United States Copyright Act.  It was written as part of
  18.  *  the author's official duties as a United States Government employee and
  19.  *  thus cannot be copyrighted.  This software/database is freely available
  20.  *  to the public for use. The National Library of Medicine and the U.S.
  21.  *  Government have not placed any restriction on its use or reproduction.
  22.  *
  23.  *  Although all reasonable efforts have been taken to ensure the accuracy
  24.  *  and reliability of the software and data, the NLM and the U.S.
  25.  *  Government do not and cannot warrant the performance or results that
  26.  *  may be obtained by using this software or data. The NLM and the U.S.
  27.  *  Government disclaim all warranties, express or implied, including
  28.  *  warranties of performance, merchantability or fitness for any particular
  29.  *  purpose.
  30.  *
  31.  *  Please cite the author in any work or product based on this material.
  32.  *
  33.  * ===========================================================================
  34.  *
  35.  * Authors:  Mike DiCuccio
  36.  *
  37.  * File Description:
  38.  *
  39.  *    CDLoadMenuData_Impl -- Abstract class to hold callback information
  40.  *                          necessary to spawn a document / data loader plugin
  41.  *                          from an FLTK callback
  42.  *
  43.  *    COpenMenuData      -- Class to hold / launch plugin to open a new
  44.  *                          document
  45.  *    CImportMenuData    -- Class to hold / launch plugin to import data into
  46.  *                          an existing record
  47.  *    CSaveAsMenuData    -- Class to hold / launch plugin to save the current
  48.  *                          record
  49.  *    CUnloadMenuData    -- Class to unload a document from memory
  50.  *
  51.  *    CDocLoaderMenuMgr  -- Manager for dynamic FLTK document laoder plugin
  52.  *                          menu + callback data
  53.  */
  55. #include <ncbi_pch.hpp>
  56. #include <gui/plugin/PluginMessage.hpp>
  57. #include <gui/plugin/PluginMRUList.hpp>
  58. #include <gui/plugin/PluginMRUEntry.hpp>
  59. #include <gui/core/dload_factory.hpp>
  60. #include <gui/core/dload_menu.hpp>
  61. #include <gui/core/doc_manager.hpp>
  62. #include <gui/core/idocument.hpp>
  63. #include <gui/core/plugin_registry.hpp>
  64. #include <gui/core/plugin_utils.hpp>
  65. #include <gui/core/plugin_handle.hpp>
  66. #include <gui/core/plugin_dlg.hpp>
  67. #include <gui/utils/message_box.hpp>
  70. BEGIN_NCBI_SCOPE
  71. USING_SCOPE(objects);
  74. //
  75. // internal base class used by suclasses.  This class exists to keep
  76. // CPluginHandle private within the context of this header.
  77. //
  78. class CDLoadMenuData_Impl : public IDLoadMenuData
  79. {
  80. public:
  81.     //CDLoadMenuData_Impl(CPluginHandle plugin);
  82.     CDLoadMenuData_Impl(const string& plugin_name);
  83.     virtual ~CDLoadMenuData_Impl() {}
  85. protected:
  86.     string        m_Plugin;
  87. };
  90. //
  91. // concrete data class for loading new documents
  92. //
  93. class COpenMenuData : public CDLoadMenuData_Impl
  94. {
  95. public:
  96.     COpenMenuData(const string& plugin)
  97.         : CDLoadMenuData_Impl(plugin)
  98.     {
  99.     }
  101.     COpenMenuData(CPluginHandle plugin)
  102.         : CDLoadMenuData_Impl(plugin.GetClassName())
  103.     {
  104.     }
  106.     //
  107.     // DoCallback()
  108.     // here we handle the meat of creating a new view
  109.     //
  110.     void DoCallback()
  111.     {
  112.         if ( m_Plugin.empty() ) {
  113.             return;
  114.         }
  116.         // we create a dummy selection buffer to hold our single document
  117.         CPluginUtils::CallPlugin(m_Plugin, eDataCommand_load);
  118.     }
  119. };
  123. class COpenMenuDataEx : public IDLoadMenuData
  124. {
  125. public:
  126.     COpenMenuDataEx()
  127.     {
  128.     }
  130.     //
  131.     // DoCallback()
  132.     // here we handle the meat of creating a new view
  133.     //
  134.     void DoCallback()
  135.     {
  136.         if ( !m_Dlg.get() ) {
  137.             m_Dlg.reset(new CPluginDlg(eDataCommand_load));
  138.         }
  139.         m_Dlg->Show();
  140.     }
  142. private:
  143.     auto_ptr<CPluginDlg> m_Dlg;
  144. };
  148. //
  149. // concrete data class for loading new documents
  150. //
  151. class CSearchMenuData : public CDLoadMenuData_Impl
  152. {
  153. public:
  154.     CSearchMenuData(const string& plugin)
  155.         : CDLoadMenuData_Impl(plugin)
  156.     {
  157.     }
  159.     CSearchMenuData(CPluginHandle plugin)
  160.         : CDLoadMenuData_Impl(plugin.GetClassName())
  161.     {
  162.     }
  164.     //
  165.     // DoCallback()
  166.     // here we handle the meat of creating a new view
  167.     //
  168.     void DoCallback()
  169.     {
  170.         if ( m_Plugin.empty() ) {
  171.             return;
  172.         }
  174.         CPluginUtils::CallPlugin(m_Plugin, eDataCommand_search);
  175.     }
  176. };
  180. //
  181. // concrete data class for loading new documents
  182. //
  183. class CManageMenuData : public CDLoadMenuData_Impl
  184. {
  185. public:
  186.     CManageMenuData(const string& plugin)
  187.         : CDLoadMenuData_Impl(plugin)
  188.     {
  189.     }
  191.     CManageMenuData(CPluginHandle plugin)
  192.         : CDLoadMenuData_Impl(plugin.GetClassName())
  193.     {
  194.     }
  196.     //
  197.     // DoCallback()
  198.     // here we handle the meat of creating a new view
  199.     //
  200.     void DoCallback()
  201.     {
  202.         if ( m_Plugin.empty() ) {
  203.             return;
  204.         }
  206.         CPluginUtils::CallPlugin(m_Plugin, eDataCommand_manage);
  207.     }
  208. };
  212. //
  213. // concrete data class for importing into current documents
  214. //
  215. class CImportMenuData : public CDLoadMenuData_Impl
  216. {
  217. public:
  218.     CImportMenuData(CPluginHandle plugin, IDocument* doc)
  219.         : CDLoadMenuData_Impl(plugin.GetClassName()),
  220.           m_Doc(doc)
  221.     {
  222.     }
  224.     //
  225.     // DoCallback()
  226.     // here we handle the meat of creating a new view
  227.     //
  228.     void DoCallback()
  229.     {
  230.         if ( m_Plugin.empty()  ||  !m_Doc ) {
  231.             return;
  232.         }
  234.         CPluginUtils::CallPlugin(m_Plugin, eDataCommand_import, m_Doc);
  235.     }
  237. private:
  238.     IDocument* m_Doc;
  240. };
  244. //
  245. // concrete data class for saving current documents
  246. //
  247. class CSaveMenuData : public CDLoadMenuData_Impl
  248. {
  249. public:
  250.     CSaveMenuData(const string& plugin_name, IDocument* doc)
  251.         : CDLoadMenuData_Impl(plugin_name),
  252.           m_Doc(doc)
  253.     {
  254.     }
  256.     
  257.     CSaveMenuData(CPluginHandle plugin, IDocument* doc)
  258.         : CDLoadMenuData_Impl(plugin.GetClassName()),
  259.           m_Doc(doc)
  260.     {
  261.     }
  262.     
  264.     //
  265.     // DoCallback()
  266.     // here we handle the meat of creating a new view
  267.     //
  268.     void DoCallback()
  269.     {
  270.         if ( m_Plugin.empty()  ||  !m_Doc ) {
  271.             return;
  272.         }
  274.         CPluginUtils::CallPlugin(m_Plugin, eDataCommand_save, m_Doc);
  275.     }
  277. private:
  278.     IDocument* m_Doc;
  280. };
  284. //
  285. // concrete data class for unloading documents
  286. //
  287. class CUnloadMenuData : public CDLoadMenuData_Impl
  288. {
  289. public:
  290.     CUnloadMenuData(IDocument* doc)
  291.         : CDLoadMenuData_Impl(kEmptyStr),
  292.           m_Doc(doc)
  293.     {
  294.     }
  296.     //
  297.     // DoCallback()
  298.     // here we handle the meat of creating a new view
  299.     //
  300.     void DoCallback()
  301.     {
  302.         if ( !m_Doc ) {
  303.             return;
  304.         }
  306.         if (CDocManager::ReleaseDocument(m_Doc)) {
  307.             m_Doc = NULL;
  308.         }
  309.     }
  311. private:
  312.     IDocument* m_Doc;
  314. };
  317. //
  318. // concrete data class for most recently used documents
  319. //
  320. class CRecentMenuData : public CDLoadMenuData_Impl
  321. {
  322. public:
  323.     CRecentMenuData(CPluginMessage& msg)
  324.         : CDLoadMenuData_Impl(kEmptyStr),
  325.           m_Msg(&msg)
  326.     {
  327.     }
  329.     //
  330.     // DoCallback()
  331.     // here we handle the meat of creating a new view
  332.     //
  333.     void DoCallback()
  334.     {
  335.         if ( !m_Msg ) {
  336.             return;
  337.         }
  339.         CPluginUtils::CallPlugin(*m_Msg);
  341.     }
  343. private:
  344.     CPluginMessage* m_Msg;
  346. };
  349. //
  350. // default ctor for our base menu data class
  351. //
  352. CDLoadMenuData_Impl::CDLoadMenuData_Impl(const string& plugin_name)
  353.     : m_Plugin(plugin_name)
  354. {
  355. }
  358. //
  359. // default ctor for the view menu manager class
  360. //
  361. CDocLoaderMenuMgr::CDocLoaderMenuMgr(Fl_Menu_* menu, const string& base)
  362.     : CFltkMenuMgrBase<IDLoadMenuData>(menu)
  363. {
  364.     SetMenuBase(base);
  365. }
  368. //
  369. // Clear()
  370. // this clears the contents of our two submenus
  371. //
  372. void CDocLoaderMenuMgr::Clear()
  373. {
  374.     // Do our base class clear
  375.     x_ClearData();
  377.     if ( !m_Menu ) {
  378.         return;
  379.     }
  381.     string base = m_Base;
  382.     if ( !base.empty() ) {
  383.         base += "/";
  384.     }
  386.     x_RemoveSubitems(base + "Open");
  387.     x_RemoveSubitems(base + "Import");
  388.     x_RemoveSubitems(base + "Save as");
  389.     x_RemoveSubitems(base + "Unload");
  390.     x_RemoveSubitems(base + "Recent Documents");
  391. }
  394. //
  395. // AddOpenMenu()
  396. // This fills out a new menu to hold the 
  397. //
  398. void CDocLoaderMenuMgr::AddOpenMenu()
  399. {
  400.     string menu_base = m_Base;
  401.     if ( !menu_base.empty() ) {
  402.         menu_base += "/";
  403.     }
  404.     menu_base += "Open";
  406. #if 0
  408.     x_AddItem(menu_base, new COpenMenuDataEx());
  410. #else
  412.     int items_added = 0;
  413.     CPluginRegistry::TPlugins plugins =
  414.         CPluginRegistry::GetPlugins(CPluginCommandSet::e_Data);
  415.     NON_CONST_ITERATE (CPluginRegistry::TPlugins, iter, plugins) {
  416.         // verify that we support the 'load' command
  417.         CPluginHandle plugin = *iter;
  418.         if ( !plugin.HasCommandSubtype(eDataCommand_load) ) {
  419.             continue;
  420.         }
  422.         string s = plugin.GetMenuItem();
  423.         if ( !menu_base.empty() ) {
  424.             s = menu_base + s;
  425.         }
  426.         x_AddItem(s, new COpenMenuData(plugin.GetClassName()));
  427.         ++items_added;
  428.     }
  430.     if (items_added == 0) {
  431.         x_AddNullItem(menu_base + "(no plugins loaded)");
  432.     }
  433. #endif
  434. }
  437. //
  438. // AddRecentMenu()
  439. // This fills out a new menu to hold the 
  440. //
  441. void CDocLoaderMenuMgr::AddRecentMenu()
  442. {
  443.     string menu_base = m_Base;
  444.     if ( !menu_base.empty() ) {
  445.         menu_base += "/";
  446.     }
  447.     menu_base += "Recent Documents/";
  450.     int items_added = 0;
  451.     ITERATE (CPluginMRUList::Tdata, iter, CDocManager::GetMRUCache().Get()) {
  452.         ++items_added;
  453.         CRef<CPluginMRUEntry> entry = *iter;
  454.         string s = menu_base + "&" +
  455.             NStr::IntToString(items_added) + " " + entry->GetLabel();
  456.         x_AddItem(s, new CRecentMenuData(entry->SetMessage()));
  457.     }
  459.     if (items_added == 0) {
  460.         x_AddNullItem(menu_base + "(no plugins loaded)");
  461.     }
  462. }
  465. //
  466. // AddImportMenu()
  467. // This fills out a dynamic menu for importing into a given document.  If the
  468. // parameter 'doc' is NULL, then a menu is produced for importing into every
  469. // loaded document.
  470. //
  471. void CDocLoaderMenuMgr::AddImportMenu(IDocument* doc)
  472. {
  473.     string menu_base = m_Base;
  474.     if ( !menu_base.empty() ) {
  475.         menu_base += "/";
  476.     }
  477.     menu_base += "Import/";
  479.     int items_added = 0;
  480.     if (doc) {
  481.         // we add an import menu for this document only
  482.         CPluginRegistry::TPlugins plugins =
  483.             CPluginRegistry::GetPlugins(eDataCommand_import, doc);
  484.         NON_CONST_ITERATE (CPluginRegistry::TPlugins, iter, plugins) {
  485.             // verify that we support the 'load' command
  486.             CPluginHandle plugin = *iter;
  487.             string s = plugin.GetMenuItem();
  488.             if ( !menu_base.empty() ) {
  489.                 s = menu_base + s;
  490.             }
  491.             x_AddItem(s, new CImportMenuData(plugin, doc));
  492.             ++items_added;
  493.         }
  494.     } else if (CDocManager::GetDocuments().size() != 0) {
  495.         // we add an import menu for all documents
  496.         NON_CONST_ITERATE (CDocManager::TDocList, doc_iter,
  497.                            CDocManager::GetDocuments()) {
  498.             doc = *doc_iter;
  499.             if ( !doc ) {
  500.                 continue;
  501.             }
  502.             string base = menu_base + doc->GetShortTitle();
  503.             CPluginRegistry::TPlugins plugins =
  504.                 CPluginRegistry::GetPlugins(eDataCommand_import, doc);
  505.             NON_CONST_ITERATE (CPluginRegistry::TPlugins, iter, plugins) {
  506.                 // verify that we support the 'load' command
  507.                 CPluginHandle plugin = *iter;
  508.                 string s = plugin.GetMenuItem();
  509.                 if ( !base.empty() ) {
  510.                     s = base + "/" + s;
  511.                 }
  512.                 x_AddItem(s, new CImportMenuData(plugin, doc));
  513.                 ++items_added;
  514.             }
  515.         }
  516.     }
  518.     if (items_added == 0) {
  519.         x_AddNullItem(menu_base + "(no records loaded)");
  520.     }
  521. }
  524. //
  525. // AddSearchMenu()
  526. // This fills out a new menu to hold the 
  527. //
  528. void CDocLoaderMenuMgr::AddSearchMenu()
  529. {
  530.     string menu_base = m_Base;
  531.     if ( !menu_base.empty() ) {
  532.         menu_base += "/";
  533.     }
  534.     menu_base += "Search/";
  537.     int items_added = 0;
  538.     CPluginRegistry::TPlugins plugins =
  539.         CPluginRegistry::GetPlugins(CPluginCommandSet::e_Data);
  540.     NON_CONST_ITERATE (CPluginRegistry::TPlugins, iter, plugins) {
  541.         // verify that we support the 'load' command
  542.         CPluginHandle plugin = *iter;
  543.         if ( !plugin.HasCommandSubtype(eDataCommand_search) ) {
  544.             continue;
  545.         }
  547.         string s = plugin.GetMenuItem();
  548.         if ( !menu_base.empty() ) {
  549.             s = menu_base + s;
  550.         }
  551.         x_AddItem(s, new CSearchMenuData(plugin.GetClassName()));
  552.         ++items_added;
  553.     }
  555.     if (items_added == 0) {
  556.         x_AddNullItem(menu_base + "(no plugins loaded)");
  557.     }
  558. }
  561. //
  562. // AddManageMenu()
  563. // This fills out a new menu to hold the 
  564. //
  565. void CDocLoaderMenuMgr::AddManageMenu()
  566. {
  567.     string menu_base = m_Base;
  568.     if ( !menu_base.empty() ) {
  569.         menu_base += "/";
  570.     }
  571.     menu_base += "Manage Data Sources/";
  574.     int items_added = 0;
  575.     CPluginRegistry::TPlugins plugins =
  576.         CPluginRegistry::GetPlugins(CPluginCommandSet::e_Data);
  577.     NON_CONST_ITERATE (CPluginRegistry::TPlugins, iter, plugins) {
  578.         // verify that we support the 'load' command
  579.         CPluginHandle plugin = *iter;
  580.         if ( !plugin.HasCommandSubtype(eDataCommand_manage) ) {
  581.             continue;
  582.         }
  584.         string s = plugin.GetMenuItem();
  585.         if ( !menu_base.empty() ) {
  586.             s = menu_base + s;
  587.         }
  588.         x_AddItem(s, new CManageMenuData(plugin.GetClassName()));
  589.         ++items_added;
  590.     }
  592.     if (items_added == 0) {
  593.         x_AddNullItem(menu_base + "(no plugins loaded)");
  594.     }
  595. }
  598. //
  599. // AddSaveAsMenu()
  600. // This fills out a dynamic menu for saving a given document.  If the
  601. // parameter 'doc' is NULL, then a menu is produced for saving every
  602. // loaded document.
  603. //
  604. void CDocLoaderMenuMgr::AddSaveAsMenu(IDocument* doc)
  605. {
  606.     string menu_base = m_Base;
  607.     if ( !menu_base.empty() ) {
  608.         menu_base += "/";
  609.     }
  610.     menu_base += "Save as/";
  612.     int items_added = 0;
  613.     if (doc) {
  614.         // we add an import menu for this document only
  615.         CPluginRegistry::TPlugins plugins =
  616.             CPluginRegistry::GetPlugins(eDataCommand_save, doc);
  617.         NON_CONST_ITERATE (CPluginRegistry::TPlugins, iter, plugins) {
  618.             // verify that we support the 'save' command
  619.             CPluginHandle plugin = *iter;
  620.             string s = plugin.GetMenuItem();
  621.             if ( !menu_base.empty() ) {
  622.                 s = menu_base + s;
  623.             }
  624.             x_AddItem(s, new CSaveMenuData(plugin, doc));
  625.             ++items_added;
  626.         }
  627.     } else if (CDocManager::GetDocuments().size() != 0) {
  628.         // we add an import menu for all documents
  629.         NON_CONST_ITERATE (CDocManager::TDocList, doc_iter,
  630.                            CDocManager::GetDocuments()) {
  631.             doc = *doc_iter;
  632.             if ( !doc ) {
  633.                 continue;
  634.             }
  635.             string base = menu_base + doc->GetShortTitle();
  636.             CPluginRegistry::TPlugins plugins =
  637.                 CPluginRegistry::GetPlugins(eDataCommand_save, doc);
  638.             NON_CONST_ITERATE (CPluginRegistry::TPlugins, iter, plugins) {
  639.                 // verify that we support the 'save' command
  640.                 CPluginHandle plugin = *iter;
  641.                 string s = plugin.GetMenuItem();
  642.                 if ( !base.empty() ) {
  643.                     s = menu_base + s;
  644.                 }
  645.                 x_AddItem(s, new CSaveMenuData(plugin, doc));
  646.                 ++items_added;
  647.             }
  648.         }
  649.     }
  651.     if (items_added == 0) {
  652.         x_AddNullItem(menu_base + "(no records loaded)");
  653.     }
  654. }
  657. //
  658. // AddUnloadMenu()
  659. // This produces a menu for explicitly unloading a given document
  660. //
  661. void CDocLoaderMenuMgr::AddUnloadMenu(IDocument* doc)
  662. {
  663.     string menu_base = m_Base;
  664.     if ( !menu_base.empty() ) {
  665.         menu_base += "/";
  666.     }
  667.     menu_base += "Unload/";
  669.     int items_added = 0;
  670.     if (doc) {
  671.         // we add an import menu for this document only
  672.         x_AddItem(menu_base, new CUnloadMenuData(doc));
  673.         ++items_added;
  674.     } else if (CDocManager::GetDocuments().size() != 0) {
  675.         // we add an import menu for all documents
  676.         NON_CONST_ITERATE (CDocManager::TDocList, doc_iter,
  677.                            CDocManager::GetDocuments()) {
  678.             doc = *doc_iter;
  679.             if ( !doc ) {
  680.                 continue;
  681.             }
  682.             string s = menu_base + doc->GetShortTitle();
  683.             x_AddItem(s, new CUnloadMenuData(*doc_iter));
  684.             ++items_added;
  685.         }
  686.     }
  688.     if (items_added == 0) {
  689.         x_AddNullItem(menu_base + "(no records loaded)");
  690.     }
  691. }
  694. END_NCBI_SCOPE
  696. /*
  697.  * ===========================================================================
  698.  * $Log: dload_menu.cpp,v $
  699.  * Revision 1000.3  2004/06/01 20:43:46  gouriano
  700.  * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.30
  701.  *
  702.  * Revision 1.30  2004/06/01 18:38:35  dicuccio
  703.  * Fixed multiple definition compiler error
  704.  *
  705.  * Revision 1.29  2004/06/01 18:01:58  dicuccio
  706.  * Updated to match new API in CDocManager.  Added commented-out implementation of
  707.  * new plugin options dialog
  708.  *
  709.  * Revision 1.28  2004/05/21 22:27:40  gorelenk
  710.  * Added PCH ncbi_pch.hpp
  711.  *
  712.  * Revision 1.27  2004/05/18 15:06:15  friedman
  713.  * Removed included tha does not exist
  714.  *
  715.  * Revision 1.26  2004/05/18 11:13:24  friedman
  716.  * Handle adding recently loaded documents into the MRU list.
  717.  *
  718.  * Revision 1.25  2004/04/16 14:37:10  dicuccio
  719.  * Drop unneeded selection buffer parameter
  720.  *
  721.  * Revision 1.24  2003/11/06 20:06:29  dicuccio
  722.  * Moved USING_SCOPE(objects) to implementation files
  723.  *
  724.  * Revision 1.23  2003/10/27 17:36:38  dicuccio
  725.  * Removed #include for pld request status enum
  726.  *
  727.  * Revision 1.22  2003/09/16 13:59:00  dicuccio
  728.  * Code clean-up.  Renamed interface class for doc loader menu data
  729.  *
  730.  * Revision 1.21  2003/09/04 14:01:51  dicuccio
  731.  * Introduce IDocument and IView as abstract base classes for CDocument and CView
  732.  *
  733.  * Revision 1.20  2003/08/04 17:29:42  dicuccio
  734.  * Changed menu signature for manage to 'Manage Data Sources'
  735.  *
  736.  * Revision 1.19  2003/07/31 16:53:21  dicuccio
  737.  * Added implementations for search / manage plugin commands
  738.  *
  739.  * Revision 1.18  2003/07/21 19:26:48  dicuccio
  740.  * Changed data class interface from Run() to DoCallback() -- more descriptive.
  741.  * Modified all menu structures to accept a selection buffer; use selection
  742.  * buffers internally for all operations.  Fixed screening of plugins based on
  743.  * selection contents
  744.  *
  745.  * Revision 1.17  2003/07/14 11:00:22  shomrat
  746.  * Plugin messageing system related changes
  747.  *
  748.  * Revision 1.16  2003/06/25 17:02:54  dicuccio
  749.  * Split CPluginHandle into a handle (pointer-to-implementation) and
  750.  * implementation file.  Lots of #include file clean-ups.
  751.  *
  752.  * Revision 1.15  2003/05/30 14:15:41  dicuccio
  753.  * Renamed MessageBox to NcbiMessageBox because brain-dead MSVC thinks this is
  754.  * ::MessageBox and rewrites the symbol as MessageBoxA, which results in an
  755.  * unresolved external and conflict with the Win32 API :(.
  756.  *
  757.  * Revision 1.14  2003/05/30 12:56:50  dicuccio
  758.  * Converted code to use MessageBox() instead of fl_ask()/fl_message()/fl_alert()
  759.  *
  760.  * Revision 1.13  2003/04/29 14:36:49  dicuccio
  761.  * Fully implemented screening of plugins based on selection content - updated
  762.  * API to match
  763.  *
  764.  * Revision 1.12  2003/04/24 16:26:32  dicuccio
  765.  * Plugins are now responsible for marshalling documents (not the framework's
  766.  * function).  Also, fixed given API changes to IDocument
  767.  *
  768.  * Revision 1.11  2003/04/16 18:19:20  dicuccio
  769.  * Modified menu handlers to use generic plugin launch mechanism (CallPlugin())
  770.  *
  771.  * Revision 1.10  2003/03/10 22:58:51  kuznets
  772.  * iterate -> ITERATE
  773.  *
  774.  * Revision 1.9  2003/02/26 17:53:31  dicuccio
  775.  * Cleaned up the dynamic menus to make the dynamic menus resistant to menu
  776.  * refreshes while the menu callback is running
  777.  *
  778.  * Revision 1.8  2003/02/24 13:03:15  dicuccio
  779.  * Renamed classes in plugin spec:
  780.  *     CArgSeg --> CPluginArgSet
  781.  *     CArgument --> CPluginArg
  782.  *     CPluginArgs --> CPluginCommand
  783.  *     CPluginCommands --> CPluginCommandSet
  784.  *
  785.  * Revision 1.7  2003/02/20 19:49:54  dicuccio
  786.  * Created new plugin architecture, based on ASN.1 spec.  Moved GBENCH frameowrk
  787.  * over to use new plugin architecture.
  788.  *
  789.  * Revision 1.6  2003/02/05 19:48:29  dicuccio
  790.  * Implemented save for data loader dynamic menus
  791.  *
  792.  * Revision 1.5  2003/01/15 21:06:51  dicuccio
  793.  * Removed useless _TRACE()
  794.  *
  795.  * Revision 1.4  2003/01/13 13:10:06  dicuccio
  796.  * Namespace clean-up.  Retired namespace gui -> converted all to namespace
  797.  * ncbi.  Moved all FLUID-generated code into namespace ncbi.
  798.  *
  799.  * Revision 1.3  2003/01/10 17:36:41  dicuccio
  800.  * Changed TPluginList --> TPlugins
  801.  *
  802.  * Revision 1.2  2002/12/30 17:52:18  dicuccio
  803.  * Added private menu callback handler - delays call to
  804.  * CDocManager::UpdateAllViews(), which invalidates current menu data objects.
  805.  *
  806.  * Revision 1.1  2002/12/20 19:15:54  dicuccio
  807.  * Initial revision.
  808.  *
  809.  * ===========================================================================
  810.  */