src/frontends/qt4/Menus.cpp

   1 /**
   2  * \file qt4/Menus.cpp
   3  * This file is part of LyX, the document processor.
   4  * Licence details can be found in the file COPYING.
   5  *
   6  * \author John Levon
   7  *
   8  * Full author contact details are available in file CREDITS.
   9  */
  10
  11 #include <config.h>
  12
  13 #include "Menus.h"
  14
  15 #include "Action.h"
  16 #include "GuiApplication.h"
  17 #include "GuiPopupMenu.h"
  18 #include "GuiView.h"
  19
  20 #include "qt_helpers.h"
  21
  22 #include "support/debug.h"
  23
  24 #include <QCursor>
  25 #include <QMenuBar>
  26
  27
  28 namespace lyx {
  29 namespace frontend {
  30
  31 // MacOSX specific stuff is at the end.
  32
  33 void Menus::fillMenuBar(GuiView * view)
  34 {
  35         // Clear all menubar contents before filling it.
  36         view->menuBar()->clear();
  37
  38 #ifdef Q_WS_MACX
  39         // setup special mac specific menu item
  40         macxMenuBarInit();
  41 #endif
  42
  43         LYXERR(Debug::GUI, "populating menu bar" << to_utf8(getMenubar().name()));
  44
  45         if (getMenubar().size() == 0) {
  46                 LYXERR(Debug::GUI, "\tERROR: empty menu bar"
  47                         << to_utf8(getMenubar().name()));
  48                 return;
  49         }
  50         else {
  51                 LYXERR(Debug::GUI, "menu bar entries "
  52                         << getMenubar().size());
  53         }
  54
  55         Menu menu;
  56         expand(getMenubar(), menu, view->buffer());
  57
  58         Menu::const_iterator m = menu.begin();
  59         Menu::const_iterator end = menu.end();
  60
  61         for (; m != end; ++m) {
  62
  63                 if (m->kind() != MenuItem::Submenu) {
  64                         LYXERR(Debug::GUI, "\tERROR: not a submenu " << to_utf8(m->label()));
  65                         continue;
  66                 }
  67
  68                 LYXERR(Debug::GUI, "menu bar item " << to_utf8(m->label())
  69                         << " is a submenu named " << to_utf8(m->submenuname()));
  70
  71                 docstring name = m->submenuname();
  72                 if (!hasMenu(name)) {
  73                         LYXERR(Debug::GUI, "\tERROR: " << to_utf8(name)
  74                                 << " submenu has no menu!");
  75                         continue;
  76                 }
  77
  78                 Menu menu;
  79                 expand(getMenubar(), menu, view->buffer());
  80
  81                 GuiPopupMenu * qMenu = new GuiPopupMenu(view, *m, true);
  82                 view->menuBar()->addMenu(qMenu);
  83
  84                 name_map_[toqstr(name)] = qMenu;
  85         }
  86 }
  87
  88
  89 void Menus::openByName(QString const & name)
  90 {
  91         if (QMenu * menu = name_map_.value(name))
  92                 menu->exec(QCursor::pos());
  93 }
  94
  95
  96 /// Some special Qt/Mac support hacks
  97
  98 /*
  99   Here is what the Qt documentation says about how a menubar is chosen:
 100
 101      1) If the window has a QMenuBar then it is used. 2) If the window
 102      is a modal then its menubar is used. If no menubar is specified
 103      then a default menubar is used (as documented below) 3) If the
 104      window has no parent then the default menubar is used (as
 105      documented below).
 106
 107      The above 3 steps are applied all the way up the parent window
 108      chain until one of the above are satisifed. If all else fails a
 109      default menubar will be created, the default menubar on Qt/Mac is
 110      an empty menubar, however you can create a different default
 111      menubar by creating a parentless QMenuBar, the first one created
 112      will thus be designated the default menubar, and will be used
 113      whenever a default menubar is needed.
 114
 115   Thus, for Qt/Mac, we add the menus to a free standing menubar, so
 116   that this menubar will be used also when one of LyX' dialogs has
 117   focus. (JMarc)
 118 */
 119
 120 void Menus::macxMenuBarInit(GuiView * view)
 121 {
 122         /* Since Qt 4.2, the qt/mac menu code has special code for
 123            specifying the role of a menu entry. However, it does not
 124            work very well with our scheme of creating menus on demand,
 125            and therefore we need to put these entries in a special
 126            invisible menu. (JMarc)
 127         */
 128
 129         /* The entries of our special mac menu. If we add support for
 130          * special entries in MenuBackend, we could imagine something
 131          * like
 132          *    SpecialItem About " "About LyX" "dialog-show aboutlyx"
 133          * and therefore avoid hardcoding. I am not sure it is worth
 134          * the hassle, though. (JMarc)
 135          */
 136         struct MacMenuEntry {
 137                 kb_action action;
 138                 char const * arg;
 139                 char const * label;
 140                 QAction::MenuRole role;
 141         };
 142
 143         MacMenuEntry entries[] = {
 144                 {LFUN_DIALOG_SHOW, "aboutlyx", "About LyX",
 145                  QAction::AboutRole},
 146                 {LFUN_DIALOG_SHOW, "prefs", "Preferences",
 147                  QAction::PreferencesRole},
 148                 {LFUN_RECONFIGURE, "", "Reconfigure",
 149                  QAction::ApplicationSpecificRole},
 150                 {LFUN_LYX_QUIT, "", "Quit LyX", QAction::QuitRole}
 151         };
 152         const size_t num_entries = sizeof(entries) / sizeof(MacMenuEntry);
 153
 154         // the special menu for MenuBackend.
 155         Menu special;
 156         for (size_t i = 0 ; i < num_entries ; ++i) {
 157                 FuncRequest const func(entries[i].action,
 158                                        from_utf8(entries[i].arg));
 159                 special.add(MenuItem(MenuItem::Command,
 160                                      from_utf8(entries[i].label),
 161                                      func));
 162         }
 163         specialMenu(special);
 164
 165         // add the entries to a QMenu that will eventually be empty
 166         // and therefore invisible.
 167         QMenu * qMenu = view->menuBar()->addMenu("special");
 168
 169         // we do not use 'special' because it is a temporary variable,
 170         // whereas MenuBackend::specialMenu points to a persistent
 171         // copy.
 172         Menu::const_iterator cit = specialMenu().begin();
 173         Menu::const_iterator end = specialMenu().end();
 174         for (size_t i = 0 ; cit != end ; ++cit, ++i) {
 175                 Action * action = new Action(*view, QIcon(),
 176                                              toqstr(cit->label()),
 177                                              cit->func(), QString());
 178                 action->setMenuRole(entries[i].role);
 179                 qMenu->addAction(action);
 180
 181         }
 182 }
 183
 184 } // namespace frontend
 185 } // namespace lyx
 186
 187 #include "Menus_moc.cpp"