Mercurialglemon-0.x / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
main_win.cc
author ladanyi
Wed, 10 Jan 2007 14:37:46 +0000
changeset 184 4e8704aae278
parent 174 95872af46fc4
child 190 2cac5b936a2b
permissions -rw-r--r--
Added support for setting the background form an image file. 
     1 /* -*- C++ -*-

     2  *

     3  * This file is a part of LEMON, a generic C++ optimization library

     4  *

     5  * Copyright (C) 2003-2006

     6  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

     7  * (Egervary Research Group on Combinatorial Optimization, EGRES).

     8  *

     9  * Permission to use, modify and distribute this software is granted

    10  * provided that this copyright notice appears in all copies. For

    11  * precise terms see the accompanying LICENSE file.

    12  *

    13  * This software is provided "AS IS" with no warranty of any kind,

    14  * express or implied, and with no claim as to its suitability for any

    15  * purpose.

    16  *

    17  */

    18 

    19 #ifdef HAVE_CONFIG_H

    20 #include <config.h>

    21 #endif

    22 

    23 #include "main_win.h"

    24 #include "guipixbufs.h"

    25 #include "background_chooser_dialog.h"

    26 

    27 #include "i18n.h"

    28 

    29 MainWin::MainWin()

    30 {

    31   set_title ("no file");

    32   set_default_size(WIN_WIDTH,WIN_HEIGHT);

    33   //add(vbox);

    34   add(table);

    35 

    36   // custom icons for the toolbar

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

    38  

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

    40       2328, gui_icons_move);

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

    42       2328, gui_icons_addnode);

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

    44       2328, gui_icons_addlink);

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

    46       2328, gui_icons_delete);

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

    48       2328, gui_icons_editlink);

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

    50       2328, gui_icons_newmap);

    51 

    52   Gtk::IconSource move_icon_source;

    53   move_icon_source.set_pixbuf(p_move_pixbuf);

    54   Gtk::IconSet move_icon_set;

    55   move_icon_set.add_source(move_icon_source);

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

    57 

    58   Gtk::IconSource addnode_icon_source;

    59   addnode_icon_source.set_pixbuf(p_addnode_pixbuf);

    60   Gtk::IconSet addnode_icon_set;

    61   addnode_icon_set.add_source(addnode_icon_source);

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

    63 

    64   Gtk::IconSource addlink_icon_source;

    65   addlink_icon_source.set_pixbuf(p_addlink_pixbuf);

    66   Gtk::IconSet addlink_icon_set;

    67   addlink_icon_set.add_source(addlink_icon_source);

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

    69 

    70   Gtk::IconSource delete_icon_source;

    71   delete_icon_source.set_pixbuf(p_delete_pixbuf);

    72   Gtk::IconSet delete_icon_set;

    73   delete_icon_set.add_source(delete_icon_source);

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

    75 

    76   Gtk::IconSource editlink_icon_source;

    77   editlink_icon_source.set_pixbuf(p_editlink_pixbuf);

    78   Gtk::IconSet editlink_icon_set;

    79   editlink_icon_set.add_source(editlink_icon_source);

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

    81 

    82   Gtk::IconSource newmap_icon_source;

    83   newmap_icon_source.set_pixbuf(p_newmap_pixbuf);

    84   Gtk::IconSet newmap_icon_set;

    85   newmap_icon_set.add_source(newmap_icon_source);

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

    87 

    88   p_icon_factory->add_default();

    89   

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

    91 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   107 

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

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

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

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

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

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

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

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

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

   117   ag->add( Gtk::Action::create("SetBackground", _("Set Background...")),

   118 	    sigc::mem_fun(*this, &MainWin::createBackgroundChooser));

   119   

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

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

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

   123   ag->add( Gtk::Action::create("ShowDesign", _("_Design")),

   124 	   sigc::mem_fun(*this, &MainWin::createDesignWin));

   125 

   126   ag->add( Gtk::Action::create("AlgoMenu", _("_Algorithms")) );

   127   ag->add( Gtk::Action::create("AlgoGeneral", _("_General")),

   128 	   sigc::bind( sigc::mem_fun ( *this, &MainWin::createAlgoWin ), 0) );

   129   ag->add( Gtk::Action::create("AlgoKruskal", _("_Kruskal")),

   130 	   sigc::bind( sigc::mem_fun ( *this, &MainWin::createAlgoWin ), 1) );

   131   ag->add( Gtk::Action::create("AlgoDijkstra", _("_Dijkstra")),

   132 	   sigc::bind( sigc::mem_fun ( *this, &MainWin::createAlgoWin ), 2) );

   133   ag->add( Gtk::Action::create("AlgoSuurballe", _("_Suurballe")),

   134 	   sigc::bind( sigc::mem_fun ( *this, &MainWin::createAlgoWin ), 3) );

   135 

   136   Gtk::RadioAction::Group tool_group;

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

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

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

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

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

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

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

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

   145 

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

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

   148 

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

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

   151 

   152   ag->add( Gtk::Action::create("DesignGraph", Gtk::Stock::REFRESH),

   153       sigc::mem_fun ( *this , &MainWin::reDesignGraph ) );

   154 

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

   156   uim->insert_action_group(ag);

   157   add_accel_group(uim->get_accel_group());

   158 

   159   try

   160   {

   161 

   162     Glib::ustring ui_info =

   163       "<ui>"

   164       "  <menubar name='MenuBar'>"

   165       "    <menu action='FileMenu'>"

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

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

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

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

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

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

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

   173       "    </menu>"

   174       "    <menu action='ViewMenu'>"

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

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

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

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

   179       "      <menuitem action='SetBackground' />"

   180       "    </menu>"

   181       "    <menu action='ShowMenu'>"

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

   183       "      <menuitem action='ShowDesign'/>"

   184       "    </menu>"

   185       "    <menu action='AlgoMenu'>"

   186       "      <menuitem action='AlgoGeneral'/>"

   187       "      <menuitem action='AlgoKruskal'/>"

   188       "      <menuitem action='AlgoDijkstra'/>"

   189       "      <menuitem action='AlgoSuurballe'/>"

   190       "    </menu>"

   191       "  </menubar>"

   192       "  <toolbar name='ToolBar'>"

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

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

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

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

   197       "    <separator />"

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

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

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

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

   202       "    <separator />"

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

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

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

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

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

   208       "    <separator />"

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

   210       "    <toolitem action='DesignGraph' />"

   211       "  </toolbar>"

   212       "</ui>";

   213 

   214     uim->add_ui_from_string(ui_info);

   215 

   216   }

   217   catch(const Glib::Error& ex)

   218   {

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

   220   }

   221 

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

   223   if (menubar){

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

   225     table.attach(*menubar, 0, 1, 0, 1, Gtk::EXPAND|Gtk::FILL, Gtk::SHRINK);

   226   }

   227 

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

   229   if (toolbar)

   230   {

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

   232     //hbox.pack_start(*toolbar, Gtk::PACK_EXPAND_WIDGET);

   233 

   234     table.attach(*toolbar, 0, 1, 1, 2, Gtk::EXPAND|Gtk::FILL, Gtk::SHRINK);

   235 

   236   }

   237  

   238   table2.set_row_spacings(10);

   239   table2.set_col_spacings(5);

   240 

   241   auto_scale = new Gtk::CheckButton("Autoscale");

   242   auto_scale->set_active(false);

   243   auto_scale->signal_toggled().connect(sigc::mem_fun(*this, &MainWin::nodeViewChanged));

   244   table2.attach(*auto_scale, 0,2,0,1);

   245 

   246   Gtk::Label * width_label= new Gtk::Label("Edge Width:");

   247   table2.attach(*width_label, 0,1,1,2);

   248   

   249   Gtk::Adjustment * adjustment_width=new Gtk::Adjustment(20, 1, 200, 5, 10);

   250   

   251   edge_width = new Gtk::SpinButton(*adjustment_width, 5,0);

   252   edge_width->signal_value_changed().connect(sigc::mem_fun(*this, &MainWin::nodeViewChanged));

   253   table2.attach(*edge_width, 1,2,1,2);

   254 

   255   Gtk::Label * radius_label= new Gtk::Label("Node Radius:");

   256   table2.attach(*radius_label, 2,3,1,2);

   257   

   258   Gtk::Adjustment * adjustment_radius=new Gtk::Adjustment(20, 0, 500, 5, 10);

   259 

   260   radius_size = new Gtk::SpinButton(*adjustment_radius, 5,0);

   261   radius_size->signal_value_changed().connect(sigc::mem_fun(*this, &MainWin::nodeViewChanged));

   262   table2.attach(*radius_size, 3,4,1,2);

   263 

   264   zoom_track = new Gtk::CheckButton("Zoom tracking");

   265   zoom_track->set_active(false);

   266   zoom_track->signal_toggled().connect(sigc::mem_fun(*this, &MainWin::nodeViewChanged));

   267   table2.attach(*zoom_track, 2,4,0,1);

   268 

   269 

   270   table.attach(table2, 1, 2, 0, 2, Gtk::SHRINK, Gtk::SHRINK);

   271 

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

   273   tooltips.enable();

   274 

   275   active_tab=-1;

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

   277 

   278   active_tool = MOVE;

   279 

   280   table.attach(notebook,0,2,2,3, Gtk::EXPAND|Gtk::FILL, Gtk::EXPAND|Gtk::FILL);

   281   

   282   show_all_children();

   283 }

   284 

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

   286 {

   287   if(strinst.find(name)==strinst.end())

   288     {

   289       tabnames[active_tab]=name;

   290       strinst[name]=1;

   291     }

   292   else

   293     {

   294       strinst[name]++;

   295       std::ostringstream o;

   296       o << strinst[name];

   297       tabnames[active_tab]=name+" - "+o.str();

   298     }

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

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

   301   updateAlgoWinTabs();

   302 }

   303 

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

   305 {

   306   newTab();

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

   308 }

   309 

   310 void MainWin::newTab()

   311 {

   312   int size=tabs.size();

   313   tabs.resize(size+1);

   314   tabnames.resize(size+1);

   315   active_tab=size;

   316   tabs[active_tab]=new NoteBookTab();

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

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

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

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

   321   notebook.set_current_page(size);

   322   set_tabtitle(_("unsaved file"));

   323   updateAlgoWinTabs();

   324 }

   325 

   326 void MainWin::closeTab()

   327 {

   328   if(active_tab!=-1)

   329     {

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

   331 	{

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

   333 				     Gtk::MESSAGE_WARNING, Gtk::BUTTONS_NONE);

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

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

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

   337 	  switch (mdialog.run())

   338 	    {

   339 	    case Gtk::RESPONSE_CANCEL:

   340 	      return;

   341 	    case Gtk::RESPONSE_REJECT:

   342 	      break;

   343 	    case Gtk::RESPONSE_ACCEPT:

   344 	      tabs[active_tab]->saveFile();

   345 	      break;

   346 	    }

   347 	}

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

   349       int size=tabs.size();

   350       if(size>1)

   351 	{

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

   353 	    {

   354 	      tabnames[i-1]=tabnames[i];

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

   356 	    }

   357 	}

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

   359       tabs.resize(size-1);

   360       tabnames.resize(size-1);

   361 

   362       int old_active_tab=active_tab;

   363       notebook.remove_page(active_tab);

   364 

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

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

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

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

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

   370       //as well.

   371       if((old_active_tab==0)&&(size!=1))

   372 	{

   373 	  onChangeTab(NULL,0);

   374 	}

   375 

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

   377       //no active_tab now

   378       if(size==1)

   379 	{

   380 	  active_tab=-1;

   381 	}

   382 

   383       updateAlgoWinTabs();

   384     }

   385 }

   386 

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

   388 {

   389   page=page;

   390   active_tab=page_num;

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

   392   set_title(tabnames[active_tab]);

   393   bool autoscale;

   394   bool zoomtrack;

   395   double width;

   396   double radius;

   397   tabs[active_tab]->getView(autoscale, zoomtrack, width, radius);

   398   edge_width->set_value(width);

   399   radius_size->set_value(radius);

   400   zoom_track->set_active(zoomtrack);

   401   auto_scale->set_active(autoscale);

   402 

   403 }

   404 

   405 void MainWin::newFile()

   406 {

   407   if(active_tab!=-1)

   408     {

   409       tabs[active_tab]->newFile();

   410     }

   411 }

   412  

   413 void MainWin::openFile()

   414 {

   415   if(active_tab==-1)

   416     {

   417       newTab();

   418     }

   419   tabs[active_tab]->openFile();

   420 }

   421  

   422 void MainWin::saveFile()

   423 {

   424   if(active_tab!=-1)

   425     {

   426       tabs[active_tab]->saveFile();

   427     }

   428 }

   429  

   430 void MainWin::saveFileAs()

   431 {

   432   if(active_tab!=-1)

   433     {

   434       tabs[active_tab]->saveFileAs();

   435     }

   436 }

   437  

   438 void MainWin::close()

   439 {

   440   if(active_tab!=-1)

   441     {

   442       tabs[active_tab]->close();

   443     }

   444 }

   445 

   446 void MainWin::zoomIn()

   447 {

   448   if(active_tab!=-1)

   449     {

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

   451     }

   452 }

   453 

   454 void MainWin::zoomOut()

   455 {

   456   if(active_tab!=-1)

   457     {

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

   459     }

   460 }

   461 

   462 void MainWin::zoomFit()

   463 {

   464   if(active_tab!=-1)

   465     {

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

   467     }

   468 }

   469 

   470 void MainWin::zoom100()

   471 {

   472   if(active_tab!=-1)

   473     {

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

   475     }

   476 }

   477 

   478 void MainWin::createMapWin()

   479 {

   480   if(active_tab!=-1)

   481     {

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

   483     }

   484 }

   485 

   486 void MainWin::createDesignWin()

   487 {

   488   if(active_tab!=-1)

   489     {

   490       tabs[active_tab]->createDesignWin(tabnames[active_tab]);

   491     }

   492 }

   493 

   494 void MainWin::createAlgoWin(int algoid)

   495 {

   496   AlgoWin * aw=new AlgoWin(algoid, tabnames);

   497   aw->signal_closing().connect(sigc::mem_fun(*this, &MainWin::deRegisterAlgoWin));

   498   aw->signal_maplist_needed().connect(sigc::mem_fun(*this, &MainWin::updateAlgoWinMaps));

   499   aw->signal_newmapwin_needed().connect(sigc::mem_fun(*this, &MainWin::createNewMapWinTabString));

   500   aws.insert(aw);

   501   aw->show();

   502 }

   503 

   504 void MainWin::updateAlgoWinTabs()

   505 {

   506   std::set< AlgoWin* >::iterator awsi=aws.begin();

   507   for(;awsi!=aws.end();awsi++)

   508     {

   509       (*awsi)->update_tablist(tabnames);

   510     }

   511 }

   512 

   513 void MainWin::updateAlgoWinMaps(AlgoWin * awp, std::string tabname)

   514 {

   515   int i=0;

   516   for(;(i<(int)tabnames.size())&&(tabnames[i]!=tabname);i++)

   517     {

   518     }

   519   awp->update_maplist(&(tabs[i]->mapstorage));

   520 }

   521 

   522 void MainWin::deRegisterAlgoWin(AlgoWin * awp)

   523 {

   524   aws.erase(awp);

   525 }

   526 

   527 void MainWin::changeEditorialTool(int tool)

   528 {

   529   active_tool=tool;

   530   if(active_tab!=-1)

   531     {

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

   533     }

   534 }

   535 

   536 void MainWin::createNewMapWin()

   537 {

   538   if(active_tab!=-1)

   539     {

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

   541       nmw->show();

   542     }

   543 }

   544 

   545 void MainWin::createNewMapWinTabString(std::string tabname, bool itisedge)

   546 {

   547   int i=0;

   548   for(;((i<(int)tabnames.size())&&(tabnames[i]!=tabname));i++)

   549     {

   550     }

   551   createNewMapWinAfterSignal(tabs[i], itisedge);

   552 }

   553 

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

   555 {

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

   557   int i=0;

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

   559     {

   560       if(*nbti!=nbt)

   561 	{

   562 	  i++;

   563 	}

   564       else

   565 	{

   566 	  continue;

   567 	}

   568     }

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

   570   nmw->run();

   571 }

   572 

   573 

   574 void MainWin::nodeViewChanged()

   575 {

   576   double width=edge_width->get_value();

   577   double radius=radius_size->get_value();

   578   bool zoomtrack=zoom_track->get_active();

   579   bool autoscale=auto_scale->get_active();

   580   tabs[active_tab]->setView(autoscale, zoomtrack, width, radius);

   581 }

   582 

   583 void MainWin::reDesignGraph()

   584 {

   585   tabs[active_tab]->reDesignGraph();

   586 }

   587 

   588 void MainWin::createBackgroundChooser()

   589 {

   590   BackgroundChooserDialog dialog(&(tabs[active_tab]->mapstorage));

   591   dialog.run();

   592 }
glemon-0.x