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

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

生物技术

开发平台：

C/C++

menu_window.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: menu_window.cpp,v $
  4.  * PRODUCTION Revision 1000.0  2004/06/01 21:29:21  gouriano
  5.  * PRODUCTION PRODUCTION: IMPORTED [GCC34_MSVC7] Dev-tree R1.7
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: menu_window.cpp,v 1000.0 2004/06/01 21:29:21 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:  Andrey Yazhuk
  36.  *  
  37.  */
  39. #include <ncbi_pch.hpp>
  40. #include <corelib/ncbistd.hpp>
  41. #include <algorithm>
  43. #include <gui/utils/accel_table.hpp>
  44. #include <gui/widgets/fl/menu_window.hpp>
  46. #include <FL/fl_draw.H>
  47. #include <FL/Fl_Image.H>
  49. #include <FL/Enumerations.H>
  50. #include <FL/Fl.H>
  52. #include <math.h>
  54. BEGIN_NCBI_SCOPE
  57. ///////////////////////////////////////////////////////////////////////////////
  58. /// CMenuProperties
  59. CMenu::CProperties::CProperties()
  60. {
  61.     m_FontType = FL_HELVETICA;
  62.     m_FontSize = 12;
  64.     m_Colors[eBack] = fl_rgb_color(216, 216, 216);
  65.     m_Colors[eFocusedBack] = fl_rgb_color(192, 192, 216);
  66.     m_Colors[eCheckedBack] = fl_rgb_color(200, 200, 216);
  67.     m_Colors[ePushedBack] = fl_rgb_color(128, 128, 192);
  68.     m_Colors[ePopupBack] = fl_rgb_color(248, 248, 255);
  69.     m_Colors[eFrame] = fl_rgb_color(64, 64, 64);
  70.     m_Colors[eText] = fl_rgb_color(0, 0, 0);
  71.     m_Colors[eDisabledText] = fl_rgb_color(196, 196, 196);
  72.     m_Colors[eFocusedDisabledText] = fl_rgb_color(224, 224, 224);
  73.     m_Colors[ePushedText] = fl_rgb_color(255, 255, 255);
  74.     m_Colors[eFocusedFrame] = fl_rgb_color(0, 0, 128);
  75.     m_Colors[eIconArea] = fl_rgb_color(232, 232, 240);
  76.     m_Colors[eBorder] = fl_rgb_color(255, 255, 255);
  77. }
  79. const static int    kDefaultIconSize = 16;
  80. const static int    kCheckSize = 16;
  81. const static int    kRadioSize = 16;
  82. const static int    kSubMarkerH = 7; // submenu marker height 
  83. const static int    kSubMarkerOffset = 7; // submenu marker offset from the right
  84. const static int    kSubMarkerW = 12; // submenu marker width
  85. const static int    kBorderSize = 3; // menu border
  86. const static int    kSpace = 2; // spacing around icons, labels
  87. const static int    kAccelSpace = 8; // spacing between item label and accelerator label
  88. const static int    kItemOffsetY = 3;
  89. const static int    kItemOffsetX = 4; // horz spacing between items  
  90. const static int    kSubmenuOffsetX = 8; // horz spacing between submenus
  91. const static int    kSeparatorSize = 1 + 2 * kItemOffsetX;
  93. const static char   kAccessKeyMarker = '&';
  95. const static double kMenuDelay = 0.4;
  97. ///////////////////////////////////////////////////////////////////////////////
  98. /// class CMenu - base class for all menus
  100. CMenu::CProperties  CMenu::sm_Props;
  101. CRef<CResourceManager>   CMenu::sm_ResManager; 
  103. CRef<CResourceManager>   CMenu::GetResourceManager(void)
  104. {
  105.     return sm_ResManager;
  106. }
  108. CMenu::TCmdToHintMap   CMenu::sm_CmdToHint;
  110. void    CMenu::SetResourceManager(CRef<CResourceManager> manager)
  111. {
  112.     sm_ResManager = manager;
  113.     if(sm_ResManager)   {
  114.         manager->RegisterAlias("menu::check", "check.png");
  115.         manager->RegisterAlias("menu::radio", "radio.png");    
  116.     }
  117. }
  119. void    CMenu::SetCmdHint(TCmdID cmd, const string& hint)
  120. {
  121.     sm_CmdToHint[cmd] = hint;
  122. }
  124. string   CMenu::GetCmdHint(TCmdID cmd)
  125. {
  126.     TCmdToHintMap::iterator it = sm_CmdToHint.find(cmd);
  127.     return (it != sm_CmdToHint.end()) ? it->second : "";
  128. }
  130. CMenu::CMenu()
  131. :   m_RootItem(NULL),
  132.     m_bOwnItems(false),
  133.     m_CmdTarget(NULL),
  134.     m_Listener(NULL),
  135.     m_Width(0), 
  136.     m_Height(0),
  137.     m_Border(0),
  138.     m_IconSize(kDefaultIconSize),
  139.     m_MaxLabelW(0),
  140.     m_BackColor(eBack),
  141.     m_Selected(NULL),
  142.     m_PushedItem(NULL),
  143.     m_bKeyActivated(false)
  144. {
  145. }
  147. CMenu::~CMenu()
  148. {
  149.     x_Clear();
  150. }
  152. void    CMenu::SetCmdTarget(CCommandTarget* target)
  153. {
  154.     m_CmdTarget = target;
  155. }
  157. CCommandTarget*    CMenu::GetCmdTarget(void)
  158. {
  159.     return m_CmdTarget;
  160. }
  162. void    CMenu::SetItemImageSize(int size)
  163. {
  164.     _ASSERT(size >= 0  && size < 100);
  165.     m_IconSize = size;
  166. }
  168. bool    CMenu::x_IsKeyActivated() const
  169. {
  170.     return m_bKeyActivated;
  171. }
  172. /// Creates a menu described by array of SMenuItem-s. CMenuBar creates a separate
  173. /// copy of a menu, so that it can be modified at run-time.
  174. void    CMenu::SetItems(const SMenuItemRec* items)
  175. {
  176.     CMenuItem* root = CreateMenuItems(items);
  177.     x_SetItems(root, true);
  178. }
  180. void    CMenu::SetItems(CMenuItem* root_item)
  181. {    
  182.     x_SetItems(root_item, true);
  183. }
  185. void    CMenu::SetHintListener(IMenuHintListener* listener)
  186. {
  187.     m_Listener = listener;
  188. }
  190. IMenuHintListener*  CMenu::GetHintListener()
  191. {
  192.     return m_Listener;
  193. }
  195. void    CMenu::x_SetItems(CMenuItem* root_item, bool take_ownership)
  196. {
  197.     x_Clear();
  199.     m_RootItem = root_item;
  200.     m_bOwnItems = take_ownership;
  201.     
  202.     if(m_RootItem)  {
  203.         CResourceManager* manager = GetResourceManager();
  204.         _ASSERT(manager);
  206.         m_hCheckIcon = manager->GetImage("menu::check");
  207.         m_hRadioIcon = manager->GetImage("menu::radio");
  209.         for(CMenuItem::TChildItem_CI it =  m_RootItem->SubItemsBegin();
  210.                                         it != m_RootItem->SubItemsEnd(); ++it) {
  211.             CMenuItem* item = (*it)->GetValue();
  212.             
  213.             // create entry for a menu item
  214.             SItemEntry entry;
  215.             entry.m_Item = item;
  216.             if(item->HasImage())    {
  217.                 entry.m_hIcon = manager->GetImage(item->GetImageAlias()); // preloading images
  218.             }
  219.             entry.m_Size = 0;
  221.             // create access key entry
  222.             const string& label = item->GetLabel();
  223.             string::size_type pos = label.find(kAccessKeyMarker);
  225.             if(pos != string::npos  &&  pos + 1 < label.size()) {
  226.                 char ch = label[pos + 1];
  227.                 ch = tolower(ch);
  228.                 
  229.                 TAccessKeyToItemMap::const_iterator it = m_AccessKeyToItem.find(ch);
  230.                 if(it == m_AccessKeyToItem.end())   { // OK
  231.                     m_AccessKeyToItem[ch] = item;
  232.                 }   else {
  233.                     ERR_POST("CMenuItem "" << label << "" specifies accelerator that is already defined in this menu.");
  234.                 }            
  235.             }
  237.         
  238.             // lookup item accelerator
  239.             if(item->IsItem())  {
  240.                 TCmdID cmd = item->GetCommand();
  241.                 int accel = 0;
  242.                 if(CAccelTable::GetAccelByCommand(cmd, accel))    {
  243.                     entry.m_AccelLabel = CAccelTable::GetAccelLabel(accel);
  244.                 }
  245.             }
  247.             m_Entries.push_back(entry);
  248.         }
  249.     }
  250.     
  251.     x_Layout();    
  252. }
  254. void    CMenu::x_Clear(void)
  255. {
  256.     m_AccessKeyToItem.clear();
  257.     m_Entries.clear();
  259.     m_Selected = NULL;
  260.     
  261.     if(m_bOwnItems)   {
  262.         delete m_RootItem;
  263.     }
  264.     m_RootItem = NULL;
  265. }
  267. void    CMenu::x_UpdateItems(void)
  268. {
  269.     CCommandTarget* target = GetCmdTarget();
  270.     if(target)  {
  271.         NON_CONST_ITERATE(TEntries, it, m_Entries)  {
  272.             CMenuItem& item = *it->m_Item;
  273.             if(item.IsItem())   {
  274.                 CMenuCmdUI CmdUI(item);
  275.                 
  276.                 target->OnUpdateCommand(item.GetCommand(), &CmdUI);
  277.             }
  278.         }
  279.     }
  280. }
  282. // all coordinates calculated are relative to widget's origin
  283. void    CMenu::x_Layout(void)
  284. {
  285.     m_Width = 0;
  286.     m_Height = 0;
  287.     m_MaxLabelW = 0;
  288.     int text_w = 0;
  289.     int marker_w = 0;
  290.     
  291.     fl_font(sm_Props.m_FontType, sm_Props.m_FontSize);
  292.     const int item_h = max(m_IconSize, fl_height()) + kItemOffsetY * 2;
  294.     bool b_horz = x_IsHorizontal();
  295.     int i = 0; // iterate by items
  296.     ITERATE(TEntries, it, m_Entries)  {
  297.         const CMenuItem& item = *it->m_Item;
  298.                 
  299.         x_MeasureItem(*it, text_w); // measure text length
  300.         
  301.         if(b_horz) { 
  302.             int icon_space = m_Entries[i].m_hIcon ? 
  303.                             (m_IconSize + kSpace) : 0;
  304.             int w = item.IsSeparator() ? kSeparatorSize : 
  305.                     (icon_space + text_w + 2 * (item.IsItem() ? kItemOffsetX : kSubmenuOffsetX));
  306.             m_Entries[i].m_Size = w;  
  307.             m_Width += w;
  308.         } else  { // vertical orientation
  309.             int h = 0;
  310.             if(item.IsSeparator())  {
  311.                 h = kSeparatorSize;
  312.             } else {
  313.                 if(item.IsSubmenu())    {
  314.                     marker_w = kSubMarkerW;
  315.                 }
  316.                 m_MaxLabelW = max(m_MaxLabelW, text_w);
  317.                 h = item_h;
  318.             }            
  319.             m_Entries[i].m_Size = h;  
  320.             m_Height += h;          
  321.         }
  322.         i++;
  323.     }
  324.     if(b_horz)  {
  325.         m_Height = item_h;
  326.     } else {
  327.         m_Width = (m_IconSize + 2 * kSpace) + kSpace + m_MaxLabelW
  328.                   + (marker_w + 2 * kSpace) + 2 * kItemOffsetX;
  329.     }
  330.     m_Width += 2 * m_Border;
  331.     m_Height += 2 * m_Border;
  332. }
  334. CPoint    CMenu::GetPreferredSize(void) const
  335. {
  336.     return CPoint(m_Width, m_Height);
  337. }
  339. void    CMenu::SetSelected(CMenuItem* item)
  340. {
  341.     if(m_Selected != item)   {
  342.         m_Selected = item;
  343.         GetWidget().damage(FL_DAMAGE_OVERLAY);//redraw();
  344.     }
  345. }
  347. CMenuItem*      CMenu::GetRootItem(void)
  348. {
  349.     return m_RootItem;
  350. }
  352. int     CMenu::GetBorder(void) const
  353. {
  354.     return m_Border;
  355. }
  357. void    CMenu::x_Draw(int x, int y)
  358. {    
  359.     Fl_Widget& wid = GetWidget();
  361.     int w = wid.w(), h = wid.h();
  362.     fl_clip(x, y, w, h);
  364.     if(m_Border > 0)    { // draw frame and border
  365.         fl_color(sm_Props.GetColor(eFrame));
  366.         fl_rect(x, y, w, h); // frame
  368.         fl_color(sm_Props.GetColor(eBorder));
  369.         for( int i = 1; i < m_Border; i++ ) { // border
  370.             fl_rect(i, i, w - 2 * i, h - 2 * i); 
  371.         }
  372.     }
  374.     // fill background not filled by items
  375.     fl_color(sm_Props.GetColor(m_BackColor));
  377.     // fill the right part
  378.     int x_off = m_Width - m_Border;
  379.     fl_rectf(x + x_off, y + m_Border, w - m_Border  - x_off, h - 2 * m_Border);
  381.     // fill the bottom part
  382.     int y_off = m_Height - m_Border;
  383.     fl_rectf(x + m_Border, y + y_off, m_Width - 2 * m_Border, h - m_Border - y_off);
  385.     x_DrawItems(x + m_Border, y + m_Border);
  387.     fl_pop_clip();
  388. }
  390. void    CMenu::x_DrawItems(int x, int y)    
  391. {
  392.     bool b_horz = x_IsHorizontal();
  393.     if(m_RootItem) {
  394.         fl_font(sm_Props.m_FontType, sm_Props.m_FontSize);
  396.         int  i = 0;
  397.         NON_CONST_ITERATE(TEntries, it, m_Entries)    {
  398.             int size = it->m_Size;                        
  399.             if(b_horz)  {
  400.                 x_DrawItem(*it, x, y, size, m_Height - 2 * m_Border);
  401.                 x += size;
  402.             } else {
  403.                 x_DrawItem(*it, x, y, m_Width - 2 * m_Border, size);
  404.                 y += size;
  405.             }
  406.             i++;
  407.         }
  408.     }
  409. }
  411. /// draw single menu item in the given rectangular area
  412. void    CMenu::x_DrawItem(CMenu::SItemEntry& entry, int x, int y, int w, int h)
  413. {
  414.     CMenuItem& item = *entry.m_Item;
  415.     
  416.     bool b_icon = (bool)(entry.m_hIcon);
  417.     int icon_w = x_IsHorizontal() ? (m_IconSize + kSpace) 
  418.                                   : (m_IconSize + 2 * kSpace);
  420.     bool b_focused = false;
  421.     bool b_pushed = false;
  423.     if(x_IsSubMenuPushed()) {
  424.         b_focused = (m_Selected == &item)  &&  item.IsEnabled();
  425.     } else if(x_IsItemPushed())   {
  426.         b_focused = (m_Selected != m_PushedItem)  &&  (m_PushedItem == &item);
  427.         b_pushed = (m_Selected == m_PushedItem)  && (m_PushedItem == &item);
  428.     } else {
  429.         b_focused = (m_Selected == &item)  &&  
  430.             (! x_IsHorizontal()  ||  Fl::belowmouse() == &GetWidget() ||  x_IsKeyActivated());
  431.     }
  432.     bool b_check = item.IsChecked()  ||  item.IsRadioSelected(); // item checked
  433.     
  434.     Fl_Color back_color = FL_RED; 
  435.     if(b_focused  ||  b_pushed)   { // draw focused item with frame        
  436.         EColorType color = (x_IsHorizontal()  &&  item.IsSubmenu())
  437.                             ? (m_PushedItem ? ePopupBack : eFocusedBack)
  438.                             : (b_pushed ? ePushedBack : eFocusedBack);
  439.         back_color = sm_Props.GetColor(color);
  440.         fl_color(back_color);
  441.         fl_rectf(x, y, w, h);
  443.         // draw focused frame
  444.         fl_color(sm_Props.GetColor(x_IsItemPushed() ? eFocusedFrame : eFrame));
  445.         fl_rect(x, y, w, h);
  446.     } else { // draw unfocused item        
  447.         back_color = sm_Props.GetColor(m_BackColor);
  448.         if(x_IsHorizontal())    {    
  449.             if(b_check)    {
  450.                 fl_color(sm_Props.GetColor(eCheckedBack));
  451.                 fl_rectf(x, y, w, h);
  453.                 fl_color(sm_Props.GetColor(eFocusedFrame));
  454.                 fl_rect(x, y, w, h);
  455.             } else {                
  456.                 fl_color(back_color);
  457.                 fl_rectf(x, y, w, h);
  458.             }            
  459.         } else {            
  460.             fl_color(back_color);
  461.             fl_rectf(x + icon_w, y, w - icon_w, h); // fill text background
  463.             back_color = sm_Props.GetColor(eIconArea);
  464.             fl_color(back_color);            
  465.             fl_rectf(x, y, icon_w, h); // draw icon placeholder
  466.         } 
  467.     }
  469.     int y_c = y + h / 2;
  470.             
  471.     if(item.IsSeparator())  { //draw separation line        
  472.         fl_color(sm_Props.GetColor(eDisabledText));    
  473.         if(x_IsHorizontal())    {
  474.             int x_c = x + w / 2;
  475.             fl_line(x_c, y + 1, x_c, y + h - 2); // horz line
  476.         } else {
  477.             fl_line(x + icon_w + 1, y_c, x + w - 2, y_c); // vert line
  478.         }
  479.     } else {  
  480.         // draw Icon
  481.         int x_off = x_IsHorizontal() ? (item.IsItem() ? kItemOffsetX : kSubmenuOffsetX)
  482.                                      : kSpace;
  483.         x_DrawItemIcon(entry, x + x_off, y_c - m_IconSize / 2, back_color);         
  485.         // draw Label adn Accelerator Label
  486.         EColorType text_color = b_focused ? eFocusedDisabledText : eDisabledText;
  487.         if(item.IsEnabled())    {
  488.             text_color = b_pushed ? ePushedText : eText;
  489.         }
  490.         fl_color(sm_Props.GetColor(text_color));
  492.         int text_off = x_off;
  493.         if(x_IsHorizontal())    {
  494.             text_off += b_icon ? (icon_w + kSpace) : 0;
  495.         } else {
  496.             text_off = icon_w + kSpace * 2;
  497.         }    
  498.         x_DrawItemText(entry, x + text_off, y, w, h);      
  499.         
  500.         // draw submenu marker
  501.         if(! x_IsHorizontal()  &&  item.IsSubmenu())    { 
  502.             int N = kSubMarkerH / 2;
  503.             int m_x = x + (w - 1) - kSubMarkerOffset;
  504.             int y_c = y + h / 2;
  505.             
  506.             fl_color(sm_Props.GetColor(eText));
  507.             for( int i = 0; i <= N; i++ )    { // draw triangle as series of lines
  508.                 fl_line(m_x - i, y_c - i, m_x - i, y_c + i);
  509.             }
  510.         }
  511.     }
  512. }
  514. /// draws item's label and accelerator label (if any)
  515. void    CMenu::x_DrawItemText(const CMenu::SItemEntry& entry, int x, int y, int w, int h)
  516. {    
  517.     const CMenuItem& item = *entry.m_Item;
  518.     const string& text = item.GetLabel();
  520.     int text_x = x;
  521.     int y_c = y + h / 2;
  522.     int text_y = y_c + fl_height() / 2 - 2;
  523.    
  524.     int label_len = 0;
  525.     string::size_type pos = text.find(kAccessKeyMarker); // find accelerator marker
  527.     if(pos != string::npos  &&  pos + 1 < text.size())   { // there is an accelerator        
  528.         int line_x = text_x;
  529.         if(pos > 0) {
  530.             fl_draw(text.c_str(), pos, text_x, text_y); // draw all the text before marker
  531.             line_x += (int) ceil(fl_width(text.c_str(), pos));
  532.         }
  533.         
  534.         int line_len = (int) ceil(fl_width(text.c_str() + pos + 1, 1));
  536.         fl_draw(text.c_str() + pos + 1, line_x, text_y); // draw text after Marker
  537.         
  538.         int line_y = text_y + 2;
  539.         fl_line(line_x, line_y, line_x + line_len - 1, line_y); // draw Underscore
  540.     }
  541.     else { // no accelerator - draw plain text
  542.         fl_draw(text.c_str(), text_x, text_y);
  543.     }
  545.     // draw accelerator label
  546.     if(! x_IsHorizontal())  {
  547.         int len = (int) ceil(fl_width(entry.m_AccelLabel.c_str()));
  548.         fl_draw(entry.m_AccelLabel.c_str(), x + m_MaxLabelW - len, text_y);
  549.     }
  551. }
  553. void    CMenu::x_DrawItemIcon(CMenu::SItemEntry& entry, int x, int y, Fl_Color back_color)
  554. {
  555.     CMenuItem& item = *entry.m_Item;
  557.     CFLTKImageHandle hIcon;
  558.     if(item.IsChecked())    {
  559.         hIcon = m_hCheckIcon;
  560.     } else if(item.IsRadioSelected())    {
  561.         hIcon = m_hRadioIcon;
  562.     } else {
  563.         hIcon = entry.m_hIcon;            
  564.     }
  565.     if(hIcon) { //draw icon if any
  566.         Fl_Image* image = &(*hIcon);
  567.         bool disabled = ! item.IsEnabled();
  568.         CPNGImageExt* ext_image = dynamic_cast<CPNGImageExt*>(image);
  569.         if(ext_image)   {
  570.             ext_image->DrawTransparent(back_color, x, y, m_IconSize, m_IconSize, disabled);
  571.         } else {
  572.             if(disabled)    {
  573.                 image = image->copy();
  574.                 image->inactive();
  575.             }
  576.             image->draw(x, y, m_IconSize, m_IconSize);
  577.             if(disabled)    {
  578.                 delete image;
  579.             }
  580.         }
  581.     } 
  582. }
  584. void    CMenu::x_MeasureItem(const SItemEntry& entry, int& text_w) const
  585. {
  586.     CMenuItem& item = *entry.m_Item;
  587.     if(item.IsSeparator())  {
  588.         text_w = 0;
  589.     } else {
  590.         fl_font(sm_Props.m_FontType, sm_Props.m_FontSize);
  591.         const string& text = item.GetLabel();
  592.         text_w = (int) ceil(fl_width(text.c_str()));
  594.         string::size_type pos = text.find(kAccessKeyMarker); // find accelerator marker
  595.         if(pos != string::npos  &&  pos + 1 < text.size())   { // there is an accelerator        
  596.             text_w -= (int) ceil(fl_width("&"));
  597.         }
  599.         if(! x_IsHorizontal())  {
  600.             // measure accelerator label
  601.             text_w += kAccelSpace;
  602.             text_w += (int) ceil(fl_width(entry.m_AccelLabel.c_str()));
  603.         }
  604.     }
  605. }
  607. CRect    CMenu::x_GetPopupItemRect(const CMenuItem& r_item)
  608. {
  609.     bool b_horz = x_IsHorizontal();
  611.     int pos = m_Border;
  612.     if(m_RootItem) {     
  613.         for( size_t i = 0;  i < m_Entries.size();  i++  )  {
  614.             const CMenuItem* item = m_Entries[i].m_Item;
  615.             int size = m_Entries[i].m_Size;
  616.             
  617.             if(item == &r_item)    { // found r_item
  618.                 if(b_horz)  {
  619.                     return CRect(pos, m_Border, pos + size - 1, m_Height - m_Border - 1);
  620.                 } else {
  621.                     return CRect(m_Border, pos, m_Width - m_Border - 1, pos + size - 1);
  622.                 }
  623.                 break;
  624.             } else {
  625.                 pos += size;
  626.             }
  627.         }
  628.     }
  629.     return CRect(0, 0);
  630. }
  633. // returns item containing (x, y) point
  634. CMenuItem*      CMenu::x_HitTest(int x, int y)
  635. {    
  636.     Fl_Widget& wid = GetWidget();
  637.     bool b_horz = x_IsHorizontal();
  638.     
  639.     // to local coords
  640.     x -= wid.x();
  641.     y -= wid.y();
  643.     int i_x = m_Border;
  644.     int i_y = m_Border;
  645.             
  646.     bool b_hit_rect = (b_horz && y >= m_Border  &&  y < m_Border + m_Height) 
  647.                         || (! b_horz  &&  x >= m_Border  &&  x < m_Border + m_Width);
  648.     if(b_hit_rect  &&  m_RootItem) {
  649.         fl_font(sm_Props.m_FontType, sm_Props.m_FontSize);
  650.         int i = 0;
  651.         for( CMenuItem::TChildItem_I it =  m_RootItem->SubItemsBegin();
  652.                                    it != m_RootItem->SubItemsEnd(); ++it, i++  ) {
  653.             CMenuItem& item = *(*it)->GetValue();
  654.             int size = m_Entries[i].m_Size;
  656.             if(b_horz)  {
  657.                 if(x >= i_x  &&  x < i_x + size)  {
  658.                     return &item;
  659.                 } else  i_x += size;
  660.             } else {
  661.                 if(y >= i_y  &&  y < i_y + size)  {
  662.                     return &item;
  663.                 } else  i_y += size;
  664.             }
  665.         }
  666.     }
  667.     return NULL;
  668. }
  670. void    CMenu::x_ExecuteCommand(const CMenuItem& item)
  671. {
  672.     if(item.IsEnabled()  &&  item.IsItem())  {
  673.         TCmdID cmd = item.GetCommand();        
  674.         if(GetCmdTarget())  {
  675.             GetCmdTarget()->OnCommand(cmd);
  676.         } else {
  677.             ERR_POST("CMenu - cannot execute command, not command target specified");
  678.         }
  679.     }     
  680. }
  682. void    WidgetToScreen(const Fl_Widget& widget, int& wx, int& wy)
  683. {
  684.     for( Fl_Window* w = widget.window(); w; w = w->window())   {
  685.         wx += w->x();
  686.         wy += w->y();
  687.     } 
  688. }
  691. ///////////////////////////////////////////////////////////////////////////////
  692. /// CMenuCmdUI
  693. CMenuCmdUI::CMenuCmdUI(CMenuItem& item)
  694. : m_Item(item)
  695. {
  696. }
  698. TCmdID  CMenuCmdUI::GetCommand() const
  699. {
  700.     return m_Item.GetCommand();
  701. }
  703. void    CMenuCmdUI::Enable(bool en)
  704. {
  705.     m_Item.Enable(en);
  706. }
  708. void    CMenuCmdUI::SetCheck(bool set)
  709. {
  710.     m_Item.SetCheck(set);
  711. }
  713. void    CMenuCmdUI::SetRadio(bool set)
  714. {
  715.     m_Item.SelectRadio(set);
  716. }
  718. void    CMenuCmdUI::SetLabel(const string& label)
  719. {
  720.     m_Item.SetLabel(label);
  721. }
  723. ///////////////////////////////////////////////////////////////////////////////
  724. /// CPopupMenu1
  726. CPopupMenu1::TPopupVector    CPopupMenu1::sm_Popups;
  727. CMenuItem*      CPopupMenu1::sm_CurrItem = NULL;
  728. CPopupMenu1*    CPopupMenu1::sm_CurrPopup = NULL;
  729. CPopupMenu1::EState          CPopupMenu1::sm_State;
  730. bool            CPopupMenu1::sm_bMenubar;
  732. CPopupMenu1::CPopupMenu1(int x, int y, CMenuItem* root_item, 
  733.                          CCommandTarget* target, IMenuHintListener* listener)
  734. :   TPopupMenuParent(x, y, 0, 0)
  735. {
  736.     x_Init(x, y, x, y, root_item, target, listener, true);
  737. }
  739. CPopupMenu1::CPopupMenu1(int x, int y, const SMenuItemRec* items, 
  740.                          CCommandTarget* target, IMenuHintListener* listener)
  741. :   TPopupMenuParent(x, y, 0, 0)
  742. {
  743.     CMenuItem* root_item = CreateMenuItems(items);
  744.     x_Init(x, y, x, y, root_item, target, listener, true);
  745. }
  747. // this is a protected constructor used only within CMenu subsystem
  748. // creates a child popup menu. 
  749. CPopupMenu1::CPopupMenu1(int x, int y, int left, int top, CMenuItem* root_item,
  750.                          CCommandTarget* target, IMenuHintListener* listener)
  751. :   TPopupMenuParent(x, y, 0, 0)
  752. {   
  753.    x_Init(x, y, left, top, root_item, target, listener, false);
  754. }
  756. void    CPopupMenu1::x_Init(int x, int y, int left, int top, CMenuItem* root_item, 
  757.                             CCommandTarget* target, IMenuHintListener* listener, bool root_popup)
  758. {
  759.     m_MenuBar = NULL; // popup mode
  761.     position(x, y);
  762.     m_Left = left;
  763.     m_Top = top;
  764.     
  765.     m_bSkipFirstRelease = root_popup;
  766.     
  767.     m_Cmd = eCmdInvalid;
  769.     m_Border = kBorderSize; 
  770.     m_BackColor = ePopupBack;  // override standard color  
  772.     end(); // prevent adding child widgets
  773.     set_modal();    
  774.     clear_border(); // hide frame
  776.     x_SetItems(root_item, root_popup); // own items only if this is a root popup menu
  777.     SetCmdTarget(target);
  778.     SetHintListener(listener);
  779. }
  781. /// Creates root popup menu stub for a menubar
  782. CPopupMenu1::CPopupMenu1(CMenuBar1& menubar, CMenuItem* root_item, CMenuItem* sel_item,
  783.                          IMenuHintListener* listener)
  784. :   TPopupMenuParent(0, 0, 0, 0),
  785.     m_Left(0), m_Top(0),
  786.     m_MenuBar(&menubar),
  787.     m_bSkipFirstRelease(true),
  788.     m_Cmd(eCmdInvalid)
  789. {
  790.     end(); // prevent adding child widgets
  791.     set_modal();    
  792.     clear_border(); // hide frame
  793.     
  794.     m_Border = m_MenuBar->GetBorder();
  795.     
  796.     m_bKeyActivated = menubar.m_bKeyActivated;
  798.     x_SetItems(root_item, false); // share items with the caller
  799.     SetSelected(sel_item);
  800.     SetHintListener(listener);
  801. }
  803. void    CPopupMenu1::x_AdjustRectangle()
  804. {
  805.     if(m_MenuBar)    {    
  806.         CRect rc = m_MenuBar->GetPopupRect();
  807.         
  808.         const Fl_Widget& wid = m_MenuBar->GetWidget();
  809.         int x = 0, y = 0;
  810.         WidgetToScreen(wid, x,y); // upper-left corner to screen coords
  812.         rc.Offset(x, y);
  813.         resize(rc.Left(), rc.Top(), rc.Width(), rc.Height());
  814.     } else {
  815.         // adjsut size
  816.         TPopupMenuParent::size(m_Width, m_Height);    
  818.         int X = x(), Y = y();
  819.         //adjust position on screen
  820.         if(X + m_Width > Fl::w())  { // not enough space to the right
  821.             if(m_Left == X)   {
  822.                 X = Fl::w() - m_Width;
  823.             } else  {
  824.                 X = m_Left - (m_Width -1); // place to the left
  825.             }
  826.         }
  827.         X = max(X, 0);
  828.         x(X);
  829.     
  830.         if(Y + m_Height > Fl::h())   { // not enought space to the bottom
  831.             if(m_Top == Y)    {
  832.                 Y = Fl::h() - m_Height; // scroll up
  833.             } else  {
  834.                 Y = m_Top - (m_Height - 1); // flip up
  835.             }
  836.         }
  837.         Y = max(Y, 0);
  838.         y(Y);
  839.     }
  840. }
  842. void    CPopupMenu1::SetSelected(CMenuItem* item)
  843. {
  844.     if(m_MenuBar)   { // delegate
  845.         CMenuItem* new_item = NULL;
  846.         if(item)    {
  847.             CMenuItem* root = m_MenuBar->GetRootItem();
  848.             new_item = root->FindEqualSubItem(*item);
  850.             _ASSERT(new_item); // must exist
  851.         }
  852.         m_MenuBar->SetSelected(new_item);
  853.     }
  854.     CMenu::SetSelected(item);
  855. }
  857. CRect   CPopupMenu1::x_GetPopupItemRect(const CMenuItem& item)
  858. {
  859.     CRect rc = CMenu::x_GetPopupItemRect(item);
  860.     if(! x_IsMenuBar()) {
  861.         rc.Inflate(m_Border, 0);
  862.     }
  863.     return rc;
  864. }
  866. /// this functions shows Popup menu and all its submenus and provides event 
  867. /// loop for handling all events.
  868. void    CPopupMenu1::Popup()
  869. {
  870.     if(sm_Popups.size())    {
  871.         ERR_POST("CPopupMenu1::Popup() - must not be called recursively.");
  872.         return;
  873.     }
  875.     sm_Popups.push_back(this);
  877.     sm_bMenubar = (this->m_MenuBar != NULL);
  878.     Fl_Group::current(0);
  880.     //grab events and do initialization
  881.     Fl_Window* prev_grab = Fl::grab();
  882.     Fl::grab(*this);
  884.     // set initial state for this menu
  885.     if(sm_bMenubar) {
  886.         sm_CurrItem = m_Selected; // inherit selection from menubar
  887.         if(m_MenuBar->x_IsKeyActivated())   { // do not expand submenus automatically
  888.             sm_State = eIdle;
  889.         } else {
  890.             m_Selected = NULL; // to trigger submenu expansion
  891.             sm_State = eTrackSubmenus;
  892.         }
  893.     } else {
  894.         sm_CurrItem = NULL;
  895.         sm_State = eIdle;
  896.     }
  897.     sm_CurrPopup = this;
  898.     
  899.     CMenuItem* prev_item = NULL;
  901.     m_Timer.Init(1, kMenuDelay, false, this);
  902.     
  903.     do { // message loop - works while popup menus are on screen
  904.         // show hidden menus
  905.         for( size_t i_popup = 0; i_popup < sm_Popups.size(); i_popup++ ) {
  906.             CPopupMenu1* p_popup = sm_Popups[i_popup];
  907.             if(! p_popup->shown())  {
  908.                 p_popup->show();
  909.             }
  910.         }
  911.         
  912.         Fl::wait(); // handle events and calculate new state
  914.         if(sm_CurrItem != prev_item) {
  915.             x_UpdateListener();
  916.         }
  918.         // performs actions depending on cuurent state
  919.         switch(sm_State)    {
  920.         case eIdle:
  921.         case eDone: break;
  922.         case eHide: { //hide one popup
  923.             if(sm_Popups.size() > 1) { // except the first one                
  924.                 CPopupMenu1* dead_menu = sm_Popups.back();
  925.                 delete dead_menu;
  926.                 sm_Popups.pop_back();
  927.             }
  928.             sm_State = eIdle;
  929.         }; break;
  930.         default:
  931.             if(sm_CurrItem == NULL)    {
  932.                 // turn off selection in deepest menu, but don't erase other menus:
  933.                 if(sm_Popups.size())    {
  934.                     sm_Popups.back()->SetSelected(NULL);
  935.                 }
  936.             } else if(! sm_CurrItem->IsSeparator()) { // change selected itme (if it isn;t a separator)
  937.                 
  938.                 if(sm_State == eTrackSubmenus  &&  sm_CurrPopup->m_Selected == sm_CurrItem)  {
  939.                     sm_State = eIdle; // nothing changed
  940.                 } else  {                                
  941.                     TPopupVector::iterator it = std::find(sm_Popups.begin(), sm_Popups.end(), sm_CurrPopup);
  942.                     CMenuItem* item = sm_CurrItem;                    
  944.                     for( int i = it - sm_Popups.begin(); i >= 0; i-- )    {                        
  945.                         sm_Popups[i]->SetSelected(item);
  946.                         item = item->GetParent();            
  947.                     }
  948.                 }        
  949.         
  950.                 sm_CurrPopup->SetSelected(sm_CurrItem);
  952.                 switch(sm_State)    {
  953.                 case eTrack:    {
  954.                     x_CollapseToCurrent(); // close expanded submenus
  955.                 }; break;
  956.                 case eExpand:   {
  957.                     x_ShowCurrItemSubmenu(true); //expand submenu and select item
  958.                     sm_State = eIdle;
  959.                 }; break;
  960.                 case eMenuPush: 
  961.                 {                                    
  962.                     x_CollapseToCurrent(); // close expanded submenus
  963.                     x_ShowCurrItemSubmenu(false); //expand new submenu
  964.                 }; break;
  965.                 case eTrackSubmenus: {
  966.                     if(sm_CurrPopup  &&  sm_CurrPopup->x_IsMenuBar())   {
  967.                         x_CollapseToCurrent(); // close expanded submenus
  968.                         x_ShowCurrItemSubmenu(false); //expand new submenu
  969.                     } else {
  970.                         m_Timer.ReStart();
  971.                     }
  972.                 }; break;
  973.                 default: break;
  974.                 }; //switch
  975.                 sm_State = eIdle; // procesing finished - go to neutral state
  976.             }; 
  977.             prev_item = sm_CurrItem;            
  978.         }//switch
  979.     } while(sm_State != eDone);
  981.     _ASSERT(sm_State == eDone); // check exit condition
  982.     m_Timer.Stop();
  984.     for( size_t i = 1; i < sm_Popups.size(); i++ )  {
  985.         delete sm_Popups[i];
  986.     }
  987.     sm_Popups.clear();
  988.     
  989.     hide(); // close window
  991.     Fl::grab(prev_grab); //return grab to previous owner
  993.     sm_CurrItem = NULL;
  994.     sm_CurrPopup = NULL;
  995.     sm_State = eIdle;
  997.     if(m_Cmd != eCmdInvalid)   {
  998.         if(GetCmdTarget())  {
  999.             GetCmdTarget()->OnCommand(m_Cmd);
  1000.         } else {
  1001.             ERR_POST("CMenu cannot execute command - no command target specifed.");
  1002.         }
  1003.     }
  1004. }
  1006. // close all submenus up to current menu
  1007. void    CPopupMenu1::x_CollapseToCurrent(void)
  1008. {
  1009.     // delete all submenus from the last one to "sm_CurrPopup"
  1010.     while(sm_Popups.size() > 1) { // except the first one
  1011.         CPopupMenu1* dead_menu = sm_Popups.back();
  1012.         if(dead_menu != sm_CurrPopup)  {
  1013.             delete dead_menu;
  1014.             sm_Popups.pop_back();
  1015.         } else break;
  1016.     }
  1017. }
  1019. void    CPopupMenu1::x_ShowCurrItemSubmenu(bool b_select)
  1020. {
  1021.     _ASSERT(sm_CurrItem);
  1023.     if(sm_CurrItem->IsSubmenu()  &&  ! sm_CurrItem->IsSubmenuEmpty())    { // show submenu
  1024.         CRect rc = sm_CurrPopup->x_GetPopupItemRect(*sm_CurrItem);
  1025.         rc.Offset(sm_CurrPopup->x(), sm_CurrPopup->y()); // to screen coords
  1026.         int x, y;
  1027.         if(sm_CurrPopup->x_IsMenuBar())   {
  1028.             x = rc.Left();
  1029.             y = rc.Bottom();
  1030.         } else {
  1031.             x = rc.Right();
  1032.             y = rc.Top();
  1033.         }
  1034.         int left = rc.Left();
  1035.         int top = rc.Top();
  1037.         CPopupMenu1* submenu = new CPopupMenu1(x, y, left, top, sm_CurrItem, 
  1038.                                                GetCmdTarget(), GetHintListener());
  1039.         sm_Popups.push_back(submenu);        
  1040.         
  1041.         sm_CurrPopup = submenu;
  1043.         if(b_select)    {
  1044.             x_SelectNextItem();
  1045.         } else {
  1046.             sm_CurrItem = NULL;            
  1047.         }
  1048.         sm_CurrPopup->SetSelected(sm_CurrItem);                        
  1049.         sm_CurrPopup->show();
  1050.     }
  1051. }
  1053. // changes current item's state to opposite
  1054. void    CPopupMenu1::x_TogglePushItem()
  1055. {
  1056.     _ASSERT(m_bKeyActivated); // not supposed to be used overwise
  1057.     
  1058.     if(m_PushedItem == NULL)    {
  1059.         m_MenuBar->m_PushedItem = m_PushedItem = sm_CurrItem;        
  1060.     } else {
  1061.         m_MenuBar->m_PushedItem = m_PushedItem = NULL;
  1062.         redraw();
  1063.         x_CloseItemSubmenu(); // collapse menu hierarhy        
  1064.     }
  1065.     redraw();
  1066. }
  1068. /// handles events for all CPopupMenu-s being active at the moment
  1069. int     CPopupMenu1::handle(int event)
  1070. {   
  1071.     m_Event.OnFLTKEvent(event);
  1073.     switch(event)   {
  1074.     case FL_KEYDOWN: return x_HandleKeyboard();
  1075.     case FL_ENTER:
  1076.     case FL_LEAVE:
  1077.     case FL_MOVE:
  1078.     case FL_DRAG:
  1079.     case FL_PUSH: 
  1080.     case FL_RELEASE:   {
  1081.         // locate menu item being hit
  1082.         CPopupMenu1* popup = NULL;
  1083.         CMenuItem* item = NULL;
  1084.         int i_popup = sm_Popups.size() - 1;
  1086.         while(item == NULL  &&  i_popup >= 0) {
  1087.             popup = sm_Popups[i_popup];
  1088.             int x = Fl::event_x_root();
  1089.             int y = Fl::event_y_root();
  1090.             item = popup->x_HitTest(x, y);
  1091.             if(item == NULL)  {
  1092.                 i_popup--;
  1093.             }
  1094.         }        
  1095.         if(item  &&  item->IsSeparator())  {
  1096.             item = NULL;
  1097.         }
  1098.         
  1099.         switch(event)   {
  1100.         case FL_PUSH:    {  
  1101.             sm_CurrItem = item;
  1102.             sm_CurrPopup = item ? popup : NULL;
  1104.             // if m_bSkipFirstRelease is "true" then Popup was shown on FL_RELEASE
  1105.             // and we do not need to skip next FL_RELEASE
  1106.             m_bSkipFirstRelease = false; 
  1107.             
  1108.             if(sm_CurrItem  &&  sm_CurrItem->IsSubmenu()) {
  1109.                 if(x_IsKeyActivated())   {
  1110.                     x_TogglePushItem();
  1111.                     sm_State = m_PushedItem ? eMenuPush : eHide;
  1112.                     return 1;
  1113.                 }
  1114.                 sm_State = eMenuPush;
  1115.             } else  {
  1116.                 sm_State = ePush;
  1117.             }
  1118.         }; break;
  1119.         case FL_RELEASE:    {            
  1120.             if(m_bSkipFirstRelease)   {
  1121.                 m_bSkipFirstRelease = false;
  1122.             } else {
  1123.                 bool b_skip  = x_IsKeyActivated()  ||  (item  &&  ! item->IsEnabled());
  1124.                 if(! b_skip)    {
  1125.                     if(item == NULL  ||  item->IsItem()) // command item pushed
  1126.                     {
  1127.                         if(item)    {
  1128.                             x_SetExecuteCommand(*item);
  1129.                         }
  1130.                         sm_State = eDone;
  1131.                     } else if(popup  &&  popup->m_MenuBar)  {
  1132.                         sm_State = eDone;
  1133.                     }
  1134.                 }
  1135.             }   
  1136.         }; break;
  1137.         default: {
  1138.             if(! x_IsKeyActivated()  || item)   {
  1139.                 sm_CurrItem = item;
  1140.                 sm_CurrPopup = item ? popup : NULL;             
  1141.             }
  1142.             sm_State = (! x_IsKeyActivated()  ||  m_PushedItem) ? eTrackSubmenus : eTrack;
  1143.         };
  1144.         };
  1146.         if(event == FL_ENTER ||  event == FL_LEAVE) {
  1147.             redraw(); // we need to repaint itseld to reflect changes in "focused" state
  1148.         }
  1149.         return 1;
  1150.     };
  1151.     };// switch
  1153.     return Fl_Window::handle(event);
  1154. }
  1156. int     CPopupMenu1::x_HandleKeyboard()
  1157. {
  1158.     if(x_HandleShortcuts())  {
  1159.         return 1;
  1160.     }
  1162.     int key = Fl::event_key();
  1163.     if(key == FL_Tab)   {
  1164.         key = (Fl::event_shift()) ? FL_BackSpace : FL_Down;
  1165.     } 
  1166.     
  1167.     switch(key) {
  1168.     case FL_Down: {
  1169.         if(! sm_CurrPopup->x_IsMenuBar())    { // Up-Down works only in submenus
  1170.             x_SelectNextItem();
  1171.         } else if(x_IsKeyActivated())    {
  1172.             x_TogglePushItem();
  1173.             sm_State = eExpand;
  1174.         }
  1175.         return 1;
  1176.     };
  1177.     case FL_Up: {
  1178.         if(! sm_CurrPopup->x_IsMenuBar())    { // Up-Down works only in submenus
  1179.             x_SelectPrevItem();
  1180.         }
  1181.         return 1;
  1182.     };
  1183.     case FL_Right: {
  1184.         x_OnRightPressed();
  1185.         return 1;
  1186.     }; 
  1187.     case FL_Left: {
  1188.         x_OnLeftPressed(); 
  1189.         return 1;
  1190.     };
  1191.     case FL_Page_Up:
  1192.     case FL_Home:   {
  1193.         x_SelectTopItem();
  1194.         return 1;
  1195.     }; 
  1196.     case FL_Page_Down:
  1197.     case FL_End:    {
  1198.         x_SelectBottomItem();
  1199.         return 1;
  1200.     };
  1201.     case FL_Enter:
  1202.     case ' ':   {
  1203.         if(sm_CurrItem  &&  sm_CurrItem->IsEnabled())   {
  1204.             if(sm_CurrItem->IsItem())  {
  1205.                 x_SetExecuteCommand(*sm_CurrItem);
  1206.                 sm_State = eDone;
  1207.             } else {
  1208.                 sm_State = eExpand;
  1209.             }
  1210.         }         
  1211.         return 1;
  1212.     };
  1213.     case FL_Escape: {
  1214.         if(x_IsMenuBar()  &&  x_IsKeyActivated()  &&  sm_Popups.size() > 1) {
  1215.             x_TogglePushItem(); // "unpush" selected item and close submenus
  1216.         } else {
  1217.             sm_CurrPopup = NULL; 
  1218.             sm_State = eDone; // exit menus
  1219.         }
  1220.         return 1;
  1221.     };
  1222.     };
  1223.     return 0;
  1224. }
  1226. // handle both type of keyboard shortcuts - Access Keys and Accelerators
  1227. int    CPopupMenu1::x_HandleShortcuts(void)
  1228. {
  1229.     // first try accelerators
  1230.     int accel = m_Event.GetAccelByEvent();
  1231.     TCmdID cmd = eCmdInvalid;
  1232.     if(CAccelTable::GetCommandByAccel(accel, cmd))    {
  1233.         m_Cmd = cmd;
  1234.         sm_State = eDone;
  1235.         return 1;
  1236.     }
  1237.     // now handling access keys
  1238.     if(sm_CurrPopup)    {
  1239.         char ch = tolower(Fl::event_key());
  1241.         TAccessKeyToItemMap::const_iterator it = sm_CurrPopup->m_AccessKeyToItem.find(ch);
  1242.     
  1243.         if(it != sm_CurrPopup->m_AccessKeyToItem.end())   {
  1244.             sm_CurrItem = it->second;
  1245.             if(sm_CurrItem  &&  sm_CurrItem->IsEnabled())   {
  1246.                 if(sm_CurrItem->IsItem())  {
  1247.                     x_SetExecuteCommand(*sm_CurrItem);
  1248.                     sm_State = eDone;
  1249.                 } else if(sm_CurrItem->IsSubmenu())    {
  1250.                     sm_State = sm_CurrPopup->x_IsMenuBar() ? eTrackSubmenus : eTrack;
  1251.                 }
  1252.             }         
  1253.             return 1;
  1254.         }
  1255.     }
  1256.     return 0;
  1257. }
  1259. void    CPopupMenu1::x_OnLeftPressed(void)
  1260. {
  1261.     if(x_IsMenuBar())   { // root menu is MenuBar
  1262.         if(sm_Popups.size() > 2)    { // close last menu
  1263.             x_CloseItemSubmenu();            
  1264.         } else  { // select previos item in MenuBar
  1265.             sm_CurrPopup = this;
  1266.             x_SelectPrevItem();
  1267.         }
  1268.     } else { // root menu is Popup
  1269.         x_CloseItemSubmenu();
  1270.     }
  1271. }
  1273. void    CPopupMenu1::x_OnRightPressed(void)
  1274. {
  1275.     if(sm_CurrPopup->m_Selected  &&  ! sm_CurrPopup->m_Selected->IsSubmenuEmpty()  &&  m_PushedItem) {
  1276.         sm_State = eExpand;
  1277.     } else {         
  1278.         if(x_IsMenuBar()) {//  &&  sm_Popups.size() > 1  &&  sm_CurrPopup == sm_Popups[1])  {
  1279.             // if current popup is MenuBar's submenu
  1280.             sm_CurrPopup = this; // MenuBar
  1281.             x_SelectNextItem();  // select next item (to the right) in MenuBar
  1282.         }
  1283.     }
  1284. }
  1286. // selects next item in the current menu (Popup or MenuBar)
  1287. void    CPopupMenu1::x_SelectNextItem(void)
  1288. {
  1289.     _ASSERT(sm_CurrPopup);
  1291.     CMenuItem& root = *sm_CurrPopup->m_RootItem;
  1292.     if(! root.IsSubmenuEmpty())    {
  1293.         // find selected ot first if nothing is selected
  1294.         CMenuItem::TChildItem_I it = sm_CurrPopup->m_Selected ? 
  1295.             root.FindSubItem(*sm_CurrPopup->m_Selected) : --root.SubItemsEnd();
  1296.         
  1297.         _ASSERT(it != root.SubItemsEnd());
  1298.         
  1299.         CMenuItem* item = NULL;
  1300.         do {
  1301.             ++it;
  1302.             if(it == root.SubItemsEnd())    {
  1303.                 it = root.SubItemsBegin(); 
  1304.             }
  1305.             item = (*it)->GetValue();
  1306.         } while(item->IsSeparator()  &&  item != sm_CurrPopup->m_Selected);
  1307.     
  1308.         sm_CurrItem = item;
  1309.         sm_State = (sm_CurrPopup->x_IsMenuBar()  &&  ! sm_CurrItem->IsSubmenuEmpty()  &&  m_PushedItem) ? eTrackSubmenus : eTrack;
  1310.     }
  1311. }
  1313. // selects next item in the current menu (Popup or MenuBar)
  1314. void    CPopupMenu1::x_SelectPrevItem(void)
  1315. {
  1316.     _ASSERT(sm_CurrPopup);
  1318.     CMenuItem& root = *sm_CurrPopup->m_RootItem;
  1319.     if(! root.IsSubmenuEmpty())    {
  1320.         // find selected ot fisrt if nothing is selected
  1321.         CMenuItem::TChildItem_I it = sm_CurrPopup->m_Selected ? 
  1322.             root.FindSubItem(*sm_CurrPopup->m_Selected) : root.SubItemsBegin();
  1323.         
  1324.         _ASSERT(it != root.SubItemsEnd());
  1325.     
  1326.         CMenuItem* item = NULL;
  1327.         do {
  1328.             if(it == root.SubItemsBegin())    {
  1329.                 it = root.SubItemsEnd(); 
  1330.             }
  1331.             --it;
  1332.             item = (*it)->GetValue();
  1333.         } while(item->IsSeparator()  &&  item != sm_CurrPopup->m_Selected);
  1334.     
  1335.         sm_CurrItem = item;
  1336.         //sm_State = sm_CurrPopup->x_IsMenuBar() ? eTrackSubmenus : eTrack;
  1337.         sm_State = (sm_CurrPopup->x_IsMenuBar()  &&  ! sm_CurrItem->IsSubmenuEmpty()  &&  m_PushedItem) ? eTrackSubmenus : eTrack;
  1338.     }
  1339. }
  1341. void    CPopupMenu1::x_SelectTopItem(void)
  1342. {
  1343.     if(! sm_CurrPopup->x_IsMenuBar()) {
  1344.         for(size_t i = 0; i < sm_CurrPopup->m_Entries.size(); i++ )  {
  1345.             SItemEntry& entry = sm_CurrPopup->m_Entries[i];
  1346.             CMenuItem* item = entry.m_Item;
  1347.             if(! item->IsSeparator()  &&  item->IsEnabled())    {
  1348.                 sm_CurrItem = item;
  1349.                 sm_State = eTrack; // select
  1350.                 return;
  1351.             }
  1352.         }
  1353.     }
  1354. }
  1356. void    CPopupMenu1::x_SelectBottomItem(void)
  1357. {
  1358.     if(! sm_CurrPopup->x_IsMenuBar()) {
  1359.         for(int i = sm_CurrPopup->m_Entries.size() - 1; i >= 0;  i-- )  {
  1360.             SItemEntry& entry = sm_CurrPopup->m_Entries[i];
  1361.             CMenuItem* item = entry.m_Item;
  1362.             if(! item->IsSeparator()  &&  item->IsEnabled())    {
  1363.                 sm_CurrItem = item;
  1364.                 sm_State = eTrack; // select
  1365.                 return;
  1366.             }
  1367.         }
  1368.     }
  1369. }
  1371. void    CPopupMenu1::x_CloseItemSubmenu(void)
  1372. {
  1373.     if(sm_Popups.size() > 1) {
  1374.         CPopupMenu1* menu = sm_Popups.back();
  1375.         if(sm_CurrPopup == menu)    { // select previous one
  1376.             sm_CurrPopup = sm_Popups[sm_Popups.size() - 2];
  1377.             sm_CurrItem = sm_CurrPopup->m_Selected;
  1378.         }
  1379.         sm_State = eHide;
  1380.     }
  1381. }
  1383. ///  sets command that will be executed on exit
  1384. void    CPopupMenu1::x_SetExecuteCommand(const CMenuItem& item)
  1385. {
  1386.     if(item.IsEnabled()  &&  item.IsItem())  {
  1387.         m_Cmd = item.GetCommand();        
  1388.     } else {
  1389.         m_Cmd = eCmdInvalid;
  1390.     }     
  1391. }
  1393. /// depending on selected item generates text string and supplies it to the 
  1394. /// listener
  1395. void    CPopupMenu1::x_UpdateListener()
  1396. {
  1397.     if(m_Listener)    {
  1398.         string hint;
  1399.         if(sm_CurrItem  &&  sm_CurrItem->IsItem())    {
  1400.             hint = GetCmdHint(sm_CurrItem->GetCommand());
  1401.         }
  1402.         m_Listener->OnHint(hint);
  1403.     }
  1404. }
  1406. void    CPopupMenu1::show(void)
  1407. { 
  1408.     x_AdjustRectangle();
  1409.     x_UpdateItems();
  1410.     
  1411.     TPopupMenuParent::show();
  1412. }
  1414. void    CPopupMenu1::draw(void)
  1415. {    
  1416.     if(m_MenuBar)   { // delegate draing to hosting MenuBar
  1417.         m_MenuBar->x_Draw(0, 0);
  1418.     } else {
  1419.         CMenu::x_Draw(0, 0);
  1420.     }
  1421. }
  1423. Fl_Widget&  CPopupMenu1::GetWidget(void)
  1424. {
  1425.     return *static_cast<Fl_Widget*>(this);
  1426. }
  1428. const Fl_Widget&  CPopupMenu1::GetWidget(void) const
  1429. {
  1430.     return *static_cast<const Fl_Widget*>(this);
  1431. }
  1433. bool    CPopupMenu1::x_IsHorizontal(void) const
  1434. {
  1435.     return m_MenuBar != NULL;
  1436. }
  1438. void    CPopupMenu1::OnTimeout(int timer_id)
  1439. {
  1440.     m_Timer.Stop();
  1441.     if(timer_id == 1)   {        
  1442.         if(sm_CurrPopup  && sm_CurrItem)    {
  1443.             x_CollapseToCurrent(); // close expanded submenus
  1444.             x_ShowCurrItemSubmenu(false); //expand new submenu
  1445.         }
  1446.     }
  1447. }
  1449. ///////////////////////////////////////////////////////////////////////////////
  1450. /// CMenuBar1
  1451. CMenuBar1::CMenuBar1(int x, int y, int w, int h)
  1452. :   Fl_Widget(x, y, w, h),
  1453.     m_TooltipItem(NULL)
  1454. {
  1455.     m_Border = 2;
  1456.     
  1457.     m_Tooltip.SetMode(CTooltip::eStayOnMove);
  1458.     m_Tooltip.EnableActiveMode(this);
  1459. }
  1461. void    CMenuBar1::EnableTooltips(bool b_en)
  1462. {
  1463.     m_Tooltip.Enable(b_en);
  1464. }
  1466. void    CMenuBar1::Activate()
  1467. {
  1468.     if(m_RootItem  &&  ! m_RootItem->IsSubmenuEmpty())  {
  1469.         CMenuItem* item = (* m_RootItem->SubItemsBegin())->GetValue();
  1470.         
  1471.         SetSelected(item);
  1472.         m_PushedItem = NULL; // not pushed by default
  1473.         m_bKeyActivated = true;
  1474.         
  1475.         x_ShowSubMenu();
  1476.         
  1477.         m_bKeyActivated = false;
  1478.     }
  1479. }
  1481. void    CMenuBar1::draw(void)
  1482. {
  1483.    Fl_Widget& wid = GetWidget();
  1484.    x_Draw(wid.x(), wid.y());
  1485. }
  1487. void    CMenuBar1::x_Draw(int x, int y)
  1488. {    
  1489.    CMenu::x_Draw(x, y); 
  1490.    
  1491.    Fl_Widget& wid = GetWidget();
  1492.    fl_draw_box(FL_THIN_UP_FRAME, x, y, wid.w(), wid.h(), sm_Props.GetColor(eBack));
  1493. }
  1495. Fl_Widget&  CMenuBar1::GetWidget(void)
  1496. {
  1497.     return *static_cast<Fl_Widget*>(this);
  1498. }
  1500. const Fl_Widget&  CMenuBar1::GetWidget() const
  1501. {
  1502.     return *static_cast<const Fl_Widget*>(this);
  1503. }
  1505. CRect   CMenuBar1::GetPopupRect(void) const
  1506. {
  1507.     int w = GetWidget().w();
  1508.     int h = GetWidget().h();
  1509.     return CRect(x(), y(), x() + w -1, y() + h - 1);
  1510. }
  1512. int     CMenuBar1::handle(int event)
  1513. {
  1514.     int res = x_Handle(event);
  1515.     return res ? res : Fl_Widget::handle(event);
  1516. }
  1518. int     CMenuBar1::x_Handle(int event)
  1519. {
  1520.     m_Tooltip.Handle(event);
  1522.     switch(event)   {
  1523.     case FL_ENTER:
  1524.     case FL_MOVE:
  1525.     case FL_DRAG:
  1526.     case FL_PUSH:   
  1527.     case FL_LEAVE: {
  1528.         CMenuItem* item = x_HitTest(Fl::event_x(), Fl::event_y());
  1529.         if(item  && item->IsSeparator())  {
  1530.             item = NULL;
  1531.         }
  1532.         SetSelected(item);
  1533.         
  1534.         switch(event)   {
  1535.         case FL_PUSH:    {
  1536.             m_PushedItem = item;
  1538.             if(m_Selected  &&  m_Selected->IsEnabledSubmenu())    {            
  1539.                 // FL_RELEASE for this FL_PUSH will be handled inside popup menu stub
  1540.                 x_ShowSubMenu();                    
  1541.                 // when we return from x_ShowSubMenu() it should not be considered pressed
  1542.                 m_PushedItem = NULL;
  1543.             }
  1544.             GetWidget().redraw();            
  1545.         }; break;
  1546.         case FL_ENTER:
  1547.         case FL_LEAVE:  {
  1548.             redraw();
  1549.         }; break;
  1550.         };
  1551.         return 1;
  1552.     };
  1553.     case FL_RELEASE:    {            
  1554.         CMenuItem* item = x_HitTest(Fl::event_x(), Fl::event_y());
  1556.         if(item  &&  item == m_PushedItem  //&&  Fl::event_is_click()
  1557.             &&  x_IsItemPushed())    {
  1558.             x_ExecuteCommand(*m_PushedItem); 
  1559.         }
  1560.         m_PushedItem = NULL;
  1561.         GetWidget().redraw();
  1562.         return 1;
  1563.     }
  1564.     };
  1565.     return 0;    
  1566. }
  1568. int     CMenuBar1::x_HandleShortcuts(void)
  1569. {
  1570.     char ch = tolower(Fl::event_key());
  1572.     TAccessKeyToItemMap::const_iterator it = m_AccessKeyToItem.find(ch);
  1573.     
  1574.     if(it != m_AccessKeyToItem.end())   {
  1575.         SetSelected(it->second);
  1576.         x_ShowSubMenu();
  1577.         return 1;
  1578.     }
  1579.     return 0;
  1580. }
  1582. void    CMenuBar1::x_ShowSubMenu(void)
  1583. {
  1584.     if(m_Selected->IsEnabled()) {
  1585.         if(m_Selected->IsSubmenu()  &&  ! m_Selected->IsSubmenuEmpty()) {   // show popup menu                  
  1586.             CPopupMenu1 popup(*this, m_RootItem, m_Selected, GetHintListener());
  1587.             popup.SetCmdTarget(GetCmdTarget());
  1588.             popup.Popup();
  1590.             SetSelected(NULL);
  1591.         }
  1592.     }    
  1593. }
  1595. bool    CMenuBar1::x_IsHorizontal(void) const
  1596. {
  1597.     return true;
  1598. }
  1600. bool    CMenuBar1::TC_NeedTooltip(int x, int y)
  1601. {
  1602.     m_TooltipItem = x_HitTest(x, y);
  1603.     bool en = m_TooltipItem  &&  ! m_TooltipItem->IsSeparator();
  1604.     return en;
  1605. }
  1607. string  CMenuBar1::TC_GetTooltip(int& x, int& y, int& w, int& h)
  1608. {
  1609.     _ASSERT(m_TooltipItem);
  1611.     CRect rc = x_GetPopupItemRect(*m_TooltipItem);
  1612.     x = rc.Left();
  1613.     y = rc.Top();
  1614.     w = rc.Width();
  1615.     h = rc.Height();
  1617.     return x_GetTooltip(*m_TooltipItem);
  1618. }
  1620. string  CMenuBar1::x_GetTooltip(const CMenuItem& item) const
  1621. {
  1622.     // find accelerator label if any
  1623.     string s_accel;
  1624.     ITERATE(TEntries, it, m_Entries)  {
  1625.         if(it->m_Item == &item) {
  1626.             s_accel = it->m_AccelLabel;
  1627.             break;
  1628.         }
  1629.     }
  1631.     string label = item.GetLabel();
  1633.     string::size_type pos = label.find(kAccessKeyMarker); // find accelerator marker
  1635.     if(pos != string::npos  &&  pos + 1 < label.size())   { // there is an accelerator        
  1636.         label.erase(pos, 1);
  1637.     }
  1638.     
  1639.     if(s_accel.size())  {
  1640.         label += " (";
  1641.         label += s_accel + ")";
  1642.     }
  1643.     return label;
  1644. }
  1646. END_NCBI_SCOPE
  1648. /*
  1649.  * ===========================================================================
  1650.  * $Log: menu_window.cpp,v $
  1651.  * Revision 1000.0  2004/06/01 21:29:21  gouriano
  1652.  * PRODUCTION: IMPORTED [GCC34_MSVC7] Dev-tree R1.7
  1653.  *
  1654.  * Revision 1.7  2004/05/21 22:27:53  gorelenk
  1655.  * Added PCH ncbi_pch.hpp
  1656.  *
  1657.  * Revision 1.6  2004/05/13 17:29:39  yazhuk
  1658.  * Added support for accelerators, keyboard activated menus
  1659.  *
  1660.  * Revision 1.5  2004/05/10 20:58:11  ucko
  1661.  * +<math.h> for ceil
  1662.  *
  1663.  * Revision 1.4  2004/05/10 16:25:40  yazhuk
  1664.  * Addressed GCC warnings
  1665.  *
  1666.  * Revision 1.3  2004/05/07 14:19:29  yazhuk
  1667.  * Added UpdateItems(), fixed focus handling
  1668.  *
  1669.  * Revision 1.2  2004/05/03 19:47:36  yazhuk
  1670.  * Refactoring; support for command updates
  1671.  *
  1672.  * Revision 1.1  2004/04/22 16:56:35  yazhuk
  1673.  * Initial revision
  1674.  *
  1675.  * ===========================================================================
  1676.  */