[174] | 1 | /* -*- C++ -*- |
---|
| 2 | * |
---|
| 3 | * This file is a part of LEMON, a generic C++ optimization library |
---|
| 4 | * |
---|
| 5 | * Copyright (C) 2003-2006 |
---|
| 6 | * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport |
---|
| 7 | * (Egervary Research Group on Combinatorial Optimization, EGRES). |
---|
| 8 | * |
---|
| 9 | * Permission to use, modify and distribute this software is granted |
---|
| 10 | * provided that this copyright notice appears in all copies. For |
---|
| 11 | * precise terms see the accompanying LICENSE file. |
---|
| 12 | * |
---|
| 13 | * This software is provided "AS IS" with no warranty of any kind, |
---|
| 14 | * express or implied, and with no claim as to its suitability for any |
---|
| 15 | * purpose. |
---|
| 16 | * |
---|
| 17 | */ |
---|
[42] | 18 | |
---|
| 19 | #ifndef NEWMAPWIN_H |
---|
| 20 | #define NEWMAPWIN_H |
---|
| 21 | |
---|
| 22 | class NewMapWin; |
---|
| 23 | |
---|
| 24 | #include <all_include.h> |
---|
[96] | 25 | #include <nbtab.h> |
---|
[42] | 26 | #include <libgnomecanvasmm.h> |
---|
| 27 | #include <libgnomecanvasmm/polygon.h> |
---|
[88] | 28 | #include <stack> |
---|
[42] | 29 | |
---|
[120] | 30 | ///Graphical interface for node/edge map creation. |
---|
| 31 | |
---|
[42] | 32 | ///This class is responsible for creating a window, |
---|
| 33 | ///on which the parameters of a new map can be set. |
---|
[90] | 34 | class NewMapWin : public Gtk::Dialog |
---|
[42] | 35 | { |
---|
[120] | 36 | ///The \ref NoteBookTab in which the new map has to be placed. |
---|
[96] | 37 | NoteBookTab & mytab; |
---|
[42] | 38 | |
---|
[88] | 39 | public: |
---|
[120] | 40 | |
---|
| 41 | ///Struct to be able to evaluate expressions. |
---|
| 42 | |
---|
| 43 | ///Initial values of map elements can be given |
---|
| 44 | ///by numbers or by expressions. From expressions |
---|
[121] | 45 | ///we build first a tree according to the priorities |
---|
| 46 | ///of operations in the expression. This is the data |
---|
| 47 | ///structure |
---|
[120] | 48 | ///that can store one tree element. |
---|
[88] | 49 | struct tree_node |
---|
| 50 | { |
---|
[120] | 51 | ///Character stored in this tree element |
---|
[88] | 52 | char ch; |
---|
[120] | 53 | ///Left child of tree element. |
---|
[88] | 54 | tree_node * left_child; |
---|
[120] | 55 | ///Right child of tree element. |
---|
[88] | 56 | tree_node * right_child; |
---|
| 57 | }; |
---|
| 58 | |
---|
[120] | 59 | ///Constructor of NewMapWin. |
---|
| 60 | |
---|
| 61 | ///It creates the widgets shown in |
---|
| 62 | ///NewMapWin. |
---|
[96] | 63 | NewMapWin(const std::string& title, NoteBookTab &, bool itisedge=true, bool edgenode=true); |
---|
[117] | 64 | |
---|
[120] | 65 | ///Callback function for OK button. It creates the map. |
---|
| 66 | |
---|
| 67 | ///This function determines whether the input is correct: |
---|
| 68 | ///the name of new map must not be already used, the expression |
---|
| 69 | ///that gives tha initial values of map elements has to be valid. |
---|
| 70 | ///If input is correct it creates and registrates the new map |
---|
| 71 | ///to the correct place. (\ref mytab) |
---|
[90] | 72 | virtual void on_response(int response_id); |
---|
[85] | 73 | |
---|
[120] | 74 | ///Close window if Esc key pressed. |
---|
[42] | 75 | virtual bool closeIfEscapeIsPressed(GdkEventKey*); |
---|
| 76 | |
---|
[120] | 77 | ///Function that creates a tree from an appropriately manipulated string. |
---|
[88] | 78 | |
---|
[120] | 79 | ///Tree is builded according to priorities of operations in expression given by string. |
---|
| 80 | ///Priorities are indicated in a vector that contains weights for each operation. |
---|
| 81 | ///\param to_tree string to build tree from |
---|
| 82 | ///\param weights weights (priorities) |
---|
| 83 | ///\param offset this function call is recursive. This parameter tells us, |
---|
| 84 | ///with which part of the string do we have to deal with. |
---|
| 85 | tree_node * weightedString2Tree(std::string to_tree, std::vector<unsigned int> & weights, int offset); |
---|
[88] | 86 | |
---|
[120] | 87 | ///Function that creates a string from a tree by postorder reading. |
---|
[88] | 88 | |
---|
[120] | 89 | ///This is the last step of creating polishform |
---|
| 90 | ///from a given expression string. |
---|
| 91 | ///\param root the root of the tree to read through |
---|
| 92 | std::string postOrder(tree_node * root); |
---|
[88] | 93 | |
---|
[120] | 94 | ///From the given expression it creates expression given in polish form. |
---|
[117] | 95 | |
---|
[120] | 96 | ///First it substitutes variables and numbers in the given expression. |
---|
| 97 | ///The substitutions will be one character long local variables. |
---|
| 98 | ///The substituted-substitution pair is registrated in \ref ch2var. |
---|
| 99 | ///After that it gives weights fo each character in substituted expression. |
---|
| 100 | ///Weights are calculated according to the priority of operations in expression. |
---|
| 101 | ///Then it creates tree (\ref tree_node) from the weighted string. (\ref weightedString2Tree) |
---|
| 102 | ///\param to_polish the string to turn into polish_form |
---|
| 103 | ///\param itisedge do we have to create an edgemap or a nodemap. |
---|
| 104 | ///It is important, because variables are maps and if expression |
---|
| 105 | ///citates a map that does not exists the expression is not valid. |
---|
| 106 | ///But to determine, whether the map exists we have to know where |
---|
| 107 | ///to search for it. And of course for a new edgemap only edgemaps can be serve with values. |
---|
| 108 | std::string string2Polishform(std::string to_polish, bool itisedge); |
---|
| 109 | |
---|
| 110 | ///Returns whether a string can be used as value in an expression. |
---|
| 111 | |
---|
| 112 | ///The given string has to be either a mapname or a number. If it is a mapname |
---|
| 113 | ///we have to know whether it is an edgemap or a nodemap. |
---|
| 114 | ///\param variable the string about the function has to determine whether it is usable in expressions |
---|
| 115 | ///\param itisedge should the mapname be between edgemaps, or nodemaps |
---|
| 116 | bool validVariable(std::string variable, bool itisedge); |
---|
| 117 | |
---|
| 118 | ///Deletes the whole tree created for translating string to polishform. |
---|
| 119 | |
---|
| 120 | ///\param root |
---|
| 121 | ///root of the tree |
---|
| 122 | void deleteTree(tree_node * root); |
---|
| 123 | |
---|
| 124 | ///Dictionary of substitutions in expression. |
---|
| 125 | |
---|
| 126 | ///Variables and numbers are substituted with one character long variables in expressions. |
---|
| 127 | ///This is the dictionary. |
---|
[88] | 128 | std::map<char, std::string> ch2var; |
---|
| 129 | |
---|
[120] | 130 | ///Entry which gives us the name of new map. |
---|
| 131 | Gtk::Entry name; |
---|
[42] | 132 | |
---|
[120] | 133 | ///Entry which gives us the initial values of elements of new map. |
---|
| 134 | |
---|
| 135 | ///Initial value can be a number or an expression after that the |
---|
| 136 | ///initial value for each map element can be calculated. |
---|
| 137 | Gtk::Entry default_value; |
---|
| 138 | |
---|
| 139 | ///GTK Designing object. |
---|
[42] | 140 | Gtk::Table * table; |
---|
[120] | 141 | |
---|
| 142 | ///Information holder in window. |
---|
[42] | 143 | Gtk::Label * label; |
---|
| 144 | |
---|
[120] | 145 | ///If selected, nodemap will be created. |
---|
| 146 | Gtk::RadioButton node; |
---|
| 147 | |
---|
| 148 | ///If selected, edgemap will be created. |
---|
| 149 | Gtk::RadioButton edge; |
---|
[42] | 150 | }; |
---|
| 151 | |
---|
| 152 | #endif //NEWMAPWIN_H |
---|