The graph adadptors can be alteration observed.
In most cases it uses the adapted graph alteration notifiers.
Only special case is now the UndirGraphAdaptor, where
we have to proxy the signals from the graph.
The SubBidirGraphAdaptor is removed, because it doest not
gives more feature than the EdgeSubGraphAdaptor<UndirGraphAdaptor<Graph>>.
The ResGraphAdaptor is based on this composition.
8 #include "mapstorage.h"
10 #include "graph_displayer_canvas.h"
11 #include <libgnomecanvasmm.h>
12 #include <libgnomecanvasmm/polygon.h>
14 ///One tab in the Notebook that is placed in the main window (\ref MainWin).
16 ///One graph and all of its accessories like maps are assigned to one tab in the notebook.
17 ///\ref NoteBookTab is responsible for the user defined display of the graph: view can be
18 ///set by visualized maps, therefore \ref NoteBookTab must provide an interface to set the
19 ///view of graph. This is \ref Mapwin window.
21 ///\ref NoteBookTab is also
22 ///responsible for modify the graph if it is
23 ///requested. Therefore it is responsible for translating user events to modifications to
24 ///do on graph, like node/edge addition/deletion, map modification, addition and so on.
26 ///To be able to solve these tasks the help of \ref MainWin is also needed, for example to
27 ///know which editor-tool is active at the moment. Therefore \ref MainWin knows \ref NoteBookTab.
29 ///Some information in the other direction is needed as well: for example when new map creation is requested for this tab
30 ///\ref NoteBookTab must ask \ref MainWin to pop-up a \ref NewMapWin. Communication in this direction is realized by signals
31 ///therefore \ref NoteBookTab does not know \ref MainWin at all, but in this way it is not necessary.
32 class NoteBookTab : public Gtk::VBox
36 ///Constructor of \ref NoteBookTab
38 ///It initiates the \re GraphDisplayerCanvas, on which the graph will be drawn
39 ///Signals of \ref MapStorage will be bound to the appropriate callback functions here.
42 ///Maps assigned to the graph displayed in this \ref NoteBookTab of notebook.
43 MapStorage mapstorage;
45 ///Title changement indicator.
47 ///If graph is loaded from disk or saved to disk or changed its name somehow
48 ///this signal will be emit to let
49 ///\ref MainWin know that it has to modify the title of the main window.
50 ///It contains the new title.
51 sigc::signal<void, std::string> signal_title;
53 ///Returns \ref signal_title to be the caller able to connect it to a callback function.
54 sigc::signal<void, std::string> signal_title_ch();
56 ///Indicates that new map window should be popped up.
58 ///\ref NoteBookTab can ask \ref MainWin to pop up a \ref NweMapWin ny emitting this signal.
59 ///The signal contains whether an edgemap or a nodemap should be popped up. \ref NewMapWin
60 ///is not popped up by \ref NoteBookTab, because not only \ref NoteBookTab needs \ref NewMapWin,
61 ///but for example \ref MainWin and \ref AlgoWin s as well.
62 sigc::signal<void, NoteBookTab *, bool> signal_newmap;
64 ///Returns \ref signal_newmap to be the caller able to connect it to a callback function.
65 sigc::signal<void, NoteBookTab *, bool> signal_newmap_needed();
67 ///Loads the given file.
69 ///The given file will be load in the \ref MapStorage and afeter that
70 ///\ref GraphDisplayerCanvas will be requested to display the graph.
71 ///\ref GraphDisplayer will get datas from the recently set \ref MapStorage.
72 void readFile(const std::string &);
74 ///The graph will be drawn on this \ref GraphDisplayerCanvas
75 GraphDisplayerCanvas * gd_canvas;
77 ///Indicates whether the \ref MapWin is opened or not. See \ref mapwin.
80 ///Address of the only \ref MapWin that the \ref NoteBookTab can open.
82 ///Only one of this window can be opened at the same time (\ref mapwinexists),
83 ///because there is no need for more, one per tab is enough.
84 ///There won1t be benefit of more than one, but it would be
85 ///more complicated to synchronize them.
89 ///Callback for 'FileNew' action.
90 virtual void newFile();
91 ///Callback for 'FileOpen' action.
92 virtual void openFile();
93 ///Callback for 'FileSave' action.
94 virtual void saveFile();
95 ///Callback for 'FileSaveAs' action.
96 virtual void saveFileAs();
97 ///Callback for 'Close' action.
100 ///Handles changement of view of graph.
102 ///If the user changes the map to show by a property to a nother in \ref MapWin,
103 ///\ref MapWin will call this function. This function will registrate in \ref MapStorage
104 ///the new map to display by the changed property. After that \ref MapStorage will
105 ///emits a signal that will be forwarded to \ref GraphDisplayerCanvas to update the
106 ///appropriate parts of graph.
107 ///\param itiesedge whether the changed property is edge property or node property
108 ///\param prop id of property, see all_include.h
109 ///\param mapname name of the recently selected map
110 void propertyChange(bool itisedge, int prop, std::string mapname);
112 ///Emits a signal that request \ref MainWin to pop up \ref NewMapWin
114 ///This function is called by \ref MapWin.
115 ///\param itisedge whether the new map should be an edgemap or a nodemap.
116 void popupNewMapWin(bool itisedge);
118 ///Returns the actually selected edgemap to visualize by the given property.
120 ///\ref MapWin calls this function, beacuse it does not know \ref MapStorage.
121 ///\param prop property to inquire.
122 std::string getActiveEdgeMap(int prop);
124 ///Returns the actually selected nodemap to visualize by the given property.
126 ///\ref MapWin calls this function, beacuse it does not know \ref MapStorage.
127 ///\param prop property to inquire.
128 std::string getActiveNodeMap(int prop);
130 ///Registers recently created edgemap in \ref MapWin.
132 ///After creation of new map \ref MapStorage emits a signal.
133 ///This signal is bound to this callback function, that will call
134 ///a function with the same name and same parameterin \ref MapWin.
135 ///This call-forwarder function is needed, because \ref Mapstorage does not know \ref MapWin
136 ///\param mapname name of new map
137 void registerNewEdgeMap(std::string mapname);
139 ///Registers recently created nodemap in \ref MapWin.
141 ///After creation of new map \ref MapStorage emits a signal.
142 ///This signal is bound to this callback function, that will call
143 ///a function with the same name and same parameter in \ref MapWin.
144 ///This call-forwarder function is needed, because \ref Mapstorage does not know \ref MapWin
145 ///\param mapname name of new map
146 void registerNewNodeMap(std::string mapname);
148 ///Pops up and registrates the \ref MapWin of \ref NoteBookTab.
152 void createMapWin(std::string);
154 ///Closes and deregistrates the \ref MapWin of \ref NoteBookTab.