Mercurialglemon-0.x / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
nbtab.cc
changeset 194 6b2b718420eb
parent 191 af2ed974ab68
child 195 125c56c1efda
equal deleted inserted replaced
15:343ed08bbc64 16:bfb09b09c4ec 
    15  * purpose.
 
    15  * purpose.
 
    16  *
 
    16  *
 
    17  */
 
    17  */
 
    18 
    18 
    19 #include <nbtab.h>
 
    19 #include <nbtab.h>
 
       
    20 #include <mapstorage.h>
 
    20 #include <eps_win.h>
 
    21 #include <eps_win.h>
 
    21 
    22 #include <map_win.h>
 
    22 NoteBookTab::NoteBookTab():mapwinexists(false), designwinexists(false), mapstorage(*this)
 
    23 #include <design_win.h>
 
    23 {
 
    24 #include <graph_displayer_canvas.h>
 
       
    25 
       
    26 
       
    27 
       
    28 NoteBookTab::NoteBookTab():mapwinexists(false), designwinexists(false)
 
       
    29 {
 
       
    30   mapstorage=new MapStorage(*this);
 
       
    31 
    24   Gtk::ScrolledWindow *pScrolledWindow = manage(new Gtk::ScrolledWindow);
 
    32   Gtk::ScrolledWindow *pScrolledWindow = manage(new Gtk::ScrolledWindow);
 
    25   gd_canvas=new GraphDisplayerCanvas(*this);
 
    33   gd_canvas=new GraphDisplayerCanvas(*this);
 
    26   pScrolledWindow->add(*gd_canvas);
 
    34   pScrolledWindow->add(*gd_canvas);
 
    27   add(*pScrolledWindow);
 
    35   add(*pScrolledWindow);
 
    28 
    36 
    29   //connecting signals - controller character
 
    37   //connecting signals - controller character
 
    30   mapstorage.signal_prop_ch().connect(sigc::mem_fun(*gd_canvas, &GraphDisplayerCanvas::propertyChange));
 
    38   mapstorage->signal_prop_ch().connect(sigc::mem_fun(*gd_canvas, &GraphDisplayerCanvas::propertyChange));
 
    31   mapstorage.signal_node_map_ch().connect(sigc::mem_fun(*this, &NoteBookTab::registerNewNodeMap));
 
    39   mapstorage->signal_node_map_ch().connect(sigc::mem_fun(*this, &NoteBookTab::registerNewNodeMap));
 
    32   mapstorage.signal_edge_map_ch().connect(sigc::mem_fun(*this, &NoteBookTab::registerNewEdgeMap));
 
    40   mapstorage->signal_edge_map_ch().connect(sigc::mem_fun(*this, &NoteBookTab::registerNewEdgeMap));
 
    33   show_all_children();
 
    41   show_all_children();
 
    34   show();
 
    42   show();
 
    35 }
 
    43 }
 
    36 
    44 
    37 void NoteBookTab::readFile(const std::string &file)
 
    45 void NoteBookTab::readFile(const std::string &file)
 
    38 {
 
    46 {
 
    39   mapstorage.readFromFile(file);
 
    47   mapstorage->readFromFile(file);
 
    40   mapstorage.file_name = file;
 
    48   mapstorage->file_name = file;
 
    41   mapstorage.modified = false;
 
    49   mapstorage->modified = false;
 
    42   gd_canvas->drawGraph();
 
    50   gd_canvas->drawGraph();
 
    43   if(mapwinexists)
 
    51   if(mapwinexists)
 
    44     {
 
    52     {
 
    45       mapwin->update(mapstorage.getEdgeMapList(), mapstorage.getNodeMapList());
 
    53       mapwin->update(mapstorage->getEdgeMapList(), mapstorage->getNodeMapList());
 
    46     }
 
    54     }
 
    47   signal_title.emit(Glib::filename_display_basename(file));
 
    55   signal_title.emit(Glib::filename_display_basename(file));
 
    48 }
 
    56 }
 
    49 
    57 
    50 void NoteBookTab::newFile()
 
    58 void NoteBookTab::newFile()
 
    51 {
 
    59 {
 
    52   if (mapstorage.modified)
 
    60   if (mapstorage->modified)
 
    53   {
 
    61   {
 
    54     Gtk::MessageDialog mdialog("<b>Save changes before closing?</b>", true,
 
    62     Gtk::MessageDialog mdialog("<b>Save changes before closing?</b>", true,
 
    55         Gtk::MESSAGE_WARNING, Gtk::BUTTONS_NONE);
 
    63         Gtk::MESSAGE_WARNING, Gtk::BUTTONS_NONE);
 
    56     mdialog.add_button("Close file _without Saving", Gtk::RESPONSE_REJECT);
 
    64     mdialog.add_button("Close file _without Saving", Gtk::RESPONSE_REJECT);
 
    57     mdialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
 
    65     mdialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
 
    66         saveFile();
 
    74         saveFile();
 
    67         break;
 
    75         break;
 
    68     }
 
    76     }
 
    69   }
 
    77   }
 
    70   gd_canvas->clear();
 
    78   gd_canvas->clear();
 
    71   mapstorage.clear();
 
    79   mapstorage->clear();
 
    72   if(mapwinexists)
 
    80   if(mapwinexists)
 
    73     {
 
    81     {
 
    74       mapwin->update(mapstorage.getEdgeMapList(), mapstorage.getNodeMapList());
 
    82       mapwin->update(mapstorage->getEdgeMapList(), mapstorage->getNodeMapList());
 
    75     }
 
    83     }
 
    76   signal_title.emit("unsaved file");
 
    84   signal_title.emit("unsaved file");
 
    77 }
 
    85 }
 
    78 
    86 
    79 void NoteBookTab::openFile()
 
    87 void NoteBookTab::openFile()
 
    80 {
 
    88 {
 
    81   if (mapstorage.modified)
 
    89   if (mapstorage->modified)
 
    82   {
 
    90   {
 
    83     Gtk::MessageDialog mdialog("<b>Save changes before closing?</b>", true, 
    91     Gtk::MessageDialog mdialog("<b>Save changes before closing?</b>", true, 
    84         Gtk::MESSAGE_WARNING, Gtk::BUTTONS_NONE);
 
    92         Gtk::MESSAGE_WARNING, Gtk::BUTTONS_NONE);
 
    85     mdialog.add_button("Close file _without Saving", Gtk::RESPONSE_REJECT);
 
    93     mdialog.add_button("Close file _without Saving", Gtk::RESPONSE_REJECT);
 
    86     mdialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
 
    94     mdialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
 
   100   fcdialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
 
   108   fcdialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
 
   101   fcdialog.add_button(Gtk::Stock::OPEN, Gtk::RESPONSE_ACCEPT);
 
   109   fcdialog.add_button(Gtk::Stock::OPEN, Gtk::RESPONSE_ACCEPT);
 
   102   if (fcdialog.run() == Gtk::RESPONSE_ACCEPT)
 
   110   if (fcdialog.run() == Gtk::RESPONSE_ACCEPT)
 
   103   {
 
   111   {
 
   104     gd_canvas->clear();
 
   112     gd_canvas->clear();
 
   105     mapstorage.clear();
 
   113     mapstorage->clear();
 
   106     Glib::ustring filename = fcdialog.get_filename();
 
   114     Glib::ustring filename = fcdialog.get_filename();
 
   107     if (!mapstorage.readFromFile(filename))
 
   115     if (!mapstorage->readFromFile(filename))
 
   108     {
 
   116     {
 
   109       mapstorage.file_name = filename;
 
   117       mapstorage->file_name = filename;
 
   110       mapstorage.modified = false;
 
   118       mapstorage->modified = false;
 
   111       gd_canvas->drawGraph();
 
   119       gd_canvas->drawGraph();
 
   112       if(mapwinexists)
 
   120       if(mapwinexists)
 
   113 	{
 
   121 	{
 
   114 	  mapwin->update(mapstorage.getEdgeMapList(), mapstorage.getNodeMapList());
 
   122 	  mapwin->update(mapstorage->getEdgeMapList(), mapstorage->getNodeMapList());
 
   115 	}
 
   123 	}
 
   116       signal_title.emit(Glib::filename_display_basename(filename));
 
   124       signal_title.emit(Glib::filename_display_basename(filename));
 
   117     }
 
   125     }
 
   118   }
 
   126   }
 
   119 }
 
   127 }
 
   120 
   128 
   121 void NoteBookTab::saveFile()
 
   129 void NoteBookTab::saveFile()
 
   122 {
 
   130 {
 
   123   if (mapstorage.file_name == "") {
 
   131   if (mapstorage->file_name == "") {
 
   124     saveFileAs();
 
   132     saveFileAs();
 
   125   }
 
   133   }
 
   126   else
 
   134   else
 
   127   {
 
   135   {
 
   128     mapstorage.writeToFile(mapstorage.file_name);
 
   136     mapstorage->writeToFile(mapstorage->file_name);
 
   129     mapstorage.modified = false;
 
   137     mapstorage->modified = false;
 
   130     signal_title.emit(Glib::filename_display_basename(mapstorage.file_name));
 
   138     signal_title.emit(Glib::filename_display_basename(mapstorage->file_name));
 
   131   }
 
   139   }
 
   132 }
 
   140 }
 
   133 
   141 
   134 void NoteBookTab::saveFileAs()
 
   142 void NoteBookTab::saveFileAs()
 
   135 {
 
   143 {
 
   137   fcdialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
 
   145   fcdialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
 
   138   fcdialog.add_button(Gtk::Stock::SAVE, Gtk::RESPONSE_ACCEPT);
 
   146   fcdialog.add_button(Gtk::Stock::SAVE, Gtk::RESPONSE_ACCEPT);
 
   139   if (fcdialog.run() == Gtk::RESPONSE_ACCEPT)
 
   147   if (fcdialog.run() == Gtk::RESPONSE_ACCEPT)
 
   140   {
 
   148   {
 
   141     Glib::ustring filename = fcdialog.get_filename();
 
   149     Glib::ustring filename = fcdialog.get_filename();
 
   142     mapstorage.file_name = filename;
 
   150     mapstorage->file_name = filename;
 
   143     mapstorage.writeToFile(filename);
 
   151     mapstorage->writeToFile(filename);
 
   144     mapstorage.modified = false;
 
   152     mapstorage->modified = false;
 
   145     signal_title.emit(Glib::filename_display_basename(filename));
 
   153     signal_title.emit(Glib::filename_display_basename(filename));
 
   146   }
 
   154   }
 
   147 }
 
   155 }
 
   148 
   156 
   149 void NoteBookTab::close()
 
   157 void NoteBookTab::close()
 
   150 {
 
   158 {
 
   151   if (mapstorage.modified)
 
   159   if (mapstorage->modified)
 
   152   {
 
   160   {
 
   153     Gtk::MessageDialog mdialog("<b>Save changes before closing?</b>", true,
 
   161     Gtk::MessageDialog mdialog("<b>Save changes before closing?</b>", true,
 
   154         Gtk::MESSAGE_WARNING, Gtk::BUTTONS_NONE);
 
   162         Gtk::MESSAGE_WARNING, Gtk::BUTTONS_NONE);
 
   155     mdialog.add_button("Close _without Saving", Gtk::RESPONSE_REJECT);
 
   163     mdialog.add_button("Close _without Saving", Gtk::RESPONSE_REJECT);
 
   156     mdialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
 
   164     mdialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
 
   165         saveFile();
 
   173         saveFile();
 
   166         break;
 
   174         break;
 
   167     }
 
   175     }
 
   168   }
 
   176   }
 
   169   gd_canvas->clear();
 
   177   gd_canvas->clear();
 
   170   mapstorage.clear();
 
   178   mapstorage->clear();
 
   171   if(mapwinexists)
 
   179   if(mapwinexists)
 
   172     {
 
   180     {
 
   173       mapwin->update(mapstorage.getEdgeMapList(), mapstorage.getNodeMapList());
 
   181       mapwin->update(mapstorage->getEdgeMapList(), mapstorage->getNodeMapList());
 
   174     }
 
   182     }
 
   175   signal_title.emit("unsaved file");
 
   183   signal_title.emit("unsaved file");
 
   176 }
 
   184 }
 
   177 
   185 
   178 void NoteBookTab::propertyChange(bool itisedge, int prop, std::string mapname)
 
   186 void NoteBookTab::propertyChange(bool itisedge, int prop, std::string mapname)
 
   179 {
 
   187 {
 
   180   mapstorage.changeActiveMap(itisedge, prop, mapname);
 
   188   mapstorage->changeActiveMap(itisedge, prop, mapname);
 
   181 }
 
   189 }
 
   182 
   190 
   183 sigc::signal<void, NoteBookTab *, bool> NoteBookTab::signal_newmap_needed()
 
   191 sigc::signal<void, NoteBookTab *, bool> NoteBookTab::signal_newmap_needed()
 
   184 {
 
   192 {
 
   185   return signal_newmap;
 
   193   return signal_newmap;
 
   190   signal_newmap.emit(this, itisedge);
 
   198   signal_newmap.emit(this, itisedge);
 
   191 }
 
   199 }
 
   192 
   200 
   193 std::string NoteBookTab::getActiveEdgeMap(int prop)
 
   201 std::string NoteBookTab::getActiveEdgeMap(int prop)
 
   194 {
 
   202 {
 
   195   return mapstorage.getActiveEdgeMap(prop);
 
   203   return mapstorage->getActiveEdgeMap(prop);
 
   196 }
 
   204 }
 
   197 
   205 
   198 std::string NoteBookTab::getActiveNodeMap(int prop)
 
   206 std::string NoteBookTab::getActiveNodeMap(int prop)
 
   199 {
 
   207 {
 
   200   return mapstorage.getActiveNodeMap(prop);
 
   208   return mapstorage->getActiveNodeMap(prop);
 
   201 }
 
   209 }
 
   202 
   210 
   203 void NoteBookTab::registerNewEdgeMap(std::string mapname)
 
   211 void NoteBookTab::registerNewEdgeMap(std::string mapname)
 
   204 {
 
   212 {
 
   205   if(mapwinexists)
 
   213   if(mapwinexists)
 
   218 
   226 
   219 void NoteBookTab::createMapWin(std::string name)
 
   227 void NoteBookTab::createMapWin(std::string name)
 
   220 {
 
   228 {
 
   221   if(!mapwinexists)
 
   229   if(!mapwinexists)
 
   222     {
 
   230     {
 
   223       mapwin=new MapWin("Map Setup - "+name, mapstorage.getEdgeMapList(), mapstorage.getNodeMapList(), *this);
 
   231       mapwin=new MapWin("Map Setup - "+name, mapstorage->getEdgeMapList(), mapstorage->getNodeMapList(), *this);
 
   224       mapst2mapwin=mapstorage.signal_map_win_ch().connect(sigc::mem_fun(*mapwin, &MapWin::changeEntry));
 
   232       mapst2mapwin=mapstorage->signal_map_win_ch().connect(sigc::mem_fun(*mapwin, &MapWin::changeEntry));
 
   225       mapwin->show();
 
   233       mapwin->show();
 
   226       mapwinexists=true;
 
   234       mapwinexists=true;
 
   227     }
 
   235     }
 
   228 }
 
   236 }
 
   229 
   237 
   242 {
 
   250 {
 
   243   if(!designwinexists)
 
   251   if(!designwinexists)
 
   244     {
 
   252     {
 
   245       double attraction, propulsation;
 
   253       double attraction, propulsation;
 
   246       int iterations;
 
   254       int iterations;
 
   247       mapstorage.get_design_data(attraction, propulsation, iterations);
 
   255       mapstorage->get_design_data(attraction, propulsation, iterations);
 
   248       designwin=new DesignWin("Design Setup - "+name, attraction, propulsation, iterations, *this);
 
   256       designwin=new DesignWin("Design Setup - "+name, attraction, propulsation, iterations, *this);
 
   249 
   257 
   250       designwin->signal_attraction().connect(sigc::mem_fun(mapstorage, &MapStorage::set_attraction));
 
   258       designwin->signal_attraction().connect(sigc::mem_fun(mapstorage, &MapStorage::set_attraction));
 
   251       designwin->signal_propulsation().connect(sigc::mem_fun(mapstorage, &MapStorage::set_propulsation));
 
   259       designwin->signal_propulsation().connect(sigc::mem_fun(mapstorage, &MapStorage::set_propulsation));
 
   252       designwin->signal_iteration().connect(sigc::mem_fun(mapstorage, &MapStorage::set_iteration));
 
   260       designwin->signal_iteration().connect(sigc::mem_fun(mapstorage, &MapStorage::set_iteration));
 
   253       designwin->close_run().connect(sigc::mem_fun(*gd_canvas, &GraphDisplayerCanvas::reDesignGraph));
 
   261       designwin->close_run().connect(sigc::mem_fun(*gd_canvas, &GraphDisplayerCanvas::reDesignGraph));
 
   254 
   262 
   255       designwin->signal_delete_event().connect(sigc::mem_fun(*this, &NoteBookTab::closeDesignWin));
 
   263       designwin->signal_delete_event().connect(sigc::mem_fun(*this, &NoteBookTab::closeDesignWin));
 
   256 
   264 
   257       mapst2designwin=mapstorage.signal_design_win_ch().connect(sigc::mem_fun(*designwin, &DesignWin::set_data));
 
   265       mapst2designwin=mapstorage->signal_design_win_ch().connect(sigc::mem_fun(*designwin, &DesignWin::set_data));
 
   258 
   266 
   259       designwin->show();
 
   267       designwin->show();
 
   260       designwinexists=true;
 
   268       designwinexists=true;
 
   261     }
 
   269     }
 
   262 }
 
   270 }
 
   304   gd_canvas->reDesignGraph();
 
   312   gd_canvas->reDesignGraph();
 
   305 }
 
   313 }
 
   306 
   314 
   307 void NoteBookTab::active_maps_needed()
 
   315 void NoteBookTab::active_maps_needed()
 
   308 {
 
   316 {
 
   309   mapstorage.broadcastActiveMaps();
 
   317   mapstorage->broadcastActiveMaps();
 
   310 }
 
   318 }
 
   311 
   319 
   312 void NoteBookTab::exportGraphToEPS(std::vector<bool> options, std::string filename)
 
   320 void NoteBookTab::exportGraphToEPS(std::vector<bool> options, std::string filename)
 
   313 {
 
   321 {
 
   314   mapstorage.exportGraphToEPS(options, filename);
 
   322   mapstorage->exportGraphToEPS(options, filename);
 
   315 }
 
   323 }
glemon-0.x