src/MenuBackend.C

   1 /* This file is part of
   2  * ======================================================
   3  *
   4  *           LyX, The Document Processor
   5  *
   6  *           Copyright 1995 Matthias Ettrich
   7  *           Copyright 1995-2000 The LyX Team.
   8  *
   9  *
  10  * ====================================================== */
  11
  12 #ifdef __GNUG__
  13 #pragma implementation
  14 #endif
  15
  16 #include <config.h>
  17 #include "MenuBackend.h"
  18 #include "lyxlex.h"
  19 #include "LyXAction.h"
  20 #include "debug.h"
  21
  22 extern LyXAction lyxaction;
  23
  24 using std::endl;
  25
  26 // This is the global menu definition
  27 MenuBackend menubackend;
  28
  29
  30 MenuItem::MenuItem(Kind kind, string const & label, string const & command)
  31         : kind_(kind), label_(label)
  32 {
  33         switch(kind) {
  34         case Separator:
  35         case Documents:
  36         case Lastfiles:
  37                 break;
  38         case Command:
  39                 action_ = lyxaction.LookupFunc(command);
  40
  41                 if (action_ == LFUN_UNKNOWN_ACTION) {
  42                         lyxerr << "MenuItem(): LyX command `"
  43                                << command << "' does not exist." << endl;
  44                 }
  45                 break;
  46         case Submenu:
  47                 submenu_ = command;
  48                 break;
  49         }
  50 }
  51
  52
  53 Menu & Menu::add(MenuItem const & i)
  54 {
  55         items_.push_back(i);
  56         return *this;
  57 }
  58
  59
  60 void Menu::read(LyXLex & lex)
  61 {
  62         enum Menutags {
  63                 md_item = 1,
  64                 md_documents,
  65                 md_endmenu,
  66                 md_lastfiles,
  67                 md_submenu,
  68                 md_separator,
  69                 md_last
  70         };
  71
  72         struct keyword_item menutags[md_last-1] = {
  73                 { "documents", md_documents },
  74                 { "end", md_endmenu },
  75                 { "item", md_item },
  76                 { "lastfiles", md_lastfiles },
  77                 { "separator", md_separator },
  78                 { "submenu", md_submenu }
  79         };
  80
  81         lex.pushTable(menutags, md_last - 1);
  82         if (lyxerr.debugging(Debug::PARSER))
  83                 lex.printTable(lyxerr);
  84
  85         bool quit = false;
  86
  87         while (lex.IsOK() && !quit) {
  88                 switch(lex.lex()) {
  89                 case md_item: {
  90                         lex.next();
  91                         string name = lex.GetString();
  92                         lex.next();
  93                         string command = lex.GetString();
  94                         add(MenuItem(MenuItem::Command, name, command));
  95                         break;
  96                 }
  97                 case md_separator:
  98                         add(MenuItem(MenuItem::Separator));
  99                         break;
 100                 case md_lastfiles:
 101                         add(MenuItem(MenuItem::Lastfiles));
 102                         break;
 103                 case md_documents:
 104                         add(MenuItem(MenuItem::Documents));
 105                         break;
 106                 case md_submenu: {
 107                         lex.next();
 108                         string mlabel = lex.GetString();
 109                         lex.next();
 110                         string mname = lex.GetString();
 111                         add(MenuItem(MenuItem::Submenu, mlabel, mname));
 112                         break;
 113                 }
 114                 case md_endmenu:
 115                         quit = true;
 116                         break;
 117                 default:
 118                         lex.printError("menubar::read: "
 119                                        "Unknown menu tag: `$$Token'");
 120                         break;
 121                 }
 122         }
 123         lex.popTable();
 124 }
 125
 126
 127 void MenuBackend::read(LyXLex & lex)
 128 {
 129         enum Menutags {
 130                 md_menu = 1,
 131                 md_menubar,
 132                 md_endmenuset,
 133                 md_last
 134         };
 135
 136         struct keyword_item menutags[md_last - 1] = {
 137                 { "end", md_endmenuset },
 138                 { "menu", md_menu },
 139                 { "menubar", md_menubar }
 140         };
 141
 142         //consistency check
 143         if (compare_no_case(lex.GetString(), "menuset"))
 144                 lyxerr << "Menubackend::read: ERROR wrong token:`"
 145                        << lex.GetString() << '\'' << endl;
 146
 147         lex.pushTable(menutags, md_last - 1);
 148         if (lyxerr.debugging(Debug::PARSER))
 149                 lex.printTable(lyxerr);
 150
 151         bool quit = false;
 152
 153         while (lex.IsOK() && !quit) {
 154                 switch(lex.lex()) {
 155                 case md_menu: {
 156                         lex.next();
 157                         string name = lex.GetString();
 158                         Menu menu(name, false);
 159                         menu.read(lex);
 160                         add(menu);
 161                         break;
 162                 }
 163                 case md_menubar: {
 164                         lex.next();
 165                         string name = lex.GetString();
 166                         Menu menubar(name, true);
 167                         menubar.read(lex);
 168                         add(menubar);
 169                         break;
 170                 }
 171                 case md_endmenuset:
 172                         quit = true;
 173                         break;
 174                 default:
 175                         lex.printError("menubackend::read: "
 176                                        "Unknown menu tag: `$$Token'");
 177                         break;
 178                 }
 179         }
 180         lex.popTable();
 181 }
 182
 183
 184 void MenuBackend::defaults()
 185 {
 186         menulist_.clear();
 187
 188         lyxerr[Debug::GUI] << "MenuBackend::defaults: using default values"
 189                            << endl;
 190
 191         Menu file("file");
 192         file
 193                 .add(MenuItem(MenuItem::Command, "New...|N", "buffer-new"))
 194                 .add(MenuItem(MenuItem::Command, "Open...|O", "buffer-open"))
 195                 .add(MenuItem(MenuItem::Submenu, "Import|I", "import"))
 196                 .add(MenuItem(MenuItem::Command, "Quit|Q", "lyx-quit"))
 197                 .add(MenuItem(MenuItem::Separator))
 198                 .add(MenuItem(MenuItem::Lastfiles));
 199         add(file);
 200
 201         Menu import("import");
 202         import
 203                 .add(MenuItem(MenuItem::Command,
 204                               "LaTeX...|L", "buffer-import latex"))
 205                 .add(MenuItem(MenuItem::Command,
 206                               "LinuxDoc...|L", "buffer-import linuxdoc"));
 207         add(import);
 208
 209         Menu edit("edit");
 210         edit
 211                 .add(MenuItem(MenuItem::Command, "Cut", "cut"))
 212                 .add(MenuItem(MenuItem::Command, "Copy", "copy"))
 213                 .add(MenuItem(MenuItem::Command, "Paste", "paste"))
 214                 .add(MenuItem(MenuItem::Command, "Emphasize", "font-emph"));
 215         add(edit);
 216
 217         Menu documents("documents");
 218         documents.add(MenuItem(MenuItem::Documents));
 219         add(documents);
 220
 221         Menu main("main", true);
 222         main
 223                 .add(MenuItem(MenuItem::Submenu, "File|F", "file"))
 224                 .add(MenuItem(MenuItem::Submenu, "Edit|E", "edit"))
 225                 .add(MenuItem(MenuItem::Submenu,
 226                               "Documents|D", "documents"));
 227         add(main);
 228
 229         Menu main_nobuffer("main_nobuffer", true);
 230         main_nobuffer.add(MenuItem(MenuItem::Submenu, "File|F", "file"));
 231         add(main_nobuffer);
 232
 233         if (lyxerr.debugging(Debug::GUI)) {
 234                 for(const_iterator cit = begin();
 235                     cit != end() ; ++cit)
 236                         lyxerr << "Menu name: " << cit->name()
 237                                << ", Menubar: " << cit->menubar()
 238                                << endl;
 239         }
 240 }
 241
 242
 243 void MenuBackend::add(Menu const & menu)
 244 {
 245         menulist_.push_back(menu);
 246 }
 247
 248
 249 bool MenuBackend::hasMenu(string const & name) const
 250 {
 251         for (const_iterator cit = begin(); cit != end(); ++cit) {
 252                 if ((*cit).name() == name)
 253                         return true;
 254         }
 255         return false;
 256 }
 257
 258
 259 Menu const & MenuBackend::getMenu(string const & name) const
 260 {
 261         for (const_iterator cit = begin(); cit != end(); ++cit) {
 262                 if ((*cit).name() == name)
 263                         return (*cit);
 264         }
 265         Assert(false); // we actually require the name to exist.
 266         return menulist_.front();
 267 }