9 #include <mapstorage.h> |
9 #include <mapstorage.h> |
10 #include <mapselector.h> |
10 #include <mapselector.h> |
11 #include <libgnomecanvasmm.h> |
11 #include <libgnomecanvasmm.h> |
12 #include <libgnomecanvasmm/polygon.h> |
12 #include <libgnomecanvasmm/polygon.h> |
13 |
13 |
|
14 ///Ancestor class of algorithm graphical interface classes. |
|
15 |
|
16 ///It also demonstrates, how should an algorithm graphical interface |
|
17 ///work. Children of this class have the same functions and attributes, |
|
18 ///therefore with all of them can the holder \ref AlgoWin communicate |
|
19 ///in the same way. |
|
20 /// |
|
21 ///IMPORTANT! In a child class only the following tasks are to do: |
|
22 /// |
|
23 ///-call \ref init function with correct parameters from correctly parametrized constructor |
|
24 /// |
|
25 ///-implement \ref build_box function |
|
26 /// |
|
27 ///-implement \ref run function |
|
28 /// |
|
29 ///because all other thing is automatically done in \ref init function! |
|
30 |
14 class AlgoBox : public Gtk::VBox |
31 class AlgoBox : public Gtk::VBox |
15 { |
32 { |
16 sigc::signal<void, std::string> signal_maplist_need; |
33 ///Signal emitted in case of need for list of maps. |
17 sigc::signal<void, std::string, bool> signal_newmapwin_need; |
34 |
|
35 ///If the user has selected different tab to work on |
|
36 ///new maps are selected as well. These new maps should be |
|
37 ///provided for \ref AlgoBox. To get these maps, \ref AlgoBox |
|
38 ///emits this signal. |
|
39 sigc::signal<void, std::string> signal_maplist_need; |
|
40 |
|
41 ///Signal emitted in case of need for \ref NewMapWin. |
|
42 |
|
43 ///If user wants to create a new for an input, or output |
|
44 ///it can let \ref NewMapWin popped up from here as well. |
|
45 ///In that case will be this signal emitted. |
|
46 sigc::signal<void, std::string, bool> signal_newmapwin_need; |
18 |
47 |
19 protected: |
48 protected: |
|
49 ///Holder of tabnames. |
20 Gtk::ComboBoxText tabcbt; |
50 Gtk::ComboBoxText tabcbt; |
|
51 |
|
52 ///Holder of widgets, in which nodemaps can be selected to work on. |
21 std::vector<MapSelector *> nodemapcbts; |
53 std::vector<MapSelector *> nodemapcbts; |
|
54 |
|
55 ///Holder of widgets, in which edgemaps can be selected to work on. |
22 std::vector<MapSelector *> edgemapcbts; |
56 std::vector<MapSelector *> edgemapcbts; |
23 |
57 |
|
58 ///Maps of selected tabs. |
24 MapStorage * mapstorage; |
59 MapStorage * mapstorage; |
25 |
60 |
26 public: |
61 public: |
|
62 ///Empty constructor called by children. |
27 AlgoBox(){}; |
63 AlgoBox(){}; |
28 AlgoBox(std::vector<std::string>); |
|
29 |
64 |
|
65 ///Constructor |
|
66 |
|
67 ///Calls \ref init function |
|
68 ///with the provided parameters. \ref init function |
|
69 ///is needed, because it is virtual, therefore the |
|
70 ///functions of the proper class will be called when |
|
71 ///running. |
|
72 ///\param tablist list of tabs in \ref MainWin |
|
73 AlgoBox(std::vector<std::string> tablist); |
|
74 |
|
75 ///Initiates \ref AlgoBox. |
|
76 |
|
77 ///Creates the graphical interface for the realized algorithm, initiates variables, connects signals. |
|
78 /// |
|
79 ///List of tabs in \ref MainWin is required, but no one |
|
80 ///will be selected automatically. Every other |
|
81 ///entry field remains empty (unselected), until a \ref NoteBookTab |
|
82 ///is selected. |
|
83 /// |
|
84 ///It also have to bind all the signals to the correct place. |
|
85 ///This function is virtual, in all type of children of |
|
86 ///\ref AlgoBox the correct function willbe called. |
|
87 /// |
|
88 ///Therefore it is IMPORTANT that only \ref run and \ref build_box |
|
89 ///has to be implemented in children of \ref AlgoBox, every other |
|
90 ///thing will automatically work properly by the help of this |
|
91 ///function that must be called in constructor of child!!! |
30 virtual void init(std::vector<std::string>); |
92 virtual void init(std::vector<std::string>); |
31 |
93 |
32 sigc::signal<void, std::string> signal_maplist_needed(); |
94 ///Signal emitted, when selected tab changes, and new list of maps required. |
33 sigc::signal<void, std::string, bool> signal_newmapwin_needed(){return signal_newmapwin_need;}; |
95 sigc::signal<void, std::string> signal_maplist_needed(); |
|
96 |
|
97 ///Emitted if user wants to create a new map for inpuit or output. |
|
98 sigc::signal<void, std::string, bool> signal_newmapwin_needed(){return signal_newmapwin_need;}; |
|
99 |
|
100 ///Emits signal that requires list of maps for the recently selected \ref NoteBookTab. |
34 void emit_tab_change(); |
101 void emit_tab_change(); |
35 |
102 |
|
103 ///Interface, through which \ref AlgoBox can be notified about tab addition, deletion in \ref MainWin |
|
104 |
|
105 ///\param tl list |
|
106 ///of new tab state. |
36 void update_tablist( std::vector< std::string > tl ); |
107 void update_tablist( std::vector< std::string > tl ); |
37 void update_maplist( MapStorage * ); |
|
38 |
108 |
|
109 ///Interface, through which \ref AlgoBox can get the maps of the recently selected \ref NoteBookTab |
|
110 |
|
111 ///\param ms the maps |
|
112 ///of the recently selected \ref NoteBookTab |
|
113 void update_maplist( MapStorage * ms); |
|
114 |
|
115 ///Interface, through which \ref AlgoBox can be notified about nodemap addition. |
|
116 |
|
117 ///If new map was added to \ref MapStorage of currently selected \ref NoteBookTab |
|
118 ///a signal is emitted by it. This signal is connected to this function, so \ref MapSelector s |
|
119 ///in \ref nodemapcbts can be notified, and those can registrate the new map. (\ref MapSelector::append_text) |
39 void nodemaplist_changed(std::string); |
120 void nodemaplist_changed(std::string); |
|
121 |
|
122 ///Interface, through which \ref AlgoBox can be notified about edgemap addition. |
|
123 |
|
124 ///If new map was added to \ref MapStorage of currently selected \ref NoteBookTab |
|
125 ///a signal is emitted by it. This signal is connected to this function, so \ref MapSelector s |
|
126 ///in \ref edgemapcbts can be notified, and those can registrate the new map. (\ref MapSelector::append_text) |
40 void edgemaplist_changed(std::string); |
127 void edgemaplist_changed(std::string); |
41 |
128 |
42 void update_cbt( std::vector< std::string > tl, Gtk::ComboBoxText &); |
129 ///Aid function to provide data for a given entry. |
43 |
130 |
|
131 ///At the moment it is only used for updating info |
|
132 ///in \ref tabcbt. It clears it first, after that |
|
133 ///inserts the data got from caller, and if there |
|
134 ///was previously selected item it switches entry |
|
135 ///to that. |
|
136 ///\param tl list of entries (at the moment tabs in \ref MainWin) |
|
137 ///\param cbt the entry to update (at the moment only \ref tabcbt) |
|
138 void update_cbt( std::vector< std::string > tl, Gtk::ComboBoxText & cbt); |
|
139 |
|
140 ///Runs the ralized algorithm. |
|
141 |
|
142 ///Prepare the data for it |
|
143 ///and after that postprocess it if necessary. |
|
144 ///This is only a demo here, but in children it |
|
145 ///runs the algorithm really. |
44 virtual void run(); |
146 virtual void run(); |
45 |
147 |
|
148 ///Creates the layout of the \ref AlgoBox |
|
149 |
|
150 ///Place all the entries |
|
151 ///required. Run and close button is not |
|
152 ///its responsibility! |
46 virtual void build_box(); |
153 virtual void build_box(); |
47 |
154 |
48 virtual void emit_new_map_signal(bool); |
155 ///Emits \ref signal_newmapwin_need if user wants to create new input or output map. |
49 |
156 |
50 void addMapSelector(std::string, bool); |
157 ///Called in case of pressing \ref MapSelector::newbut. |
|
158 ///\param itisedge edge or nodemap is required. |
|
159 virtual void emit_new_map_signal(bool itisedge); |
|
160 |
|
161 ///Aid function to make addition of \ref MapSelector easy in \ref build_box. |
|
162 |
|
163 ///\param label label to show in \ref MapSelector |
|
164 ///\param itisedge whether edge or nodemaps stored in \ref MapSelector |
|
165 void addMapSelector(std::string label, bool itisedge); |
51 }; |
166 }; |
52 #endif //ALGOBOX_H |
167 #endif //ALGOBOX_H |