9 #include "map_win.h" |
9 #include "map_win.h" |
10 #include "graph_displayer_canvas.h" |
10 #include "graph_displayer_canvas.h" |
11 #include <libgnomecanvasmm.h> |
11 #include <libgnomecanvasmm.h> |
12 #include <libgnomecanvasmm/polygon.h> |
12 #include <libgnomecanvasmm/polygon.h> |
13 |
13 |
|
14 ///One tab in the Notebook that is placed in the main window (\ref MainWin). |
|
15 |
|
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. |
|
20 /// |
|
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. |
|
25 /// |
|
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. |
|
28 /// |
|
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. |
14 class NoteBookTab : public Gtk::VBox |
32 class NoteBookTab : public Gtk::VBox |
15 { |
33 { |
16 public: |
34 public: |
|
35 |
|
36 ///Constructor of \ref NoteBookTab |
|
37 |
|
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. |
17 NoteBookTab(); |
40 NoteBookTab(); |
18 |
41 |
|
42 ///Maps assigned to the graph displayed in this \ref NoteBookTab of notebook. |
19 MapStorage mapstorage; |
43 MapStorage mapstorage; |
20 |
44 |
|
45 ///Title changement indicator. |
|
46 |
|
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. |
21 sigc::signal<void, std::string> signal_title; |
51 sigc::signal<void, std::string> signal_title; |
22 |
52 |
|
53 ///Returns \ref signal_title to be the caller able to connect it to a callback function. |
23 sigc::signal<void, std::string> signal_title_ch(); |
54 sigc::signal<void, std::string> signal_title_ch(); |
24 |
55 |
|
56 ///Indicates that new map window should be popped up. |
|
57 |
|
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. |
25 sigc::signal<void, NoteBookTab *, bool> signal_newmap; |
62 sigc::signal<void, NoteBookTab *, bool> signal_newmap; |
26 |
63 |
|
64 ///Returns \ref signal_newmap to be the caller able to connect it to a callback function. |
27 sigc::signal<void, NoteBookTab *, bool> signal_newmap_needed(); |
65 sigc::signal<void, NoteBookTab *, bool> signal_newmap_needed(); |
28 |
66 |
|
67 ///Loads the given file. |
|
68 |
|
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. |
29 void readFile(const std::string &); |
72 void readFile(const std::string &); |
30 |
73 |
31 ///The graph will be drawn on this \ref GraphDisplayerCanvas |
74 ///The graph will be drawn on this \ref GraphDisplayerCanvas |
32 GraphDisplayerCanvas * gd_canvas; |
75 GraphDisplayerCanvas * gd_canvas; |
33 |
76 |
|
77 ///Indicates whether the \ref MapWin is opened or not. See \ref mapwin. |
34 bool mapwinexists; |
78 bool mapwinexists; |
35 |
79 |
|
80 ///Address of the only \ref MapWin that the \ref NoteBookTab can open. |
|
81 |
|
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. |
36 MapWin * mapwin; |
86 MapWin * mapwin; |
37 |
87 |
38 public: |
88 public: |
39 ///Callback for 'FileNew' action. |
89 ///Callback for 'FileNew' action. |
40 virtual void newFile(); |
90 virtual void newFile(); |
45 ///Callback for 'FileSaveAs' action. |
95 ///Callback for 'FileSaveAs' action. |
46 virtual void saveFileAs(); |
96 virtual void saveFileAs(); |
47 ///Callback for 'Close' action. |
97 ///Callback for 'Close' action. |
48 virtual void close(); |
98 virtual void close(); |
49 |
99 |
50 void propertyChange(bool, int, std::string); |
100 ///Handles changement of view of graph. |
51 void popupNewMapWin(bool, int); |
|
52 |
101 |
53 std::string getActiveEdgeMap(int); |
102 ///If the user changes the map to show by a property to a nother in \ref MapWin, |
54 std::string getActiveNodeMap(int); |
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); |
55 |
111 |
56 void registerNewEdgeMap(std::string); |
112 ///Emits a signal that request \ref MainWin to pop up \ref NewMapWin |
57 void registerNewNodeMap(std::string); |
|
58 |
113 |
|
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); |
|
117 |
|
118 ///Returns the actually selected edgemap to visualize by the given property. |
|
119 |
|
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); |
|
123 |
|
124 ///Returns the actually selected nodemap to visualize by the given property. |
|
125 |
|
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); |
|
129 |
|
130 ///Registers recently created edgemap in \ref MapWin. |
|
131 |
|
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); |
|
138 |
|
139 ///Registers recently created nodemap in \ref MapWin. |
|
140 |
|
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); |
|
147 |
|
148 ///Pops up and registrates the \ref MapWin of \ref NoteBookTab. |
|
149 |
|
150 ///See also |
|
151 ///\ref mapwin. |
59 void createMapWin(std::string); |
152 void createMapWin(std::string); |
|
153 |
|
154 ///Closes and deregistrates the \ref MapWin of \ref NoteBookTab. |
|
155 |
|
156 ///See also |
|
157 ///\ref mapwin. |
60 void closeMapWin(); |
158 void closeMapWin(); |
61 }; |
159 }; |
62 |
160 |
63 #endif //NBTAB_H |
161 #endif //NBTAB_H |