source: glemon/nbtab.h @ 6:3a44a2bb6da8

/* -*- 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 NBTAB_H
#define NBTAB_H

class MapStorage;
class EpsWin;
class MapWin;
class DesignWin;
class DigraphDisplayerCanvas;

#include <libgnomecanvasmm.h>
#include <libgnomecanvasmm/polygon.h>
#include "map_value.h"

///One tab in the Notebook that is placed in the main window (\ref MainWin).

///One digraph and all of its accessories like maps are assigned to one tab in the notebook.
///\ref NoteBookTab is responsible for the user defined display of the digraph: view can be
///set by visualized maps, therefore \ref NoteBookTab must provide an interface to set the
///view of digraph. This is \ref Mapwin window.
///
///\ref NoteBookTab is also
///responsible for modify the digraph if it is
///requested. Therefore it is responsible for translating user events to modifications to
///do on digraph, like node/arc addition/deletion, map modification, addition and so on.
///
///To be able to solve these tasks the help of \ref MainWin is also needed, for example to
///know which editor-tool is active at the moment. Therefore \ref MainWin knows \ref NoteBookTab.
///
///Some information in the other direction is needed as well: for example when new map creation is requested for this tab
///\ref NoteBookTab must ask \ref MainWin to pop-up a \ref NewMapWin. Communication in this direction is realized by signals
///therefore \ref NoteBookTab does not know \ref MainWin at all, but in this way it is not necessary.
class NoteBookTab : public Gtk::VBox
{
public:
  
  ///Constructor of \ref NoteBookTab

  ///It initiates the \re DigraphDisplayerCanvas, on which the digraph will be drawn
  ///Signals of \ref MapStorage will be bound to the appropriate callback functions here.
  NoteBookTab();
  
  ~NoteBookTab();
  
  ///Maps assigned to the digraph displayed in this \ref NoteBookTab of notebook.
  MapStorage * mapstorage;
    
  ///Title changement indicator.

  ///If digraph is loaded from disk or saved to disk or changed its name somehow
  ///this signal will be emit to let
  ///\ref MainWin know that it has to modify the title of the main window.
  ///It contains the new title.
  sigc::signal<void, std::string> signal_title;

  ///Returns \ref signal_title to be the caller able to connect it to a callback function.
  sigc::signal<void, std::string> signal_title_ch();

  ///Indicates that new map window should be popped up.

  ///\ref NoteBookTab can ask \ref MainWin to pop up a \ref NweMapWin ny emitting this signal.
  ///The signal contains whether an arcmap or a nodemap should be popped up. \ref NewMapWin
  ///is not popped up by \ref NoteBookTab, because not only \ref NoteBookTab needs \ref NewMapWin,
  ///but for example \ref MainWin and \ref AlgoWin s as well.
  sigc::signal<void, NoteBookTab *, bool> signal_newmap;

  ///Returns \ref signal_newmap to be the caller able to connect it to a callback function.
  sigc::signal<void, NoteBookTab *, bool> signal_newmap_needed();

  ///Loads the given file.

  ///The given file will be load in the \ref MapStorage and afeter that
  ///\ref DigraphDisplayerCanvas will be requested to display the digraph.
  ///\ref DigraphDisplayer will get datas from the recently set \ref MapStorage.
  void readFile(const std::string &);
    
  ///The digraph will be drawn on this \ref DigraphDisplayerCanvas
  DigraphDisplayerCanvas * gd_canvas;

  ///Indicates whether the \ref MapWin is opened or not. See \ref mapwin.
  bool mapwinexists;

  ///Indicates whether the \ref DesignWin is opened or not. See \ref designwin.
  bool designwinexists;

  ///Indicates whether the \ref EpsWin is opened or not. See \ref epswin.
  bool epswinexists;

  ///Address of the only \ref MapWin that the \ref NoteBookTab can open.

  ///Only one of this window can be opened at the same time (\ref mapwinexists), 
  ///because there is no need for more, one per tab is enough.
  ///There won1t be benefit of more than one, but it would be
  ///more complicated to synchronize them.
  MapWin * mapwin;
    
  ///Address of the only \ref DesignWin that the \ref NoteBookTab can open.

  ///Only one of this window can be opened at the same time (\ref designwinexists), 
  ///because there is no need for more, one per tab is enough.
  ///There won't be benefit of more than one, but it would be
  ///more complicated to synchronize them.
  DesignWin * designwin;

  ///Address of the only \ref EpsWin that the \ref NoteBookTab can open.

  ///Only one of this window can be opened at the same time (\ref epswinexists), 
  ///because there is no need for more, one per tab is enough.
  ///There won't be benefit of more than one.
  EpsWin * epswin;

public:
  ///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();

  ///Handles changement of view of digraph.

  ///If the user changes the map to show by a property to a nother in \ref MapWin,
  ///\ref MapWin will call this function. This function will registrate in \ref MapStorage
  ///the new map to display by the changed property. After that \ref MapStorage will
  ///emits a signal that will be forwarded to \ref DigraphDisplayerCanvas to update the
  ///appropriate parts of digraph.
  ///\param itiesarc whether the changed property is arc property or node property
  ///\param prop id of property, see all_include.h
  ///\param mapname name of the recently selected map
  void propertyChange(bool itisarc, int prop, std::string mapname);

  ///Emits a signal that request \ref MainWin to pop up \ref NewMapWin

  ///This function is called by \ref MapWin.
  ///\param itisarc whether the new map should be an arcmap or a nodemap.
  void popupNewMapWin(bool itisarc);

  ///Returns the actually selected arcmap to visualize by the given property.

  ///\ref MapWin calls this function, beacuse it does not know \ref MapStorage.
  ///\param prop property to inquire.
  std::string getActiveArcMap(int prop);

  ///Returns the actually selected nodemap to visualize by the given property.

  ///\ref MapWin calls this function, beacuse it does not know \ref MapStorage.
  ///\param prop property to inquire.
  std::string getActiveNodeMap(int prop);

  ///Registers recently created arcmap in \ref MapWin.

  ///After creation of new map \ref MapStorage emits a signal.
  ///This signal is bound to this callback function, that will call
  ///a function with the same name and same parameterin \ref MapWin.
  ///This call-forwarder function is needed, because \ref Mapstorage does not know \ref MapWin
  ///\param mapname name of new map
  void registerNewArcMap(std::string mapname, MapValue::Type type);

  ///Registers recently created nodemap in \ref MapWin.

  ///After creation of new map \ref MapStorage emits a signal.
  ///This signal is bound to this callback function, that will call
  ///a function with the same name and same parameter in \ref MapWin.
  ///This call-forwarder function is needed, because \ref Mapstorage does not know \ref MapWin
  ///\param mapname name of new map
  void registerNewNodeMap(std::string mapname, MapValue::Type type);

  ///Pops up and registrates the \ref MapWin of \ref NoteBookTab.
  
  ///See also
  ///\ref mapwin.
  void createMapWin(std::string);

  ///Pops up and registrates the \ref DesignWin of \ref NoteBookTab.
  
  ///See also
  ///\ref mapwin.
  void createDesignWin(std::string);

  ///Pops up a window, that can dump digraph to EPS

  ///Different parameters can be set here.
  void createExportToEPSWin(std::string);

  ///Closes and deregistrates the \ref MapWin of \ref NoteBookTab.
  
  ///See also
  ///\ref mapwin.
  void closeMapWin();

  ///Closes and deregistrates the \ref DesignWin of \ref NoteBookTab.
  
  ///See also
  ///\ref designwin.
  bool closeDesignWin(GdkEventAny *);

  ///Closes and deregistrates the \ref EpsWin of \ref NoteBookTab.
  
  ///See also
  ///\ref epswin.
  void closeEpsWin();

  ///Sets node representation settings
  void setView(bool, bool, double, double);

  ///Gets node representation settings
  void getView(bool &, bool &, double&, double&);

  ///Let the digraph redesign, based on gravity and arc elasticity.
  void reDesignDigraph();

  ///Lets Mapstorage export the digraph to EPS
  void exportDigraphToEPS(std::vector<bool>, std::string, std::string);

  ///\ref MapWin calls this function when it updates the maplist in comboboxes.
  void active_maps_needed();

private:
  ///Called when title of tab has changed
  void title_changed(std::string);

  ///Signal connection from \ref MapStorage to \ref MapWin

  ///If \ref MapWin is closed this connection has to be disconnected,
  ///therefore we have to store it.
  sigc::connection mapst2mapwin;

  ///Signal connection from \ref MapStorage to \ref DesignWin

  ///If \ref DesignWin is closed this connection has to be disconnected,
  ///therefore we have to store it.
  sigc::connection mapst2designwin;
};

#endif //NBTAB_H