Mercurialglemon-0.x / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
nbtab.cc
author hegyi
Wed, 25 Oct 2006 13:21:24 +0000
changeset 172 fc1e478697d3
parent 160 14a76109b561
child 173 8339178ae43d
permissions -rw-r--r--
Currently visualized map can be saved and loaded from file. 
     1 #include <nbtab.h>

     2 

     3 NoteBookTab::NoteBookTab():mapwinexists(false), designwinexists(false)

     4 {

     5   Gtk::ScrolledWindow *pScrolledWindow = manage(new Gtk::ScrolledWindow);

     6   gd_canvas=new GraphDisplayerCanvas(*this);

     7   pScrolledWindow->add(*gd_canvas);

     8   add(*pScrolledWindow);

     9 

    10   //connecting signals - controller character

    11   mapstorage.signal_prop_ch().connect(sigc::mem_fun(*gd_canvas, &GraphDisplayerCanvas::propertyChange));

    12   mapstorage.signal_node_map_ch().connect(sigc::mem_fun(*this, &NoteBookTab::registerNewNodeMap));

    13   mapstorage.signal_edge_map_ch().connect(sigc::mem_fun(*this, &NoteBookTab::registerNewEdgeMap));

    14   show_all_children();

    15   show();

    16 }

    17 

    18 void NoteBookTab::readFile(const std::string &file)

    19 {

    20   mapstorage.readFromFile(file);

    21   mapstorage.file_name = file;

    22   mapstorage.modified = false;

    23   gd_canvas->drawGraph();

    24   if(mapwinexists)

    25     {

    26       mapwin->update(mapstorage.getEdgeMapList(), mapstorage.getNodeMapList());

    27     }

    28   signal_title.emit(Glib::filename_display_basename(file));

    29 }

    30 

    31 void NoteBookTab::newFile()

    32 {

    33   if (mapstorage.modified)

    34   {

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

    36         Gtk::MESSAGE_WARNING, Gtk::BUTTONS_NONE);

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

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

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

    40     switch (mdialog.run())

    41     {

    42       case Gtk::RESPONSE_CANCEL:

    43         return;

    44       case Gtk::RESPONSE_REJECT:

    45         break;

    46       case Gtk::RESPONSE_ACCEPT:

    47         saveFile();

    48         break;

    49     }

    50   }

    51   gd_canvas->clear();

    52   mapstorage.clear();

    53   if(mapwinexists)

    54     {

    55       mapwin->update(mapstorage.getEdgeMapList(), mapstorage.getNodeMapList());

    56     }

    57   signal_title.emit("unsaved file");

    58 }

    59 

    60 void NoteBookTab::openFile()

    61 {

    62   if (mapstorage.modified)

    63   {

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

    65         Gtk::MESSAGE_WARNING, Gtk::BUTTONS_NONE);

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

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

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

    69     switch (mdialog.run())

    70     {

    71       case Gtk::RESPONSE_CANCEL:

    72         return;

    73       case Gtk::RESPONSE_REJECT:

    74         break;

    75       case Gtk::RESPONSE_ACCEPT:

    76         saveFile();

    77         break;

    78     }

    79   }

    80   Gtk::FileChooserDialog fcdialog("Open File");

    81   fcdialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);

    82   fcdialog.add_button(Gtk::Stock::OPEN, Gtk::RESPONSE_ACCEPT);

    83   if (fcdialog.run() == Gtk::RESPONSE_ACCEPT)

    84   {

    85     gd_canvas->clear();

    86     mapstorage.clear();

    87     Glib::ustring filename = fcdialog.get_filename();

    88     if (!mapstorage.readFromFile(filename))

    89     {

    90       mapstorage.file_name = filename;

    91       mapstorage.modified = false;

    92       gd_canvas->drawGraph();

    93       if(mapwinexists)

    94 	{

    95 	  mapwin->update(mapstorage.getEdgeMapList(), mapstorage.getNodeMapList());

    96 	}

    97       signal_title.emit(Glib::filename_display_basename(filename));

    98     }

    99   }

   100 }

   101 

   102 void NoteBookTab::saveFile()

   103 {

   104   if (mapstorage.file_name == "") {

   105     saveFileAs();

   106   }

   107   else

   108   {

   109     mapstorage.writeToFile(mapstorage.file_name);

   110     mapstorage.modified = false;

   111     signal_title.emit(Glib::filename_display_basename(mapstorage.file_name));

   112   }

   113 }

   114 

   115 void NoteBookTab::saveFileAs()

   116 {

   117   Gtk::FileChooserDialog fcdialog("Save File", Gtk::FILE_CHOOSER_ACTION_SAVE);

   118   fcdialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);

   119   fcdialog.add_button(Gtk::Stock::SAVE, Gtk::RESPONSE_ACCEPT);

   120   if (fcdialog.run() == Gtk::RESPONSE_ACCEPT)

   121   {

   122     Glib::ustring filename = fcdialog.get_filename();

   123     mapstorage.file_name = filename;

   124     mapstorage.writeToFile(filename);

   125     mapstorage.modified = false;

   126     signal_title.emit(Glib::filename_display_basename(filename));

   127   }

   128 }

   129 

   130 void NoteBookTab::close()

   131 {

   132   if (mapstorage.modified)

   133   {

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

   135         Gtk::MESSAGE_WARNING, Gtk::BUTTONS_NONE);

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

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

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

   139     switch (mdialog.run())

   140     {

   141       case Gtk::RESPONSE_CANCEL:

   142         return;

   143       case Gtk::RESPONSE_REJECT:

   144         break;

   145       case Gtk::RESPONSE_ACCEPT:

   146         saveFile();

   147         break;

   148     }

   149   }

   150   gd_canvas->clear();

   151   mapstorage.clear();

   152   if(mapwinexists)

   153     {

   154       mapwin->update(mapstorage.getEdgeMapList(), mapstorage.getNodeMapList());

   155     }

   156   signal_title.emit("unsaved file");

   157 }

   158 

   159 void NoteBookTab::propertyChange(bool itisedge, int prop, std::string mapname)

   160 {

   161   mapstorage.changeActiveMap(itisedge, prop, mapname);

   162 }

   163 

   164 sigc::signal<void, NoteBookTab *, bool> NoteBookTab::signal_newmap_needed()

   165 {

   166   return signal_newmap;

   167 }

   168 

   169 void NoteBookTab::popupNewMapWin(bool itisedge)

   170 {

   171   signal_newmap.emit(this, itisedge);

   172 }

   173 

   174 std::string NoteBookTab::getActiveEdgeMap(int prop)

   175 {

   176   return mapstorage.getActiveEdgeMap(prop);

   177 }

   178 

   179 std::string NoteBookTab::getActiveNodeMap(int prop)

   180 {

   181   return mapstorage.getActiveNodeMap(prop);

   182 }

   183 

   184 void NoteBookTab::registerNewEdgeMap(std::string mapname)

   185 {

   186   if(mapwinexists)

   187     {

   188       mapwin->registerNewEdgeMap(mapname);

   189     }

   190 }

   191 

   192 void NoteBookTab::registerNewNodeMap(std::string mapname)

   193 {

   194   if(mapwinexists)

   195     {

   196       mapwin->registerNewNodeMap(mapname);

   197     }

   198 }

   199 

   200 void NoteBookTab::createMapWin(std::string name)

   201 {

   202   if(!mapwinexists)

   203     {

   204       mapwin=new MapWin("Map Setup - "+name, mapstorage.getEdgeMapList(), mapstorage.getNodeMapList(), *this);

   205       mapst2mapwin=mapstorage.signal_map_win_ch().connect(sigc::mem_fun(*mapwin, &MapWin::changeEntry));

   206       mapwin->show();

   207       mapwinexists=true;

   208     }

   209 }

   210 

   211 void NoteBookTab::createDesignWin(std::string name)

   212 {

   213   if(!designwinexists)

   214     {

   215       double attraction, propulsation;

   216       int iterations;

   217       gd_canvas->get_design_data(attraction, propulsation, iterations);

   218       designwin=new DesignWin("Design Setup - "+name, attraction, propulsation, iterations, *this);

   219 

   220       designwin->signal_attraction().connect(sigc::mem_fun(*this, &NoteBookTab::attraction_ch));

   221       designwin->signal_propulsation().connect(sigc::mem_fun(*this, &NoteBookTab::propulsation_ch));

   222       designwin->signal_iteration().connect(sigc::mem_fun(*gd_canvas, &GraphDisplayerCanvas::set_iteration));

   223       designwin->close_run().connect(sigc::mem_fun(*gd_canvas, &GraphDisplayerCanvas::reDesignGraph));

   224 

   225       designwin->signal_delete_event().connect(sigc::mem_fun(*this, &NoteBookTab::closeDesignWin));

   226 

   227       designwin->show();

   228       designwinexists=true;

   229     }

   230 }

   231 

   232 void NoteBookTab::closeMapWin()

   233 {

   234   mapst2mapwin.disconnect();

   235   mapwinexists=false;

   236   delete mapwin;

   237 }

   238 

   239 bool NoteBookTab::closeDesignWin(GdkEventAny * e)

   240 {

   241   if(e->type==GDK_DELETE)

   242     {

   243       designwinexists=false;

   244       delete designwin;

   245     }

   246 }

   247 

   248 sigc::signal<void, std::string> NoteBookTab::signal_title_ch()

   249 {

   250   return signal_title;

   251 }

   252 

   253 void NoteBookTab::setView(bool autoscale, bool zoomtrack, double width, double radius)

   254 {

   255   gd_canvas->setView(autoscale, zoomtrack, width, radius);

   256 }

   257 

   258 void NoteBookTab::getView(bool & autoscale, bool & zoomtrack, double& width, double& radius)

   259 {

   260   gd_canvas->getView(autoscale, zoomtrack, width, radius);

   261 }

   262 

   263 void NoteBookTab::reDesignGraph()

   264 {

   265   gd_canvas->reDesignGraph();

   266 }

   267 

   268 void NoteBookTab::attraction_ch(double v)

   269 {

   270   gd_canvas->set_attraction(v);

   271 }

   272 

   273 void NoteBookTab::propulsation_ch(double v)

   274 {

   275   gd_canvas->set_propulsation(v);

   276 }

   277 

   278 void NoteBookTab::iteration_ch(int v)

   279 {

   280   gd_canvas->set_iteration(v);

   281 }

   282 

   283 void NoteBookTab::active_maps_needed()

   284 {

   285   mapstorage.broadcastActiveMaps();

   286 }
glemon-0.x