/* -*- C++ -*- * * This file is a part of LEMON, a generic C++ optimization library * * Copyright (C) 2003-2006 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Research Group on Combinatorial Optimization, EGRES). * * Permission to use, modify and distribute this software is granted * provided that this copyright notice appears in all copies. For * precise terms see the accompanying LICENSE file. * * This software is provided "AS IS" with no warranty of any kind, * express or implied, and with no claim as to its suitability for any * purpose. * */ #ifndef MAIN_WIN_H #define MAIN_WIN_H #include "all_include.h" #include #include #include class AlgoWin; class NoteBookTab; ///This class is the main window of GUI. ///It has menus, and a notebook. Notebook has different pages, ///the so called tabs (\ref NoteBookTab). Each \ref NoteBookTab contains a canvas on which digraphs can be drawn. ///To manage creation and close of tabs and tabswitching is the task of MainWin. class MainWin : public Gtk::Window { ///Container in which the menus and the notebook is. //Gtk::VBox vbox; Gtk::Table table; Gtk::Table table2; ///Container in which the toolbar and the node parametrizer is. Gtk::HBox hbox; ///Should nodes be autoscaled or not? Gtk::CheckButton * auto_scale; ///Should node size track zoom factor? Gtk::CheckButton * zoom_track; ///Minimum and maximum node radius entry Gtk::SpinButton * radius_size, * arc_width; ///The notebook that has tabs (\ref NoteBookTab) with different digraphs. Gtk::Notebook notebook; ///The tool selected to manipulate digraph. ///It has to be stored, because in case of tabswitching ///the correct tool has to be set for the actual digraph. int active_tool; ///The number of active tab in the notebook. int active_tab; ///Vector of existing tabs in the notebook. std::vector tabs; ///Vector of the name of tabs. ///All \ref NoteBookTab has a name that is stored here. The index of the name ///is the same as the index of the \ref NoteBookTab in \ref tabs. std::vector tabnames; ///Counter of occurence of the same file names. ///If a file is opened more than once we have to score ///the occurences to let the titles on tabs different. ///If more than one occurence is present, from the second ///one near the filename the number of the occurence appear. std::map strinst; ///Set of opened \ref AlgoWin s. ///More than one \refAlgoWin can be opened. We have to ///communicate with them in case of new \ref NoteBookTab creation, ///\ref NoteBookTab close, or map change. Therefore we have to score ///their occurences. std::set< AlgoWin* > aws; public: ///Constructor of the \ref MainWin. ///It creates the menus, the toolbar and the notebook in which ///\ref NoteBookTab s take place. \ref NoteBookTab s are the ///holder of the canvases on which the digraphs are drawn. MainWin(); ~MainWin(); ///Sets title of tabs. ///It alse registrates it in \ref tabnames. If more than one ///occurence is in the notebook of the same file it has to ///extend tabname with the number of occurence. void set_tabtitle(std::string); ///ActionGroup for menu Glib::RefPtr ag; ///UIManager for menu Glib::RefPtr uim; ///Creates a new \ref NoteBookTab and opens the given file. ///It is called only with command line parameters at stratup. void readFile(const std::string &); ///Tooltips Gtk::Tooltips * tooltips; //Call-backs of buttons ///Callback for 'FileNew' action. virtual void newFile(); ///Callback for 'FileOpen' action. virtual void openFile(); ///Callback for 'FileSave' action. virtual void saveFile(); ///Callback for 'FileSaveAs' action. virtual void saveFileAs(); ///Callback for 'Close' action. virtual void close(); //Toolbar ///Callback for 'zoomIn' action. ///It calls the appropriate function in ///\ref DigraphDisplayerCanvas virtual void zoomIn(); ///Callback for 'zoomOut' action. ///It calls the appropriate function in ///\ref DigraphDisplayerCanvas virtual void zoomOut(); ///Callback for 'zoomFit' action. ///It calls the appropriate function in ///\ref DigraphDisplayerCanvas virtual void zoomFit(); ///Callback for 'zoom100' action. ///It calls the appropriate function in ///\ref DigraphDisplayerCanvas virtual void zoom100(); ///Callback for Show Maps menupoint. ///It calls the appropriate function in ///\ref NoteBookTab virtual void createMapWin(); ///Callback for Show Design menupoint. ///It calls the appropriate function in ///\ref NoteBookTab virtual void createDesignWin(); ///Pops up an Algorithm window. ///It not only creates but registrates the newly created \ref AlgoWin. ///It is necessary, because in case of changement between tabs or maps ///we have to communicate with it. Signals are also have to be connected ///to it, because \ref AlgoWin emits signals if it needs anything (maplist, deregistration). ///\param algo type of the algorithm to run. virtual void createAlgoWin(int algo); ///Deregisters AlgoWin ///This is the function connected to the closing signal of \ref AlgoWin. ///It only deletes the sender \ref AlgoWin from \ref aws. This function ///is called only by the closing \ref AlgoWin itself. ///\param aw the \ref AlgoWin to delete. virtual void deRegisterAlgoWin(AlgoWin * aw); ///Updates list of tabs in all of the \ref AlgoWin ///When \ref NoteBookTab inserted somewhere or closed one tablist in all \ref AlgoWin ///have to be updated. That is why we score all the opened \ref AlgoWin. ///During update \ref tabnames will be passed to each \ref AlgoWin. virtual void updateAlgoWinTabs(); ///Refresh list of maps in the AlgoWin that requested it. ///In an \ref AlgoWin there is a ComboBoxText, in which ///a \ref NoteBookTab can be chosen that contains the digraph and the maps, ///on which we would like to run algorithms. If we change the ///tab the available maps also have to be updated, because ///in the different tabs different maps are available. Therefore ///on tab change the \ref AlgoWin emits a signal that contains itself ///so that the appropriate maps can be sent to it. For the sake of simplicity ///the program answers this call with the mapstorage of the newly selected tab. ///\param aw the caller \ref AlgoWin ///\param tabname the newly selected tab in the \ref AlgoWin virtual void updateAlgoWinMaps(AlgoWin * aw, std::string tabname); ///Registrates the new digraph-editor tool in hand. ///The editor-tool in hand is global, it is the same for all tab ///at the same time. Therefore the active tool has to be scored here (\ref active_tool). ///This function is the callback function of the editor-tool buttons. It sets \ref active_tool ///to the correct value. ///\param tool the newly selected digraph-editor tool (See all_include.h) virtual void changeEditorialTool(int tool); ///Pops up a \ref NewMapWin dialog after requested by a \ref MapWin ///Each tab can pop-up a \ref MapWin. In \ref MapWin new tab can be created. ///In this case \ref NoteBookTab emits a signal. This function is connected to that signal. ///It sends the caller \ref NoteBookTab and whether an arcmap or a nodemap should be created. ///Caller \ref NoteBookTab is necessary for the window to be able to place the new map in its ///correct place. ///\param nbt the caller tab ///\param itisarc true if arcmap has to be created, false if nodemap virtual void createNewMapWinAfterSignal(NoteBookTab * nbt, bool itisarc); ///Pops up a \ref NewMapWin dialog after requested by an \ref AlgoWin ///\ref AlgoWin can also can request a \ref NewMapWin to pop-up. ///It emits a signal in this case. This function is bound to that signal. ///The signal contains the name of \ref NoteBookTab in which the new map has to be ///placed and whether the new map is an arcmap or a nodemap. ///\ref tabname the tab in which the new map has to be placed ///\ref itisarc true if the new map will be arc map, false if it will be nodemap virtual void createNewMapWinTabString(std::string tabname, bool itisarc); ///Pops up a \ref NewMapWin dialog if button on \ref MainWin has been pressed. ///In this case a general \ref NewMapWin will be popped up. This means that ///both arc and nodemap can be created by it. The new map will be placed in ///\MapStorage of the actual selected \ref NoteBookTab. virtual void createNewMapWin(); //Notebook handlers ///Callback for 'FileNewTab' action. virtual void newTab(); ///Callback for 'FileCloseTab' action. ///It closes the actual \ref NoteBookTab and registrates this event: ///data is shifted to the correct places in vectors. virtual void closeTab(); ///Tabswitching handler ///Sets the variables that have to store the actual state, and it ///updates the title of window to the actually selected \ref NoteBookTab. virtual void onChangeTab(GtkNotebookPage*, guint); virtual void nodeViewChanged(); virtual void reDesignDigraph(); /// Pops up a SaveDetailsDialog. void createSaveDetailsDialog(); virtual void exportToEPS(); void createBackgroundChooser(); }; #endif //MAIN_WIN_H