Mercuriallemon-0.x / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
gui/main_win.cc
author hegyi
Tue, 03 Jan 2006 14:56:45 +0000
changeset 1869 52f5a7f9fb48
parent 1862 d47ebd34e581
child 1871 3905d347112c
permissions -rw-r--r--
Handling of tabs is rationalized a bit. More than one file can be given at startup in command prompt. If there is no file given in command prompt, an empty tab will be present at startup. 
     1 #include "main_win.h"

     2 #include "guipixbufs.h"

     3 

     4 MainWin::MainWin()

     5 {

     6   set_title ("no file");

     7   set_default_size(WIN_WIDTH,WIN_HEIGHT);

     8   add(vbox);

     9 

    10   // custom icons for the toolbar

    11   Glib::RefPtr<Gtk::IconFactory> p_icon_factory = Gtk::IconFactory::create();

    12  

    13   Glib::RefPtr<Gdk::Pixbuf> p_move_pixbuf = Gdk::Pixbuf::create_from_inline(

    14       2328, gui_icons_move);

    15   Glib::RefPtr<Gdk::Pixbuf> p_addnode_pixbuf = Gdk::Pixbuf::create_from_inline(

    16       2328, gui_icons_addnode);

    17   Glib::RefPtr<Gdk::Pixbuf> p_addlink_pixbuf = Gdk::Pixbuf::create_from_inline(

    18       2328, gui_icons_addlink);

    19   Glib::RefPtr<Gdk::Pixbuf> p_delete_pixbuf = Gdk::Pixbuf::create_from_inline(

    20       2328, gui_icons_delete);

    21   Glib::RefPtr<Gdk::Pixbuf> p_editlink_pixbuf = Gdk::Pixbuf::create_from_inline(

    22       2328, gui_icons_editlink);

    23   Glib::RefPtr<Gdk::Pixbuf> p_editnode_pixbuf = Gdk::Pixbuf::create_from_inline(

    24       2328, gui_icons_editnode);

    25   Glib::RefPtr<Gdk::Pixbuf> p_newmap_pixbuf = Gdk::Pixbuf::create_from_inline(

    26       2328, gui_icons_newmap);

    27 

    28   Gtk::IconSource move_icon_source;

    29   move_icon_source.set_pixbuf(p_move_pixbuf);

    30   Gtk::IconSet move_icon_set;

    31   move_icon_set.add_source(move_icon_source);

    32   p_icon_factory->add(Gtk::StockID("gd-move"), move_icon_set);

    33 

    34   Gtk::IconSource addnode_icon_source;

    35   addnode_icon_source.set_pixbuf(p_addnode_pixbuf);

    36   Gtk::IconSet addnode_icon_set;

    37   addnode_icon_set.add_source(addnode_icon_source);

    38   p_icon_factory->add(Gtk::StockID("gd-addnode"), addnode_icon_set);

    39 

    40   Gtk::IconSource addlink_icon_source;

    41   addlink_icon_source.set_pixbuf(p_addlink_pixbuf);

    42   Gtk::IconSet addlink_icon_set;

    43   addlink_icon_set.add_source(addlink_icon_source);

    44   p_icon_factory->add(Gtk::StockID("gd-addlink"), addlink_icon_set);

    45 

    46   Gtk::IconSource delete_icon_source;

    47   delete_icon_source.set_pixbuf(p_delete_pixbuf);

    48   Gtk::IconSet delete_icon_set;

    49   delete_icon_set.add_source(delete_icon_source);

    50   p_icon_factory->add(Gtk::StockID("gd-delete"), delete_icon_set);

    51 

    52   Gtk::IconSource editlink_icon_source;

    53   editlink_icon_source.set_pixbuf(p_editlink_pixbuf);

    54   Gtk::IconSet editlink_icon_set;

    55   editlink_icon_set.add_source(editlink_icon_source);

    56   p_icon_factory->add(Gtk::StockID("gd-editlink"), editlink_icon_set);

    57 

    58   Gtk::IconSource editnode_icon_source;

    59   editnode_icon_source.set_pixbuf(p_editnode_pixbuf);

    60   Gtk::IconSet editnode_icon_set;

    61   editnode_icon_set.add_source(editnode_icon_source);

    62   p_icon_factory->add(Gtk::StockID("gd-editnode"), editnode_icon_set);

    63 

    64   Gtk::IconSource newmap_icon_source;

    65   newmap_icon_source.set_pixbuf(p_newmap_pixbuf);

    66   Gtk::IconSet newmap_icon_set;

    67   newmap_icon_set.add_source(newmap_icon_source);

    68   p_icon_factory->add(Gtk::StockID("gd-newmap"), newmap_icon_set);

    69 

    70   p_icon_factory->add_default();

    71   

    72   ag=Gtk::ActionGroup::create();

    73 

    74   ag->add( Gtk::Action::create("FileMenu", "_File") );

    75   ag->add( Gtk::Action::create("FileNew", Gtk::Stock::NEW),

    76       sigc::mem_fun(*this, &MainWin::newTab));

    77   ag->add( Gtk::Action::create("FileOpen", Gtk::Stock::OPEN),

    78       sigc::mem_fun(*this, &MainWin::openFile));

    79   ag->add( Gtk::Action::create("FileClearTab", "Clear Tab"),

    80       sigc::mem_fun(*this, &MainWin::newFile));

    81   ag->add( Gtk::Action::create("FileSave", Gtk::Stock::SAVE),

    82       sigc::mem_fun(*this, &MainWin::saveFile));

    83   ag->add( Gtk::Action::create("FileSaveAs", Gtk::Stock::SAVE_AS),

    84       sigc::mem_fun(*this, &MainWin::saveFileAs));

    85   ag->add( Gtk::Action::create("Close", Gtk::Stock::CLOSE),

    86       sigc::mem_fun(*this, &MainWin::closeTab));

    87   ag->add( Gtk::Action::create("Quit", Gtk::Stock::QUIT),

    88       sigc::mem_fun(*this, &MainWin::hide));

    89 

    90   ag->add( Gtk::Action::create("ViewMenu", "_View") );

    91   ag->add( Gtk::Action::create("ViewZoomIn", Gtk::Stock::ZOOM_IN),

    92       sigc::mem_fun(*this, &MainWin::zoomIn));

    93   ag->add( Gtk::Action::create("ViewZoomOut", Gtk::Stock::ZOOM_OUT),

    94       sigc::mem_fun(*this, &MainWin::zoomOut));

    95   ag->add( Gtk::Action::create("ViewZoomFit", Gtk::Stock::ZOOM_FIT),

    96       sigc::mem_fun(*this, &MainWin::zoomFit));

    97   ag->add( Gtk::Action::create("ViewZoom100", Gtk::Stock::ZOOM_100),

    98       sigc::mem_fun(*this, &MainWin::zoom100));

    99   

   100   ag->add( Gtk::Action::create("ShowMenu", "_Show") );

   101   ag->add( Gtk::Action::create("ShowMaps", "_Maps"),

   102 	   sigc::mem_fun(*this, &MainWin::createMapWin));

   103 

   104   Gtk::RadioAction::Group tool_group;

   105   ag->add( Gtk::RadioAction::create(tool_group, "MoveItem", Gtk::StockID("gd-move"), "Move"),

   106       sigc::bind( sigc::mem_fun ( *this, &MainWin::changeEditorialTool ), 0) );

   107   ag->add( Gtk::RadioAction::create(tool_group, "CreateNode", Gtk::StockID("gd-addnode"), "Create node"),

   108       sigc::bind( sigc::mem_fun ( *this, &MainWin::changeEditorialTool ), 1) );

   109   ag->add( Gtk::RadioAction::create(tool_group, "CreateEdge", Gtk::StockID("gd-addlink"), "Create edge"),

   110       sigc::bind( sigc::mem_fun ( *this, &MainWin::changeEditorialTool ), 2) );

   111   ag->add( Gtk::RadioAction::create(tool_group, "EraseItem", Gtk::StockID("gd-delete"), "Delete"),

   112       sigc::bind( sigc::mem_fun ( *this, &MainWin::changeEditorialTool ), 3) );

   113 

   114   ag->add( Gtk::RadioAction::create(tool_group, "EditEdgeMap", Gtk::StockID("gd-editlink"), "Edit edge map"),

   115       sigc::bind( sigc::mem_fun ( *this, &MainWin::changeEditorialTool ), 4) );

   116   ag->add( Gtk::RadioAction::create(tool_group, "EditNodeMap", Gtk::StockID("gd-editnode"), "Edit node map"),

   117       sigc::bind( sigc::mem_fun ( *this, &MainWin::changeEditorialTool ), 5) );

   118 

   119   ag->add( Gtk::Action::create("AddMap", Gtk::StockID("gd-newmap")),

   120       sigc::mem_fun ( *this , &MainWin::createNewMapWin ) );

   121 

   122   uim=Gtk::UIManager::create();

   123   uim->insert_action_group(ag);

   124   add_accel_group(uim->get_accel_group());

   125 

   126   try

   127   {

   128 

   129     Glib::ustring ui_info =

   130       "<ui>"

   131       "  <menubar name='MenuBar'>"

   132       "    <menu action='FileMenu'>"

   133       "      <menuitem action='FileNew'/>"

   134       "      <menuitem action='FileOpen'/>"

   135       "      <menuitem action='FileClearTab'/>"

   136       "      <menuitem action='FileSave'/>"

   137       "      <menuitem action='FileSaveAs'/>"

   138       "      <menuitem action='Close'/>"

   139       "      <menuitem action='Quit'/>"

   140       "    </menu>"

   141       "    <menu action='ViewMenu'>"

   142       "      <menuitem action='ViewZoomIn' />"

   143       "      <menuitem action='ViewZoomOut' />"

   144       "      <menuitem action='ViewZoom100' />"

   145       "      <menuitem action='ViewZoomFit' />"

   146       "    </menu>"

   147       "    <menu action='ShowMenu'>"

   148       "      <menuitem action='ShowMaps'/>"

   149       "    </menu>"

   150       "  </menubar>"

   151       "  <toolbar name='ToolBar'>"

   152       "    <toolitem action='FileNew' />"

   153       "    <toolitem action='FileOpen' />"

   154       "    <toolitem action='FileSave' />"

   155       "    <toolitem action='Close' />"

   156       "    <separator />"

   157       "    <toolitem action='ViewZoomIn' />"

   158       "    <toolitem action='ViewZoomOut' />"

   159       "    <toolitem action='ViewZoom100' />"

   160       "    <toolitem action='ViewZoomFit' />"

   161       "    <separator />"

   162       "    <toolitem action='MoveItem' />"

   163       "    <toolitem action='CreateNode' />"

   164       "    <toolitem action='CreateEdge' />"

   165       "    <toolitem action='EraseItem' />"

   166       "    <toolitem action='EditEdgeMap' />"

   167       "    <toolitem action='EditNodeMap' />"

   168       "    <separator />"

   169       "    <toolitem action='AddMap' />"

   170       "  </toolbar>"

   171       "</ui>";

   172 

   173     uim->add_ui_from_string(ui_info);

   174 

   175   }

   176   catch(const Glib::Error& ex)

   177   {

   178     std::cerr << "building menus failed: " <<  ex.what();

   179   }

   180 

   181   Gtk::Widget* menubar = uim->get_widget("/MenuBar");

   182   if (menubar){

   183     vbox.pack_start(*menubar, Gtk::PACK_SHRINK);

   184   }

   185 

   186   Gtk::Widget* toolbar = uim->get_widget("/ToolBar");

   187   if (toolbar)

   188   {

   189     static_cast<Gtk::Toolbar*>(toolbar)->set_toolbar_style(Gtk::TOOLBAR_ICONS);

   190     vbox.pack_start(*toolbar, Gtk::PACK_SHRINK);

   191   }

   192 

   193   tooltips.set_tip(*(uim->get_widget("/ToolBar/CreateNode")),"Create Node");

   194   tooltips.enable();

   195 

   196   active_tab=-1;

   197   notebook.signal_switch_page().connect(sigc::mem_fun(*this, &MainWin::onChangeTab));

   198 

   199   vbox.pack_start(notebook);

   200   

   201   show_all_children();

   202 }

   203 

   204 void MainWin::set_tabtitle(std::string name)

   205 {

   206   tabnames[active_tab]=name;

   207   set_title(tabnames[active_tab] + " - " + prog_name);

   208   notebook.set_tab_label_text((Widget&)*(tabs[active_tab]), tabnames[active_tab]);

   209 }

   210 

   211 void MainWin::readFile(const std::string & filename)

   212 {

   213   newTab();

   214   tabs[active_tab]->readFile(filename);

   215 }

   216 

   217 void MainWin::newTab()

   218 {

   219   int size=tabs.size();

   220   tabs.resize(size+1);

   221   tabnames.resize(size+1);

   222   active_tab=size;

   223   tabs[active_tab]=new NoteBookTab();

   224   tabnames[active_tab]="unsaved file";

   225   tabs[active_tab]->signal_title_ch().connect(sigc::mem_fun(*this, &MainWin::set_tabtitle));

   226   tabs[active_tab]->signal_newmap_needed().connect(sigc::mem_fun(*this, &MainWin::createNewMapWinAfterSignal));

   227   tabs[active_tab]->gd_canvas->changeEditorialTool(active_tool);

   228   notebook.append_page((Gtk::Widget&)(*(tabs[active_tab])));

   229   notebook.set_current_page(size);

   230   set_tabtitle(tabnames[active_tab]);

   231 }

   232 

   233 void MainWin::closeTab()

   234 {

   235   if(active_tab!=-1)

   236     {

   237       if (tabs[active_tab]->mapstorage.modified)

   238 	{

   239 	  Gtk::MessageDialog mdialog("<b>Save changes before closing?</b>", true, 

   240 				     Gtk::MESSAGE_WARNING, Gtk::BUTTONS_NONE);

   241 	  mdialog.add_button("Close file _without Saving", Gtk::RESPONSE_REJECT);

   242 	  mdialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);

   243 	  mdialog.add_button(Gtk::Stock::SAVE, Gtk::RESPONSE_ACCEPT);

   244 	  switch (mdialog.run())

   245 	    {

   246 	    case Gtk::RESPONSE_CANCEL:

   247 	      return;

   248 	    case Gtk::RESPONSE_REJECT:

   249 	      break;

   250 	    case Gtk::RESPONSE_ACCEPT:

   251 	      tabs[active_tab]->saveFile();

   252 	      break;

   253 	    }

   254 	}

   255       //tabs vector will be decreased with the deleted value

   256       int size=tabs.size();

   257       if(size>1)

   258 	{

   259 	  for(int i=active_tab+1;i<size;i++)

   260 	    {

   261 	      tabs[i-1]=tabs[i];

   262 	    }

   263 	}

   264 

   265       //if size==1 resize will delete the only element

   266       tabs.resize(size-1);

   267 

   268       int old_active_tab=active_tab;

   269       notebook.remove_page(active_tab);

   270 

   271       //If the first tab was active, upon delete notebook

   272       //will first switch one tab upper and not lower like

   273       //in the case, when not the first tab was active.

   274       //But after deletion it will become the first tab,

   275       //and this should be registrated in tabs vector,

   276       //as well.

   277       if(old_active_tab==0)

   278 	{

   279 	  onChangeTab(NULL,0);

   280 	}

   281 

   282       //if this was the last page in notebook, there is

   283       //no active_tab now

   284       if(size==1)

   285 	{

   286 	  active_tab=-1;

   287 	}

   288     }

   289 }

   290 

   291 void MainWin::onChangeTab(GtkNotebookPage* page, guint page_num)

   292 {

   293   page=page;

   294   active_tab=page_num;

   295   tabs[active_tab]->gd_canvas->changeEditorialTool(active_tool);

   296   set_title(tabnames[active_tab]);

   297 }

   298 

   299 void MainWin::onCloseTab()

   300 {

   301 }

   302 

   303 void MainWin::newFile()

   304 {

   305   if(active_tab!=-1)

   306     {

   307       tabs[active_tab]->newFile();

   308     }

   309 }

   310  

   311 void MainWin::openFile()

   312 {

   313   if(active_tab!=-1)

   314     {

   315       tabs[active_tab]->openFile();

   316     }

   317 }

   318  

   319 void MainWin::saveFile()

   320 {

   321   if(active_tab!=-1)

   322     {

   323       tabs[active_tab]->saveFile();

   324     }

   325 }

   326  

   327 void MainWin::saveFileAs()

   328 {

   329   if(active_tab!=-1)

   330     {

   331       tabs[active_tab]->saveFileAs();

   332     }

   333 }

   334  

   335 void MainWin::close()

   336 {

   337   if(active_tab!=-1)

   338     {

   339       tabs[active_tab]->close();

   340     }

   341 }

   342 

   343 void MainWin::zoomIn()

   344 {

   345   if(active_tab!=-1)

   346     {

   347       tabs[active_tab]->gd_canvas->zoomIn();

   348     }

   349 }

   350 

   351 void MainWin::zoomOut()

   352 {

   353   if(active_tab!=-1)

   354     {

   355       tabs[active_tab]->gd_canvas->zoomOut();

   356     }

   357 }

   358 

   359 void MainWin::zoomFit()

   360 {

   361   if(active_tab!=-1)

   362     {

   363       tabs[active_tab]->gd_canvas->zoomFit();

   364     }

   365 }

   366 

   367 void MainWin::zoom100()

   368 {

   369   if(active_tab!=-1)

   370     {

   371       tabs[active_tab]->gd_canvas->zoom100();

   372     }

   373 }

   374 

   375 void MainWin::createMapWin()

   376 {

   377   if(active_tab!=-1)

   378     {

   379       tabs[active_tab]->createMapWin(tabnames[active_tab]);

   380     }

   381 }

   382 

   383 void MainWin::changeEditorialTool(int tool)

   384 {

   385   active_tool=tool;

   386   if(active_tab!=-1)

   387     {

   388       tabs[active_tab]->gd_canvas->changeEditorialTool(tool);

   389     }

   390 }

   391 

   392 void MainWin::createNewMapWin()

   393 {

   394   if(active_tab!=-1)

   395     {

   396       NewMapWin * nmw=new NewMapWin("Create New Map - "+tabnames[active_tab], *(tabs[active_tab]));

   397       nmw->show();

   398     }

   399 }

   400 

   401 void MainWin::createNewMapWinAfterSignal(NoteBookTab * nbt, bool itisedge)

   402 {

   403   std::vector<NoteBookTab*>::iterator nbti=tabs.begin();

   404   int i=0;

   405   for(;nbti!=tabs.end();nbti++)

   406     {

   407       if(*nbti!=nbt)

   408 	{

   409 	  i++;

   410 	}

   411       else

   412 	{

   413 	  continue;

   414 	}

   415     }

   416   NewMapWin * nmw=new NewMapWin("Create New Map - "+tabnames[i], *nbt, itisedge, false);

   417   nmw->run();

   418 }
lemon-0.x