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(view);
  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                 GuiPopupMenu * qMenu = new GuiPopupMenu(view, *m, true);
  79                 view->menuBar()->addMenu(qMenu);
  80
  81                 name_map_[toqstr(name)] = qMenu;
  82         }
  83 }
  84
  85
  86 QMenu * Menus::menu(QString const & name)
  87 {
  88         LYXERR(Debug::GUI, "Context menu requested: "
  89                 << qstring_to_ucs4(name));
  90         GuiPopupMenu * menu = name_map_.value(name, 0);
  91         if (!menu)
  92                 LYXERR0("resquested context menu not found: "
  93                         << qstring_to_ucs4(name));
  94         return menu;
  95 }
  96
  97
  98 /// Some special Qt/Mac support hacks
  99
 100 /*
 101   Here is what the Qt documentation says about how a menubar is chosen:
 102
 103      1) If the window has a QMenuBar then it is used. 2) If the window
 104      is a modal then its menubar is used. If no menubar is specified
 105      then a default menubar is used (as documented below) 3) If the
 106      window has no parent then the default menubar is used (as
 107      documented below).
 108
 109      The above 3 steps are applied all the way up the parent window
 110      chain until one of the above are satisifed. If all else fails a
 111      default menubar will be created, the default menubar on Qt/Mac is
 112      an empty menubar, however you can create a different default
 113      menubar by creating a parentless QMenuBar, the first one created
 114      will thus be designated the default menubar, and will be used
 115      whenever a default menubar is needed.
 116
 117   Thus, for Qt/Mac, we add the menus to a free standing menubar, so
 118   that this menubar will be used also when one of LyX' dialogs has
 119   focus. (JMarc)
 120 */
 121
 122 void Menus::macxMenuBarInit(GuiView * view)
 123 {
 124         // The Mac menubar initialisation must be done only once!
 125         static bool done = false;
 126         if (done)
 127                 return;
 128         done = true;
 129
 130         /* Since Qt 4.2, the qt/mac menu code has special code for
 131            specifying the role of a menu entry. However, it does not
 132            work very well with our scheme of creating menus on demand,
 133            and therefore we need to put these entries in a special
 134            invisible menu. (JMarc)
 135         */
 136
 137         /* The entries of our special mac menu. If we add support for
 138          * special entries in MenuBackend, we could imagine something
 139          * like
 140          *    SpecialItem About " "About LyX" "dialog-show aboutlyx"
 141          * and therefore avoid hardcoding. I am not sure it is worth
 142          * the hassle, though. (JMarc)
 143          */
 144         struct MacMenuEntry {
 145                 kb_action action;
 146                 char const * arg;
 147                 char const * label;
 148                 QAction::MenuRole role;
 149         };
 150
 151         MacMenuEntry entries[] = {
 152                 {LFUN_DIALOG_SHOW, "aboutlyx", "About LyX",
 153                  QAction::AboutRole},
 154                 {LFUN_DIALOG_SHOW, "prefs", "Preferences",
 155                  QAction::PreferencesRole},
 156                 {LFUN_RECONFIGURE, "", "Reconfigure",
 157                  QAction::ApplicationSpecificRole},
 158                 {LFUN_LYX_QUIT, "", "Quit LyX", QAction::QuitRole}
 159         };
 160         const size_t num_entries = sizeof(entries) / sizeof(MacMenuEntry);
 161
 162         // the special menu for MenuBackend.
 163         Menu special;
 164         for (size_t i = 0 ; i < num_entries ; ++i) {
 165                 FuncRequest const func(entries[i].action,
 166                                        from_utf8(entries[i].arg));
 167                 special.add(MenuItem(MenuItem::Command,
 168                                      from_utf8(entries[i].label),
 169                                      func));
 170         }
 171         specialMenu(special);
 172
 173         // add the entries to a QMenu that will eventually be empty
 174         // and therefore invisible.
 175         QMenu * qMenu = view->menuBar()->addMenu("special");
 176
 177         // we do not use 'special' because it is a temporary variable,
 178         // whereas MenuBackend::specialMenu points to a persistent
 179         // copy.
 180         Menu::const_iterator cit = specialMenu().begin();
 181         Menu::const_iterator end = specialMenu().end();
 182         for (size_t i = 0 ; cit != end ; ++cit, ++i) {
 183                 Action * action = new Action(*view, QIcon(),
 184                                              toqstr(cit->label()),
 185                                              cit->func(), QString());
 186                 action->setMenuRole(entries[i].role);
 187                 qMenu->addAction(action);
 188
 189         }
 190 }
 191
 192 } // namespace frontend
 193 } // namespace lyx
 194
 195 #include "Menus_moc.cpp"