Index: THORS
===================================================================
--- AUTHORS	(revision 164)
+++ 	(revision )
@@ -1,1 +1,0 @@
-To be filled
Index: PYING
===================================================================
--- COPYING	(revision 164)
+++ 	(revision )
@@ -1,1 +1,0 @@
-To be filled
Index: xyfile
===================================================================
--- Doxyfile	(revision 90)
+++ 	(revision )
@@ -1,273 +1,0 @@
-# Doxyfile 1.4.5
-
-#---------------------------------------------------------------------------
-# Project related configuration options
-#---------------------------------------------------------------------------
-PROJECT_NAME           = glemon
-PROJECT_NUMBER         = 0.1
-OUTPUT_DIRECTORY       = 
-CREATE_SUBDIRS         = NO
-OUTPUT_LANGUAGE        = English
-USE_WINDOWS_ENCODING   = NO
-BRIEF_MEMBER_DESC      = YES
-REPEAT_BRIEF           = YES
-ABBREVIATE_BRIEF       = "The $name class" \
-                         "The $name widget" \
-                         "The $name file" \
-                         is \
-                         provides \
-                         specifies \
-                         contains \
-                         represents \
-                         a \
-                         an \
-                         the
-ALWAYS_DETAILED_SEC    = NO
-INLINE_INHERITED_MEMB  = NO
-FULL_PATH_NAMES        = YES
-STRIP_FROM_PATH        = .
-STRIP_FROM_INC_PATH    = 
-SHORT_NAMES            = NO
-JAVADOC_AUTOBRIEF      = NO
-MULTILINE_CPP_IS_BRIEF = NO
-DETAILS_AT_TOP         = NO
-INHERIT_DOCS           = YES
-SEPARATE_MEMBER_PAGES  = NO
-TAB_SIZE               = 8
-ALIASES                = 
-OPTIMIZE_OUTPUT_FOR_C  = NO
-OPTIMIZE_OUTPUT_JAVA   = NO
-BUILTIN_STL_SUPPORT    = NO
-DISTRIBUTE_GROUP_DOC   = NO
-SUBGROUPING            = YES
-#---------------------------------------------------------------------------
-# Build related configuration options
-#---------------------------------------------------------------------------
-EXTRACT_ALL            = YES
-EXTRACT_PRIVATE        = YES
-EXTRACT_STATIC         = YES
-EXTRACT_LOCAL_CLASSES  = YES
-EXTRACT_LOCAL_METHODS  = NO
-HIDE_UNDOC_MEMBERS     = NO
-HIDE_UNDOC_CLASSES     = NO
-HIDE_FRIEND_COMPOUNDS  = NO
-HIDE_IN_BODY_DOCS      = NO
-INTERNAL_DOCS          = NO
-CASE_SENSE_NAMES       = YES
-HIDE_SCOPE_NAMES       = NO
-SHOW_INCLUDE_FILES     = YES
-INLINE_INFO            = YES
-SORT_MEMBER_DOCS       = YES
-SORT_BRIEF_DOCS        = NO
-SORT_BY_SCOPE_NAME     = NO
-GENERATE_TODOLIST      = YES
-GENERATE_TESTLIST      = YES
-GENERATE_BUGLIST       = YES
-GENERATE_DEPRECATEDLIST= YES
-ENABLED_SECTIONS       = 
-MAX_INITIALIZER_LINES  = 30
-SHOW_USED_FILES        = YES
-SHOW_DIRECTORIES       = YES
-FILE_VERSION_FILTER    = 
-#---------------------------------------------------------------------------
-# configuration options related to warning and progress messages
-#---------------------------------------------------------------------------
-QUIET                  = NO
-WARNINGS               = YES
-WARN_IF_UNDOCUMENTED   = YES
-WARN_IF_DOC_ERROR      = YES
-WARN_NO_PARAMDOC       = NO
-WARN_FORMAT            = "$file:$line: $text"
-WARN_LOGFILE           = 
-#---------------------------------------------------------------------------
-# configuration options related to the input files
-#---------------------------------------------------------------------------
-INPUT                  = .
-FILE_PATTERNS          = *.c \
-                         *.cc \
-                         *.cxx \
-                         *.cpp \
-                         *.c++ \
-                         *.d \
-                         *.java \
-                         *.ii \
-                         *.ixx \
-                         *.ipp \
-                         *.i++ \
-                         *.inl \
-                         *.h \
-                         *.hh \
-                         *.hxx \
-                         *.hpp \
-                         *.h++ \
-                         *.idl \
-                         *.odl \
-                         *.cs \
-                         *.php \
-                         *.php3 \
-                         *.inc \
-                         *.m \
-                         *.mm \
-                         *.dox \
-                         *.py \
-                         *.C \
-                         *.CC \
-                         *.C++ \
-                         *.II \
-                         *.I++ \
-                         *.H \
-                         *.HH \
-                         *.H++ \
-                         *.CS \
-                         *.PHP \
-                         *.PHP3 \
-                         *.M \
-                         *.MM \
-                         *.PY
-RECURSIVE              = NO
-EXCLUDE                = 
-EXCLUDE_SYMLINKS       = NO
-EXCLUDE_PATTERNS       = 
-EXAMPLE_PATH           = 
-EXAMPLE_PATTERNS       = *
-EXAMPLE_RECURSIVE      = NO
-IMAGE_PATH             = 
-INPUT_FILTER           = 
-FILTER_PATTERNS        = 
-FILTER_SOURCE_FILES    = NO
-#---------------------------------------------------------------------------
-# configuration options related to source browsing
-#---------------------------------------------------------------------------
-SOURCE_BROWSER         = YES
-INLINE_SOURCES         = NO
-STRIP_CODE_COMMENTS    = YES
-REFERENCED_BY_RELATION = YES
-REFERENCES_RELATION    = YES
-USE_HTAGS              = NO
-VERBATIM_HEADERS       = YES
-#---------------------------------------------------------------------------
-# configuration options related to the alphabetical class index
-#---------------------------------------------------------------------------
-ALPHABETICAL_INDEX     = NO
-COLS_IN_ALPHA_INDEX    = 5
-IGNORE_PREFIX          = 
-#---------------------------------------------------------------------------
-# configuration options related to the HTML output
-#---------------------------------------------------------------------------
-GENERATE_HTML          = YES
-HTML_OUTPUT            = html
-HTML_FILE_EXTENSION    = .html
-HTML_HEADER            = 
-HTML_FOOTER            = 
-HTML_STYLESHEET        = 
-HTML_ALIGN_MEMBERS     = YES
-GENERATE_HTMLHELP      = NO
-CHM_FILE               = 
-HHC_LOCATION           = 
-GENERATE_CHI           = NO
-BINARY_TOC             = NO
-TOC_EXPAND             = NO
-DISABLE_INDEX          = NO
-ENUM_VALUES_PER_LINE   = 4
-GENERATE_TREEVIEW      = NO
-TREEVIEW_WIDTH         = 250
-#---------------------------------------------------------------------------
-# configuration options related to the LaTeX output
-#---------------------------------------------------------------------------
-GENERATE_LATEX         = NO
-LATEX_OUTPUT           = latex
-LATEX_CMD_NAME         = latex
-MAKEINDEX_CMD_NAME     = makeindex
-COMPACT_LATEX          = NO
-PAPER_TYPE             = a4wide
-EXTRA_PACKAGES         = 
-LATEX_HEADER           = 
-PDF_HYPERLINKS         = NO
-USE_PDFLATEX           = NO
-LATEX_BATCHMODE        = NO
-LATEX_HIDE_INDICES     = NO
-#---------------------------------------------------------------------------
-# configuration options related to the RTF output
-#---------------------------------------------------------------------------
-GENERATE_RTF           = NO
-RTF_OUTPUT             = rtf
-COMPACT_RTF            = NO
-RTF_HYPERLINKS         = NO
-RTF_STYLESHEET_FILE    = 
-RTF_EXTENSIONS_FILE    = 
-#---------------------------------------------------------------------------
-# configuration options related to the man page output
-#---------------------------------------------------------------------------
-GENERATE_MAN           = NO
-MAN_OUTPUT             = man
-MAN_EXTENSION          = .3
-MAN_LINKS              = NO
-#---------------------------------------------------------------------------
-# configuration options related to the XML output
-#---------------------------------------------------------------------------
-GENERATE_XML           = NO
-XML_OUTPUT             = xml
-XML_SCHEMA             = 
-XML_DTD                = 
-XML_PROGRAMLISTING     = YES
-#---------------------------------------------------------------------------
-# configuration options for the AutoGen Definitions output
-#---------------------------------------------------------------------------
-GENERATE_AUTOGEN_DEF   = NO
-#---------------------------------------------------------------------------
-# configuration options related to the Perl module output
-#---------------------------------------------------------------------------
-GENERATE_PERLMOD       = NO
-PERLMOD_LATEX          = NO
-PERLMOD_PRETTY         = YES
-PERLMOD_MAKEVAR_PREFIX = 
-#---------------------------------------------------------------------------
-# Configuration options related to the preprocessor   
-#---------------------------------------------------------------------------
-ENABLE_PREPROCESSING   = YES
-MACRO_EXPANSION        = NO
-EXPAND_ONLY_PREDEF     = NO
-SEARCH_INCLUDES        = YES
-INCLUDE_PATH           = 
-INCLUDE_FILE_PATTERNS  = 
-PREDEFINED             = 
-EXPAND_AS_DEFINED      = 
-SKIP_FUNCTION_MACROS   = YES
-#---------------------------------------------------------------------------
-# Configuration::additions related to external references   
-#---------------------------------------------------------------------------
-TAGFILES               = 
-GENERATE_TAGFILE       = 
-ALLEXTERNALS           = NO
-EXTERNAL_GROUPS        = YES
-PERL_PATH              = /usr/bin/perl
-#---------------------------------------------------------------------------
-# Configuration options related to the dot tool   
-#---------------------------------------------------------------------------
-CLASS_DIAGRAMS         = NO
-HIDE_UNDOC_RELATIONS   = YES
-HAVE_DOT               = YES
-CLASS_GRAPH            = YES
-COLLABORATION_GRAPH    = YES
-GROUP_GRAPHS           = YES
-UML_LOOK               = NO
-TEMPLATE_RELATIONS     = NO
-INCLUDE_GRAPH          = YES
-INCLUDED_BY_GRAPH      = YES
-CALL_GRAPH             = YES
-GRAPHICAL_HIERARCHY    = YES
-DIRECTORY_GRAPH        = YES
-DOT_IMAGE_FORMAT       = png
-DOT_PATH               = 
-DOTFILE_DIRS           = 
-MAX_DOT_GRAPH_WIDTH    = 1024
-MAX_DOT_GRAPH_HEIGHT   = 1024
-MAX_DOT_GRAPH_DEPTH    = 1000
-DOT_TRANSPARENT        = NO
-DOT_MULTI_TARGETS      = NO
-GENERATE_LEGEND        = YES
-DOT_CLEANUP            = YES
-#---------------------------------------------------------------------------
-# Configuration::additions related to the search engine   
-#---------------------------------------------------------------------------
-SEARCHENGINE           = NO
Index: CENSE
===================================================================
--- LICENSE	(revision 143)
+++ 	(revision )
@@ -1,33 +1,0 @@
-gLEMON code without an explicit copyright is covered by the following
-copyright/license:
-
-Copyright (C) 2003-2006 Egervary Jeno Kombinatorikus Optimalizalasi
-Kutatocsoport (Egervary Combinatorial Optimization Research Group,
-EGRES).
-
-Permission is hereby granted, free of charge, to any person or organization
-obtaining a copy of the software and accompanying documentation covered by
-this license (the "Software") to use, reproduce, display, distribute,
-execute, and transmit the Software, and to prepare derivative works of the
-Software, and to permit third-parties to whom the Software is furnished to
-do so, all subject to the following:
-
-The copyright notices in the Software and this entire statement, including
-the above license grant, this restriction and the following disclaimer,
-must be included in all copies of the Software, in whole or in part, and
-all derivative works of the Software, unless such copies or derivative
-works are solely in the form of machine-executable object code generated by
-a source language processor.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
-SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
-FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
-ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
-
-===========================================================================
-This license is a verbatim copy of the Boost Software License, Version 1.0.
-
-
Index: Makefile.am
===================================================================
--- Makefile.am	(revision 186)
+++ Makefile.am	(revision 0)
@@ -1,151 +1,1 @@
-AM_CPPFLAGS = -I$(top_srcdir) -DLOCALEDIR=\""$(datadir)/locale"\"
-
-SUBDIRS = po m4
-
-bin_PROGRAMS = glemon
-BUILT_SOURCES = guipixbufs.h
-CLEANFILES = guipixbufs.h
-
-glemon_SOURCES = \
-	all_include.h \
-	algobox.cc \
-	algobox.h \
-	algowin.cc \
-	algowin.h \
-	gdc-broken_edge.cc \
-	graph_displayer_canvas.cc \
-	graph_displayer_canvas.h \
-	graph_displayer_canvas-edge.cc \
-	graph_displayer_canvas-event.cc \
-	graph_displayer_canvas-node.cc \
-	graph_displayer_canvas-zoom.cc \
-	graph-displayer.cc \
-	kruskalbox.cc \
-	kruskalbox.h \
-	main_win.cc \
-	main_win.h \
-	mapstorage.cc \
-	mapstorage.h \
-	map_win.cc \
-	map_win.h \
-	mapselector.cc \
-	mapselector.h \
-	nbtab.h \
-	nbtab.cc \
-	new_map_win.cc \
-	new_map_win.h \
-	xymap.h \
-	gui_reader.h \
-	gui_reader.cc \
-	gui_writer.h \
-	gui_writer.cc \
-	xml.h \
-	guipixbufs.h \
-	i18n.h \
-	gettext.h \
-	design_win.h \
-	design_win.cc \
-	dijkstrabox.h \
-	dijkstrabox.cc \
-	background_chooser_dialog.h \
-	background_chooser_dialog.cc
-
-glemon_CXXFLAGS = $(GTK_CFLAGS) $(LEMON_CFLAGS)
-# glemon_LDFLAGS = $(GTK_LIBS) $(LEMON_LIBS)
-glemon_LDADD = $(GTK_LIBS) $(LEMON_LIBS) $(LIBINTL)
-
-IMAGES = \
-	icons/addlink.png \
-	icons/addnode.png \
-	icons/delete.png \
-	icons/editlink.png \
-	icons/editnode.png \
-	icons/move.png \
-	icons/newmap.png
-
-VARIABLES = \
-	gui_icons_addlink $(srcdir)/icons/addlink.png \
-	gui_icons_addnode $(srcdir)/icons/addnode.png \
-	gui_icons_delete $(srcdir)/icons/delete.png \
-	gui_icons_editlink $(srcdir)/icons/editlink.png \
-	gui_icons_editnode $(srcdir)/icons/editnode.png \
-	gui_icons_move $(srcdir)/icons/move.png \
-	gui_icons_newmap $(srcdir)/icons/newmap.png
-
-guipixbufs.h: $(IMAGES)
-	gdk-pixbuf-csource \
-	--raw --build-list $(VARIABLES) > guipixbufs.h ||  \
-	( rm -f guipixbufs.h && false )
-
-EXTRA_DIST = \
-	$(IMAGES) \
-	guipixbufs.h \
-	glemon.spec \
-	AUTHORS \
-	COPYING \
-	LICENSE \
-	NEWS \
-	README \
-	ABOUT-NLS
-
-MRPROPERFILES = \
-	Makefile.in \
-	configure \
-	config.h.in \
-	aclocal.m4 \
-	ABOUT-NLS \
-	m4/Makefile.in \
-	m4/lib-link.m4 \
-	m4/printf-posix.m4 \
-	m4/uintmax_t.m4 \
-	m4/signed.m4 \
-	m4/iconv.m4 \
-	m4/inttypes.m4 \
-	m4/longlong.m4 \
-	m4/glibc21.m4 \
-	m4/inttypes_h.m4 \
-	m4/codeset.m4 \
-	m4/longdouble.m4 \
-	m4/nls.m4 \
-	m4/intmax.m4 \
-	m4/lib-prefix.m4 \
-	m4/glibc2.m4 \
-	m4/xsize.m4 \
-	m4/lcmessage.m4 \
-	m4/lib-ld.m4 \
-	m4/ulonglong.m4 \
-	m4/wint_t.m4 \
-	m4/progtest.m4 \
-	m4/inttypes-pri.m4 \
-	m4/stdint_h.m4 \
-	m4/intdiv0.m4 \
-	m4/isc-posix.m4 \
-	m4/po.m4 \
-	m4/size_max.m4 \
-	m4/gettext.m4 \
-	m4/wchar_t.m4 \
-	po/Rules-quot \
-	po/en@quot.header \
-	po/insert-header.sin \
-	po/quot.sed \
-	po/en@boldquot.header \
-	po/boldquot.sed \
-	po/Makevars.template \
-	po/remove-potcdate.sin \
-	po/Makefile.in.in \
-	build-aux/mkinstalldirs \
-	build-aux/config.rpath \
-	build-aux/depcomp \
-	build-aux/missing \
-	build-aux/config.guess \
-	build-aux/config.sub \
-	build-aux/install-sh
-
-mrproper:
-	$(MAKE) $(AM_MAKEFLAGS) maintainer-clean
-	-rm -f $(MRPROPERFILES)
-
-rpm: dist
-	rpmbuild -ta $(PACKAGE)-$(VERSION).tar.gz
-
-.PHONY: mrproper
+SUBDIRS = src
Index: WS
===================================================================
--- NEWS	(revision 164)
+++ 	(revision )
@@ -1,1 +1,0 @@
-To be filled
Index: ADME
===================================================================
--- README	(revision 164)
+++ 	(revision )
@@ -1,1 +1,0 @@
-To be filled
Index: gobox.cc
===================================================================
--- algobox.cc	(revision 174)
+++ 	(revision )
@@ -1,205 +1,0 @@
-/* -*- 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.
- *
- */
-
-#include <algobox.h>
-
-enum {N_DEMO1, N_DEMO2, NODE_INPUT_NUM}; // input IDs for nodes;
-enum {E_DEMO1, EDGE_INPUT_NUM}; // input IDs for edges;
-
-AlgoBox::AlgoBox(std::vector<std::string> tabnames)
-{
-  init(tabnames);
-}
-
-void AlgoBox::init(std::vector<std::string> tabnames)
-{
-  set_spacing(5);
-
-  update_tablist(tabnames);
-
-  //if active tab is changed, the map names in cbt/s have to be updated
-  tabcbt.signal_changed().connect(sigc::mem_fun(*this, &AlgoBox::emit_tab_change));
-
-  pack_start(tabcbt);
-  build_box();
-
-  show_all_children();
-};
-
-void AlgoBox::update_cbt(std::vector< std::string > stringlist, Gtk::ComboBoxText & cbt)
-{
-  std::string actname=cbt.get_active_text();
-  int prev_act=-1;
-
-  cbt.clear();
-  int actptr=0;
-
-  std::vector< std::string >::iterator emsi=stringlist.begin();
-  for(;emsi!=stringlist.end();emsi++)
-    {
-      if(actname==*emsi)
-	{
-	  prev_act=actptr;
-	}
-
-      cbt.append_text(*emsi);
-      actptr++;
-    }
-
-  if(prev_act!=-1)
-    {
-      cbt.set_active(prev_act);
-    }
-  else if(actptr>0) //so there is item in the list
-    {
-      //cbt.set_active(0);
-    }
-}
-
-void AlgoBox::update_tablist( std::vector< std::string > tl )
-{
-  update_cbt(tl, tabcbt);
-  emit_tab_change();
-}
-
-void AlgoBox::update_maplist(MapStorage * ms)
-{
-  mapstorage=ms;
-  std::vector<std::string> nml;
-  std::vector<std::string> eml;
-  if(mapstorage!=NULL)
-    {
-      mapstorage->signal_node_map_ch().connect(sigc::mem_fun(*this, &AlgoBox::nodemaplist_changed));
-      mapstorage->signal_edge_map_ch().connect(sigc::mem_fun(*this, &AlgoBox::edgemaplist_changed));
-      nml=mapstorage->getNodeMapList();
-      eml=mapstorage->getEdgeMapList();
-    }
-  for(int i=0;i<(int)nodemapcbts.size();i++)
-    {
-      (nodemapcbts[i])->update_list(nml);
-      //update_cbt(nml, *(nodemapcbts[i]));
-    }
-  for(int i=0;i<(int)edgemapcbts.size();i++)
-    {
-      (edgemapcbts[i])->update_list(eml);
-      //update_cbt(eml, *(edgemapcbts[i]));
-    }
-  signal_maplist_updated.emit();
-}
-
-void AlgoBox::nodemaplist_changed(std::string newmap)
-{
-  for(int i=0;i<(int)nodemapcbts.size();i++)
-    {
-      (nodemapcbts[i])->append_text(newmap);
-    }
-}
-
-void AlgoBox::edgemaplist_changed(std::string newmap)
-{
-  for(int i=0;i<(int)edgemapcbts.size();i++)
-    {
-      (edgemapcbts[i])->append_text(newmap);
-    }
-}
-
-void AlgoBox::run()
-{
-  std::cout << "Start algorithm." << std::endl;
-}
-
-void AlgoBox::build_box()
-{
-  pack_start(*(new Gtk::HSeparator()));
-
-  Gtk::Label * label=new Gtk::Label("Specific part for each algorithm.");
-      
-  pack_start(*label);
-  pack_start(*(new Gtk::HSeparator()));
-
-  label=new Gtk::Label("Maps in chosen tab:");
-      
-  pack_start(*label);
-
-  for(int i=0;i<NODE_INPUT_NUM;i++)
-    {
-      std::ostringstream o;
-      o << "NodeInput " << i+1 << ":";
-
-      addMapSelector(o.str(), false);
-    }
-
-  pack_start(*(new Gtk::HSeparator()));
-
-  for(int i=0;i<EDGE_INPUT_NUM;i++)
-    {
-
-      std::ostringstream o;
-      o << "EdgeInput " << i+1 << ":";
-
-      addMapSelector(o.str(), true);
-    }
-
-  pack_start(*(new Gtk::HSeparator()));
-}
-
-void AlgoBox::addMapSelector(std::string inputname, bool itisedge)
-{
-  std::vector<std::string> empty_vector;
-
-  MapSelector * msp=new MapSelector(empty_vector,"",inputname,itisedge, false);
-
-  if(itisedge)
-    {
-      edgemapcbts.resize(edgemapcbts.size()+1);
-      edgemapcbts[edgemapcbts.size()-1]=msp;
-    }
-  else
-    {
-      nodemapcbts.resize(nodemapcbts.size()+1);
-      nodemapcbts[nodemapcbts.size()-1]=msp;
-    }
-
-  msp->signal_newmapwin_needed().connect(sigc::mem_fun(*this, &AlgoBox::emit_new_map_signal));
-
-  pack_start(*msp);
-}
-
-sigc::signal<void, std::string> AlgoBox::signal_maplist_needed()
-{
-  return signal_maplist_need;
-}
-
-void AlgoBox::emit_tab_change()
-{
-  std::string active_tab=tabcbt.get_active_text();
-  if(active_tab!="")
-    {
-      signal_maplist_need.emit(active_tab);
-    }
-  else
-    {
-      std::vector<std::string> empty_vector;
-      update_maplist(NULL);
-    }
-}
-
-void AlgoBox::emit_new_map_signal(bool itisedge)
-{
-  signal_newmapwin_need.emit(tabcbt.get_active_text(), itisedge);
-}
Index: gobox.h
===================================================================
--- algobox.h	(revision 174)
+++ 	(revision )
@@ -1,189 +1,0 @@
-/* -*- 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 ALGOBOX_H
-#define ALGOBOX_H
-
-class AlgoBox;
-
-#include <all_include.h>
-#include <mapstorage.h>
-#include <mapselector.h>
-#include <libgnomecanvasmm.h>
-#include <libgnomecanvasmm/polygon.h>
-
-///Ancestor class of algorithm graphical interface classes.
-
-///It also demonstrates, how should an algorithm graphical interface
-///work. Children of this class have the same functions and attributes,
-///therefore with all of them can the holder \ref AlgoWin communicate
-///in the same way.
-///
-///IMPORTANT! In a child class only the following tasks are to do:
-///
-///-call \ref init function with correct parameters from correctly parametrized constructor
-///
-///-implement \ref build_box function
-///
-///-implement \ref run function
-///
-///because all other thing is automatically done in \ref init function!
-
-class AlgoBox : public Gtk::VBox
-{
-  ///Signal emitted in case of need for list of maps.
-
-  ///If the user has selected different tab to work on
-  ///new maps are selected as well. These new maps should be
-  ///provided for \ref AlgoBox. To get these maps, \ref AlgoBox
-  ///emits this signal.
-  sigc::signal<void, std::string> signal_maplist_need;
-
-  ///Signal emitted in case of need for \ref NewMapWin.
-
-  ///If user wants to create a new for an input, or output
-  ///it can let \ref NewMapWin popped up from here as well.
-  ///In that case will be this signal emitted.
-  sigc::signal<void, std::string, bool> signal_newmapwin_need;
-
-  ///Signal emitted when maplists are updated after tab change
-  sigc::signal<void> signal_maplist_updated;
-
-
-protected:
-  ///Holder of tabnames.
-  Gtk::ComboBoxText tabcbt;
-
-  ///Holder of widgets, in which nodemaps can be selected to work on.
-  std::vector<MapSelector *> nodemapcbts;
-
-  ///Holder of widgets, in which edgemaps can be selected to work on.
-  std::vector<MapSelector *> edgemapcbts;
-
-  ///Maps of selected tabs.
-  MapStorage * mapstorage;
-
-public:
-  ///Empty constructor called by children.
-  AlgoBox(){};
-
-  ///Constructor
-
-  ///Calls \ref init function
-  ///with the provided parameters. \ref init function
-  ///is needed, because it is virtual, therefore the
-  ///functions of the proper class will be called when
-  ///running.
-  ///\param tablist list of tabs in \ref MainWin
-  AlgoBox(std::vector<std::string> tablist);
-
-  ///Initiates \ref AlgoBox.
-
-  ///Creates the graphical interface for the realized algorithm, initiates variables, connects signals.
-  ///
-  ///List of tabs in \ref MainWin is required, but no one
-  ///will be selected automatically. Every other
-  ///entry field remains empty (unselected), until a \ref NoteBookTab
-  ///is selected.
-  ///
-  ///It also have to bind all the signals to the correct place.
-  ///This function is virtual, in all type of children of
-  ///\ref AlgoBox the correct function willbe called.
-  ///
-  ///Therefore it is IMPORTANT that only \ref run and \ref build_box
-  ///has to be implemented in children of \ref AlgoBox, every other
-  ///thing will automatically work properly by the help of this
-  ///function that must be called in constructor of child!!!
-  virtual void init(std::vector<std::string>);
-
-  ///Signal emitted, when selected tab changes, and new list of maps required.
-  sigc::signal<void, std::string> signal_maplist_needed();
-
-  ///Emitted if user wants to create a new map for inpuit or output.
-  sigc::signal<void, std::string, bool> signal_newmapwin_needed(){return signal_newmapwin_need;};
-
-  sigc::signal<void> signal_upon_maplist_updated(){return signal_maplist_updated;};
-
-  ///Emits signal that requires list of maps for the recently selected \ref NoteBookTab.
-  void emit_tab_change();
-
-  ///Interface, through which \ref AlgoBox can be notified about tab addition, deletion in \ref MainWin
-
-  ///\param tl list
-  ///of new tab state.
-  void update_tablist( std::vector< std::string > tl );
-
-  ///Interface, through which \ref AlgoBox can get the maps of the recently selected \ref NoteBookTab
-
-  ///\param ms the maps
-  ///of the recently selected \ref NoteBookTab
-  void update_maplist( MapStorage * ms);
-
-  ///Interface, through which \ref AlgoBox can be notified about nodemap addition.
-
-  ///If new map was added to \ref MapStorage of currently selected \ref NoteBookTab
-  ///a signal is emitted by it. This signal is connected to this function, so \ref MapSelector s
-  ///in \ref nodemapcbts can be notified, and those can registrate the new map. (\ref MapSelector::append_text)
-  void nodemaplist_changed(std::string);
-
-  ///Interface, through which \ref AlgoBox can be notified about edgemap addition.
-
-  ///If new map was added to \ref MapStorage of currently selected \ref NoteBookTab
-  ///a signal is emitted by it. This signal is connected to this function, so \ref MapSelector s
-  ///in \ref edgemapcbts can be notified, and those can registrate the new map. (\ref MapSelector::append_text)
-  void edgemaplist_changed(std::string);
-
-  ///Aid function to provide data for a given entry.
-
-  ///At the moment it is only used for updating info
-  ///in \ref tabcbt. It clears it first, after that
-  ///inserts the data got from caller, and if there
-  ///was previously selected item it switches entry
-  ///to that.
-  ///\param tl list of entries (at the moment tabs in \ref MainWin)
-  ///\param cbt the entry to update (at the moment only \ref tabcbt)
-  void update_cbt( std::vector< std::string > tl, Gtk::ComboBoxText & cbt);
-
-  ///Runs the ralized algorithm.
-
-  ///Prepare the data for it
-  ///and after that postprocess it if necessary.
-  ///This is only a demo here, but in children it
-  ///runs the algorithm really.
-  virtual void run();
-
-  ///Creates the layout of the \ref AlgoBox
-
-  ///Place all the entries
-  ///required. Run and close button is not
-  ///its responsibility!
-  virtual void build_box();
-
-  ///Emits \ref signal_newmapwin_need if user wants to create new input or output map.
-
-  ///Called in case of pressing \ref MapSelector::newbut.
-  ///\param itisedge edge or nodemap is required.
-  virtual void emit_new_map_signal(bool itisedge);
-
-  ///Aid function to make addition of \ref MapSelector easy in \ref build_box.
-
-  ///\param label label to show in \ref MapSelector
-  ///\param itisedge whether edge or nodemaps stored in \ref MapSelector
-  void addMapSelector(std::string label, bool itisedge);
-};
-#endif //ALGOBOX_H
Index: gowin.cc
===================================================================
--- algowin.cc	(revision 174)
+++ 	(revision )
@@ -1,116 +1,0 @@
-/* -*- 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.
- *
- */
-
-#include <algowin.h>
-#include <kruskalbox.h>
-#include <dijkstrabox.h>
-
-sigc::signal<void, AlgoWin *> AlgoWin::signal_closing()
-{
-  return signal_closed;
-}
-
-sigc::signal<void, AlgoWin *, std::string> AlgoWin::signal_maplist_needed()
-{
-  return signal_maplist_need;
-}
-
-bool AlgoWin::closeIfEscapeIsPressed(GdkEventKey* e)
-{
-  if(e->keyval==GDK_Escape)
-  {
-    on_hide();
-  }
-  return true;
-}
-
-AlgoWin::AlgoWin(int algoid, std::vector<std::string> tabnames)
-{
-  signal_key_press_event().connect(sigc::mem_fun(*this, &AlgoWin::closeIfEscapeIsPressed));
-
-  Gtk::VBox * vbox=new Gtk::VBox();
-  vbox->set_spacing(5);
-
-  Gtk::Label * label=new Gtk::Label("Select graph:");
-
-  switch(algoid)
-    {
-    case 0:
-      ab=new AlgoBox(tabnames);
-      set_title("Algo Win Demo");
-      break;
-    case 1:
-      ab=new KruskalBox(tabnames);
-      set_title("Kruskal Algorithm");
-      break;
-    case 2:
-      ab=new DijkstraBox(tabnames);
-      set_title("Dijkstra Algorithm");
-      break;
-    case 3:
-      ab=new SuurballeBox(tabnames);
-      set_title("Suurballe Algorithm");
-      break;
-    default:
-      break;
-    }
-  ab->signal_maplist_needed().connect(sigc::mem_fun(*this, &AlgoWin::emit_tab_change));
-  ab->signal_newmapwin_needed().connect(sigc::mem_fun(*this, &AlgoWin::emit_new_map_signal));
-
-  runbutton=new Gtk::Button("Run");
-  runbutton->signal_released().connect(sigc::mem_fun(*ab,&AlgoBox::run));
-  runbutton->signal_activate().connect(sigc::mem_fun(*ab,&AlgoBox::run));
-
-  closebutton=new Gtk::Button("Close");
-  closebutton->signal_released().connect(sigc::mem_fun(*this,&AlgoWin::on_hide));
-  closebutton->signal_activate().connect(sigc::mem_fun(*this,&AlgoWin::on_hide));
-      
-  Gtk::HBox * hbox=new Gtk::HBox();
-
-  hbox->pack_start(*runbutton);
-  hbox->pack_start(*closebutton);
-
-  vbox->pack_start(*label);
-  vbox->pack_start(*ab);
-  vbox->pack_start(*hbox);
-      
-  add(*vbox);
-
-  show_all_children();
-};
-
-void AlgoWin::update_tablist(std::vector<std::string> tabnames)
-{
-  ab->update_tablist(tabnames);
-}
-
-void AlgoWin::update_maplist(MapStorage * mapstorage)
-{
-  ab->update_maplist(mapstorage);
-}
-
-void AlgoWin::on_hide()
-{
-  signal_closed.emit(this);
-  Gtk::Window::on_hide();
-}
-
-void AlgoWin::emit_tab_change(std::string newtab)
-{
-  signal_maplist_need.emit(this, newtab);
-}
Index: gowin.h
===================================================================
--- algowin.h	(revision 174)
+++ 	(revision )
@@ -1,150 +1,0 @@
-/* -*- 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 ALGOWIN_H
-#define ALGOWIN_H
-
-class AlgoWin;
-
-#include <all_include.h>
-//#include <mapstorage.h>
-#include <algobox.h>
-#include <libgnomecanvasmm.h>
-#include <libgnomecanvasmm/polygon.h>
-
-class MapStorage;
-
-///Algorithm identifiers.
-enum {GENERAL, KRUSKAL, ALGO_NUM}; // algorithm IDs;
-
-///Window displaying graphical interface for different algorithms.
-
-///This class displays a graphical interface to set up
-///and run different algorithms. Different algorithms need
-///different inputs, running methods, etc. Therefore
-///class \ref AlgoWin is only a holder of a base class, the so
-///called AlgoBox. \ref AlgoBox is the ancestor of other
-///classes. These child classes realize interfaces of different
-///algorithms, but as their common ancestor is \ref AlgoBox
-///the interface of them is the same. \ref AlgoWin communicates
-///with these classes through this common interface. But it the
-///real object to be placed in \ref AlgoWin depends on the algorithm
-///which the \ref AlgoWin actually has to display. It gets the
-///id of algorithm to display at initialization, and therefore it is
-///able to place in itself the requested child of \ref AlgoBox
-/// visualizing the appropriate algorithm.
-class AlgoWin : public Gtk::Window
-{
-private:
-  ///Algorithm specific part of \ref AlgoWin
-  AlgoBox * ab;
-
-  ///Run button.
-
-  ///If pressed, algorithm should run.
-  ///That is why common ancestor of different
-  ///algorithm realizer classes have to be. In case of
-  ///pressing run button a common method can be called.
-  Gtk::Button * runbutton;
-
-  ///Close button. If pressed, \ref AlgoWin should close.
-  Gtk::Button * closebutton;
-
-protected:
-  ///Signal emitted upon close of window
-
-  ///It is necessary, because \ref MainWin have to
-  ///score the opened \ref AlgoWin s, to be able to communicate
-  ///with them: let them know about changement in tabs, maps, etc.
-  ///If \ref AlgoWin is closed, \ref MainWin has to deregistrate it.
-  ///Therefore signal contains address of emitter \ref AlgoWin.
-  sigc::signal<void, AlgoWin *> signal_closed;
-
-  ///Signal indicating that informatino on certain maplist is required.
-
-  ///It is just a forwarded signal from \ref AlgoBox, benefit of common ancestor
-  ///algorithm class. User can select the graph (the holder \ref NoteBookTab) on
-  ///which the algorithm should run. But different graphs (\ref NoteBookTab) have
-  ///different maps. If selected tab changes this signal is emitted by \ref AlgoBox,
-  ///caught and reemitted by \ref AlgoWin.
-  ///
-  ///Signal contains the address of \ref AlgoWin to let \ref MainWin know
-  ///where should the information needed forwarded, and the name of
-  ///\ref NoteBookTab, of which maps are inquired.
-  sigc::signal<void, AlgoWin *, std::string> signal_maplist_need;
-
-  ///Signal that indicates that a \ref NewMapWin should be popped up.
-
-  ///This is a forwarded signal. If \ref AlgoBox emits a signal
-  ///to let a \ref NewMapWin pop up, |ref AlgoWin catch and reemit it.
-  ///
-  ///Signal contains the name of \ref NoteBookTab, in which the new map
-  ///should be created and a boolean that indicates whether an edge or a
-  ///nodemap should be created.
-  sigc::signal<void, std::string, bool> signal_newmapwin_need;
-
-public:
-  ///Close window if escape key is pressed.
-  bool closeIfEscapeIsPressed(GdkEventKey* e);
-
-  ///Returns \ref signal_closed to be bindable somewhere.
-  sigc::signal<void, AlgoWin *> signal_closing();
-
-  ///Returns \ref signal_maplist_need to be bindable somewhere.
-  sigc::signal<void, AlgoWin *, std::string> signal_maplist_needed();
-
-  ///Returns \ref signal_newmapwin_need to be bindable somewhere.
-  sigc::signal<void, std::string, bool> signal_newmapwin_needed(){return signal_newmapwin_need;};
-
-  ///Forwards signal emitted by \ref AlgoBox, in which it indicates changement in selection of tabs.
-  void emit_tab_change(std::string);
-
-  ///Forwards signal emitted by \ref AlgoBox, in which it indicates need for \ref NewMapWin.
-  void emit_new_map_signal(std::string tabname, bool itisedge){signal_newmapwin_need.emit(tabname, itisedge);};
-
-  ///Constructor
-
-  ///It builds the window according to the information provided
-  ///by the creator. It needs the identifier of the algorithm
-  ///to visualize, and a list of name of \ref NoteBookTab s that can
-  ///be found in \ref MainWin.
-  ///\param algoid identifier of algorithm to show
-  ///\param tablist list of tabs in \ref MainWin
-  AlgoWin(int algoid, std::vector<std::string> tablist);
-
-  ///Forwards list of \ref NoteBookTabs toward \ref AlgoBox
-
-  ///In case of changement in tabs in \ref MainWin
-  ///\ref MainWin automatically updates tablist in
-  ///\ref AlgoWin s.
-  void update_tablist(std::vector<std::string> tabnames);
-
-  ///Forwards list of requested maps toward \ref AlgoBox
-
-  ///Upon catching the signal in which \ref AlgoBox requests
-  ///list of maps \ref MainWin responds
-  ///through this function.
-  void update_maplist(MapStorage *);
-
-  ///Called when window is closing.
-
-  ///\ref AlgoWin has to be deregistrated in \ref MainWin
-  ///thereforeit emits signal \ref signal_closed.
-  void on_hide();
-};
-#endif //ALGOWIN_H
Index: l_include.h
===================================================================
--- all_include.h	(revision 174)
+++ 	(revision )
@@ -1,67 +1,0 @@
-/* -*- 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 ALL_INCLUDE_H
-#define ALL_INCLUDE_H
-
-#include <fstream>
-#include <iostream>
-
-#include <vector>
-
-#include <lemon/list_graph.h>
-#include <lemon/graph_reader.h>
-#include <lemon/graph_writer.h>
-#include <lemon/graph_utils.h>
-#include <lemon/maps.h>
-#include <lemon/error.h>
-#include <lemon/dim2.h>
-
-enum {E_WIDTH, E_COLOR, E_TEXT, EDGE_PROPERTY_NUM}; // edge properties;
-enum {N_RADIUS, N_COLOR, N_TEXT, NODE_PROPERTY_NUM}; // node properties;
-enum {MOVE, CREATE_NODE, CREATE_EDGE, ERASER, MAP_EDIT, TOOL_NUM}; // tools;
-#define RANGE 3
-#define WIN_WIDTH 900
-#define WIN_HEIGHT 600
-#define MIN_EDGE_WIDTH 2
-#define MAX_EDGE_WIDTH 40
-#define MIN_NODE_RADIUS 2
-#define MAX_NODE_RADIUS 80
-
-#ifndef MAIN_PART
-extern std::vector <std::string> edge_property_strings;
-extern std::vector <double> edge_property_defaults;
-extern std::vector <std::string> node_property_strings;
-extern std::vector <double> node_property_defaults;
-extern int longest_property_string_length;
-#endif //MAIN_PART
-
-using namespace lemon;
-
-typedef lemon::dim2::Point<double> XY;
-typedef ListGraph Graph;
-typedef Graph::Node Node;
-typedef Graph::Edge Edge;
-typedef Graph::EdgeIt EdgeIt;
-typedef Graph::InEdgeIt InEdgeIt;
-typedef Graph::OutEdgeIt OutEdgeIt;
-typedef Graph::NodeIt NodeIt;
-
-const std::string prog_name = "LEMON Graph Editor";
-
-#endif // ALL_INCLUDE_H
Index: topackage/default.apspec.in
===================================================================
--- autopackage/default.apspec.in	(revision 175)
+++ 	(revision )
@@ -1,44 +1,0 @@
-# -*-shell-script-*-
-
-[Meta]
-RootName: @lemon.cs.elte.hu/glemon:$SOFTWAREVERSION
-DisplayName: glemon
-ShortName: glemon
-Maintainer: The LEMON Developers - http://lemon.cs.elte.hu/
-Packager: Alpar Juttner <alpar@cs.elte.hu>
-Summary: Graphical graph and network editor for the LEMON Graph Format
-SoftwareVersion: @VERSION@
-AutopackageTarget: 0.7
-
-# Only uncomment InterfaceVersion if your package exposes interfaces to other software,
-# for instance if it includes DSOs or python/perl modules. See the developer guide for more info,
-# or ask on autopackage-dev if you don't understand interface versioning in autopackage.
-#
-# InterfaceVersion: 0.0
-
-PackageVersion: 1
-
-[Description]
-Graphical graph and network editor for the LEMON Graph Format
-
-[BuildPrepare]
-prepareBuild
-
-[BuildUnprepare]
-unprepareBuild
-
-[Imports]
-echo '*' | import
-
-[Prepare]
-# Dependency checking
-#require @whatever.you/need 1.0
-
-[Install]
-# Put your installation script here
-#installExe bin/*
-copyFiles * $PREFIX
-
-[Uninstall]
-# Usually just the following line is enough to uninstall everything
-uninstallFromLog
Index: ckground_chooser_dialog.cc
===================================================================
--- background_chooser_dialog.cc	(revision 184)
+++ 	(revision )
@@ -1,52 +1,0 @@
-#include "background_chooser_dialog.h"
-#include <gtkmm/stock.h>
-#include "mapstorage.h"
-
-BackgroundChooserDialog::BackgroundChooserDialog(MapStorage* ms) :
-  mapstorage(ms),
-  btnClear(Gtk::Stock::CLEAR)
-{
-  set_has_separator(false);
-
-  Gtk::VBox* pVBox = get_vbox();
-
-  lblBackground.set_text("<b>Background image file</b>");
-  lblBackground.set_use_markup();
-  lblBackground.set_alignment(Gtk::ALIGN_LEFT);
-  lblScaling.set_text("<b>Scaling factor</b>");
-  lblScaling.set_use_markup();
-  lblScaling.set_alignment(Gtk::ALIGN_LEFT);
-  fcbBackground.set_width_chars(30);
-  fcbBackground.set_action(Gtk::FILE_CHOOSER_ACTION_OPEN);
-  if (mapstorage->isBackgroundSet())
-  {
-    fcbBackground.set_filename(mapstorage->getBackgroundFilename());
-  }
-
-  fcbBackground.signal_selection_changed().connect(
-    sigc::mem_fun(*this, &BackgroundChooserDialog::setBackground));
-
-  btnClear.signal_clicked().connect(
-    sigc::mem_fun(*this, &BackgroundChooserDialog::clearBackground));
-
-  pVBox->pack_start(lblBackground, Gtk::PACK_SHRINK);
-  pVBox->pack_start(box, Gtk::PACK_SHRINK);
-  box.pack_start(fcbBackground, Gtk::PACK_EXPAND_WIDGET);
-  box.pack_start(btnClear, Gtk::PACK_SHRINK);
-  pVBox->pack_start(lblScaling, Gtk::PACK_SHRINK);
-  pVBox->pack_start(sbScaling, Gtk::PACK_SHRINK);
-
-  add_button(Gtk::Stock::CLOSE, Gtk::RESPONSE_CLOSE);
-
-  show_all_children();
-}
-
-void BackgroundChooserDialog::clearBackground()
-{
-  fcbBackground.unselect_all();
-}
-
-void BackgroundChooserDialog::setBackground()
-{
-  mapstorage->setBackground(fcbBackground.get_filename());
-}
Index: ckground_chooser_dialog.h
===================================================================
--- background_chooser_dialog.h	(revision 184)
+++ 	(revision )
@@ -1,27 +1,0 @@
-#ifndef BACKGROUND_CHOOSER_DIALOG
-#define BACKGROUND_CHOOSER_DIALOG
-
-#include <gtkmm/dialog.h>
-#include <gtkmm/label.h>
-#include <gtkmm/filechooserbutton.h>
-#include <gtkmm/spinbutton.h>
-
-class MapStorage;
-
-class BackgroundChooserDialog : public Gtk::Dialog
-{
-  private:
-    MapStorage* mapstorage;
-    Gtk::Label lblBackground;
-    Gtk::Label lblScaling;
-    Gtk::FileChooserButton fcbBackground;
-    Gtk::SpinButton sbScaling;
-    Gtk::HBox box;
-    Gtk::Button btnClear;
-    void clearBackground();
-    void setBackground();
-  public:
-    BackgroundChooserDialog(MapStorage* ms);
-};
-
-#endif
Index: otstrap
===================================================================
--- bootstrap	(revision 139)
+++ 	(revision )
@@ -1,85 +1,0 @@
-#!/bin/bash
-
-quiet=0
-function quiet { [[ $quiet == 1 ]]; }
-
-if [[ "$1" == "-q" ]]; then
-  quiet=1
-  shift
-fi
-
-prev=
-for option
-do
-  if test -n "$prev"
-  then
-    eval "$prev=\$option"
-    prev=
-    continue
-  fi
-
-  optarg=`expr "x$option" : 'x[^=]*=\(.*\)'`
-
-  case $option in
-
-  -amver | --amver)
-    prev=amver ;;
-  -amver=* | --amver=*)
-    amver=$optarg ;;
-
-  -acver | --acver)
-    prev=acver ;;
-  -acver=* | --acver=*)
-    acver=$optarg ;;
-
-  --help | -h)
-    cat << EOF
-Usage: $0 [OPTION]
-
-Options:
-  -h, --help            display this help and exit
-      --amver=VERSION   use VERSION version of automake
-      --acver=VERSION   use VERSION version of autoconf
-
-Expamle:
-  $0 --amver=1.8 --acver=2.59
-EOF
-    exit 0
-    ;;
-
-  *)
-    cat << EOF >&2
-$0: unrecognized option: $option
-Try \`$0 --help' for more information.
-EOF
-    exit 1
-    ;;
-
-  esac
-done
-
-automake=automake
-aclocal=aclocal
-autoconf=autoconf
-autoheader=autoheader
-
-if test -n "$amver"
-then
-  automake=automake-$amver
-  aclocal=aclocal-$amver
-fi
-
-if test -n "$acver"
-then
-  autoconf=autoconf-$acver
-  autoheader=autoheader-$acver
-fi
-
-set -e
-quiet || set -x
-
-autopoint
-$aclocal -I m4
-$autoconf
-$autoheader
-$automake --add-missing --copy --gnu
Index: lor.lgf
===================================================================
--- color.lgf	(revision 179)
+++ 	(revision )
@@ -1,368 +1,0 @@
-@nodeset 
-coordinates_x	coordinates_y	label	
--357	-128	1	
--298	-135	2	
--229	-140	3	
--160	-146	4	
--84	-149	5	
--3	-155	6	
-76	-155	7	
-155	-151	8	
-229	-138	9	
-298	-113	10	
-362	-88	11	
-433	-53	12	
-447	3	13	
-416	59	14	
-338	69	15	
-281	31	16	
-217	6	17	
-143	-1	18	
-69	-1	19	
--7	3	20	
--73	3	21	
--137	-3	22	
--193	-26	23	
--255	-30	24	
--303	-2	25	
--348	37	26	
--355	92	27	
--335	145	28	
--299	181	29	
--229	186	30	
--164	154	31	
--104	126	32	
--46	134	33	
-0	169	34	
-47	197	35	
-100	195	36	
-141	161	37	
-195	134	38	
-256	146	39	
-314	182	40	
-370	207	41	
-431	244	42	
-@edgeset 
-		label	
-42	41	1	
-41	40	2	
-40	39	3	
-39	38	4	
-38	37	5	
-37	36	6	
-36	35	7	
-35	34	8	
-34	33	9	
-33	32	10	
-32	31	11	
-31	30	12	
-30	29	13	
-29	28	14	
-28	27	15	
-27	26	16	
-26	25	17	
-25	24	18	
-24	23	19	
-23	22	20	
-22	21	21	
-21	20	22	
-20	19	23	
-19	18	24	
-18	17	25	
-17	16	26	
-16	15	27	
-15	14	28	
-14	13	29	
-13	12	30	
-12	11	31	
-11	10	32	
-10	9	33	
-9	8	34	
-8	7	35	
-7	6	36	
-6	5	37	
-5	4	38	
-4	3	39	
-3	2	40	
-2	1	41	
-@gui
-<arrow_pos>
- <item>
-  <first>1</first>
-  <second>
-   <x>400.5</x><y>225.5</y>
-  </second>
- </item>
- <item>
-  <first>2</first>
-  <second>
-   <x>342</x><y>194.5</y>
-  </second>
- </item>
- <item>
-  <first>3</first>
-  <second>
-   <x>285</x><y>164</y>
-  </second>
- </item>
- <item>
-  <first>4</first>
-  <second>
-   <x>225.5</x><y>140</y>
-  </second>
- </item>
- <item>
-  <first>5</first>
-  <second>
-   <x>168</x><y>147.5</y>
-  </second>
- </item>
- <item>
-  <first>6</first>
-  <second>
-   <x>120.5</x><y>178</y>
-  </second>
- </item>
- <item>
-  <first>7</first>
-  <second>
-   <x>73.5</x><y>196</y>
-  </second>
- </item>
- <item>
-  <first>8</first>
-  <second>
-   <x>23.5</x><y>183</y>
-  </second>
- </item>
- <item>
-  <first>9</first>
-  <second>
-   <x>-23</x><y>151.5</y>
-  </second>
- </item>
- <item>
-  <first>10</first>
-  <second>
-   <x>-75</x><y>130</y>
-  </second>
- </item>
- <item>
-  <first>11</first>
-  <second>
-   <x>-134</x><y>140</y>
-  </second>
- </item>
- <item>
-  <first>12</first>
-  <second>
-   <x>-196.5</x><y>170</y>
-  </second>
- </item>
- <item>
-  <first>13</first>
-  <second>
-   <x>-264</x><y>183.5</y>
-  </second>
- </item>
- <item>
-  <first>14</first>
-  <second>
-   <x>-317</x><y>163</y>
-  </second>
- </item>
- <item>
-  <first>15</first>
-  <second>
-   <x>-345</x><y>118.5</y>
-  </second>
- </item>
- <item>
-  <first>16</first>
-  <second>
-   <x>-351.5</x><y>64.5</y>
-  </second>
- </item>
- <item>
-  <first>17</first>
-  <second>
-   <x>-325.5</x><y>17.5</y>
-  </second>
- </item>
- <item>
-  <first>18</first>
-  <second>
-   <x>-279</x><y>-16</y>
-  </second>
- </item>
- <item>
-  <first>19</first>
-  <second>
-   <x>-224</x><y>-28</y>
-  </second>
- </item>
- <item>
-  <first>20</first>
-  <second>
-   <x>-165</x><y>-14.5</y>
-  </second>
- </item>
- <item>
-  <first>21</first>
-  <second>
-   <x>-105</x><y>0</y>
-  </second>
- </item>
- <item>
-  <first>22</first>
-  <second>
-   <x>-40</x><y>3</y>
-  </second>
- </item>
- <item>
-  <first>23</first>
-  <second>
-   <x>31</x><y>1</y>
-  </second>
- </item>
- <item>
-  <first>24</first>
-  <second>
-   <x>106</x><y>-1</y>
-  </second>
- </item>
- <item>
-  <first>25</first>
-  <second>
-   <x>180</x><y>2.5</y>
-  </second>
- </item>
- <item>
-  <first>26</first>
-  <second>
-   <x>249</x><y>18.5</y>
-  </second>
- </item>
- <item>
-  <first>27</first>
-  <second>
-   <x>309.5</x><y>50</y>
-  </second>
- </item>
- <item>
-  <first>28</first>
-  <second>
-   <x>377</x><y>64</y>
-  </second>
- </item>
- <item>
-  <first>29</first>
-  <second>
-   <x>431.5</x><y>31</y>
-  </second>
- </item>
- <item>
-  <first>30</first>
-  <second>
-   <x>440</x><y>-25</y>
-  </second>
- </item>
- <item>
-  <first>31</first>
-  <second>
-   <x>397.5</x><y>-70.5</y>
-  </second>
- </item>
- <item>
-  <first>32</first>
-  <second>
-   <x>330</x><y>-100.5</y>
-  </second>
- </item>
- <item>
-  <first>33</first>
-  <second>
-   <x>263.5</x><y>-125.5</y>
-  </second>
- </item>
- <item>
-  <first>34</first>
-  <second>
-   <x>192</x><y>-144.5</y>
-  </second>
- </item>
- <item>
-  <first>35</first>
-  <second>
-   <x>115.5</x><y>-153</y>
-  </second>
- </item>
- <item>
-  <first>36</first>
-  <second>
-   <x>36.5</x><y>-155</y>
-  </second>
- </item>
- <item>
-  <first>37</first>
-  <second>
-   <x>-43.5</x><y>-152</y>
-  </second>
- </item>
- <item>
-  <first>38</first>
-  <second>
-   <x>-122</x><y>-147.5</y>
-  </second>
- </item>
- <item>
-  <first>39</first>
-  <second>
-   <x>-194.5</x><y>-143</y>
-  </second>
- </item>
- <item>
-  <first>40</first>
-  <second>
-   <x>-263.5</x><y>-137.5</y>
-  </second>
- </item>
- <item>
-  <first>41</first>
-  <second>
-   <x>-327.5</x><y>-131.5</y>
-  </second>
- </item>
-</arrow_pos>
-<active_nodemaps>
- <item>
-  <first>0</first>
-  <second></second>
- </item>
- <item>
-  <first>1</first>
-  <second>label</second>
- </item>
- <item>
-  <first>2</first>
-  <second></second>
- </item>
-</active_nodemaps>
-<active_edgemaps>
- <item>
-  <first>0</first>
-  <second></second>
- </item>
- <item>
-  <first>1</first>
-  <second>label</second>
- </item>
- <item>
-  <first>2</first>
-  <second></second>
- </item>
-</active_edgemaps>
-<redesign-attraction>0.05</redesign-attraction>
-<redesign-propulsation>40000</redesign-propulsation>
-<redesign-iteration>20</redesign-iteration>
-@end
Index: nfigure.ac
===================================================================
--- configure.ac	(revision 183)
+++ 	(revision )
@@ -1,96 +1,0 @@
-dnl Process this file with autoconf to produce a configure script.
-
-dnl Version information.
-m4_define([glemon_version_major], [0])
-m4_define([glemon_version_minor], [5])
-m4_define([glemon_version_micro], [90])
-m4_define([glemon_version_nano], [])
-m4_define([glemon_version_tag], [svn])
-m4_define([glemon_svn_revision], [m4_normalize(esyscmd([svn info |grep ^Revision |cut -d ' ' -f 2]))])
-m4_define([glemon_version], [glemon_version_major().glemon_version_minor()ifelse(glemon_version_micro(), [], [], [.glemon_version_micro()])ifelse(glemon_version_nano(), [], [], [.glemon_version_nano()])ifelse(glemon_version_tag(), [], [], glemon_version_tag(), [svn], [[_]glemon_version_tag()[]glemon_svn_revision()], [[_]glemon_version_tag()])])
-
-AC_PREREQ([2.59])
-AC_INIT([gLEMON], [glemon_version()], [etik-ol@cs.elte.hu], [glemon])
-AC_CONFIG_AUX_DIR([build-aux])
-AC_CONFIG_MACRO_DIR([m4])
-AM_INIT_AUTOMAKE([-Wall -Werror foreign])
-AC_CONFIG_SRCDIR([main_win.h])
-AC_CONFIG_HEADERS([config.h])
-
-dnl Checks for programs.
-AC_PROG_CXX
-AC_PROG_CC
-AM_GNU_GETTEXT_VERSION([0.14.2])
-AM_GNU_GETTEXT([external])
-
-dnl Checks for libraries.
-PKG_CHECK_MODULES([GTK], [libgnomecanvasmm-2.6 >= 2.6.0 gtkmm-2.4 >= 2.6])
-
-AC_ARG_WITH([lemon-prefix],
-AS_HELP_STRING([--with-lemon-prefix@<:@=PREFIX@:>@], [search for LEMON under PREFIX]), [], [with_lemon_prefix=no])
-if test x"$with_lemon_prefix" != x"no"; then
-  export PKG_CONFIG_PATH="$with_lemon_prefix/lib/pkgconfig/:$PKG_CONFIG_PATH"
-fi
-
-PKG_CHECK_MODULES([LEMON_0_5], [lemon >= 0.5],
-  [lemon_0_5_found=yes], [
-    AC_MSG_RESULT([no])
-    lemon_0_5_found=no])
-PKG_CHECK_MODULES([LEMON_SVNHEAD], [lemon = svnhead],
-  [lemon_svn_head_found=yes], [
-    AC_MSG_RESULT([no])
-    lemon_svn_head_found=no])
-if test x"$lemon_0_5_found" = x"no" -a x"$lemon_svn_head_found" = x"no"; then
-  AC_MSG_ERROR([LEMON not found.])
-else
-  if test x"$lemon_svn_head_found" = x"yes"; then
-    LEMON_CFLAGS="$LEMON_SVNHEAD_CFLAGS"
-    LEMON_LIBS="$LEMON_SVNHEAD_LIBS"
-  else
-    LEMON_CFLAGS="$LEMON_0_5_CFLAGS"
-    LEMON_LIBS="$LEMON_0_5_LIBS"
-  fi
-  AC_SUBST(LEMON_CFLAGS)
-  AC_SUBST(LEMON_LIBS)
-fi
-
-dnl Checks for header files.
-AC_CHECK_HEADERS([libintl.h locale.h])
-
-dnl Checks for typedefs, structures, and compiler characteristics.
-AC_HEADER_STDBOOL
-AC_C_CONST
-
-dnl Checks for library functions.
-AC_CHECK_FUNCS([setlocale sqrt])
-
-AC_CONFIG_FILES([
-Makefile
-glemon.spec
-autopackage/default.apspec
-po/Makefile.in
-m4/Makefile
-])
-
-AC_OUTPUT
-
-echo
-echo '****************************** SUMMARY ******************************'
-echo
-echo Package version............... : $PACKAGE-$VERSION
-echo
-echo C++ compiler.................. : $CXX
-echo C++ compiles flags............ : $CXXFLAGS
-echo
-echo LEMON CFLAGS.................. : $LEMON_CFLAGS
-echo LEMON LIBS.................... : $LEMON_LIBS
-echo
-echo The packace will be installed in
-echo -n '  '
-echo $prefix.
-echo
-echo '*********************************************************************'
-
-echo
-echo configure complete, now type \'make\' and then \'make install\'.
-echo
Index: sign_win.cc
===================================================================
--- design_win.cc	(revision 177)
+++ 	(revision )
@@ -1,98 +1,0 @@
-/* -*- 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.
- *
- */
-
-#include <design_win.h>
-
-bool DesignWin::closeIfEscapeIsPressed(GdkEventKey* e)
-{
-  if(e->keyval==GDK_Escape)
-  {
-    on_hide();
-  }
-  return true;
-}
-
-DesignWin::DesignWin(const std::string& title, double attraction_v, double propulsation_v, int iterations_v, NoteBookTab & mw):mytab(mw)
-{
-  set_title(title);
-
-  mytab.signal_title_ch().connect(sigc::mem_fun(*this, &DesignWin::set_title));
-
-  signal_key_press_event().connect(sigc::mem_fun(*this, &DesignWin::closeIfEscapeIsPressed));
-
-  Gtk::VBox * vbox=new Gtk::VBox();
-  vbox->set_spacing(5);
-
-  Gtk::Label * attraction_label=new Gtk::Label("Edge elasticity: ");
-  Gtk::Label * propulsation_label=new Gtk::Label("Node propulsation: ");
-  Gtk::Label * iteration_label=new Gtk::Label("Iteration number: ");
-
-  Gtk::Adjustment * attraction_adjustment=new Gtk::Adjustment(attraction_v, 0,1,0.01,0.1);
-  Gtk::Adjustment * propulsation_adjustment=new Gtk::Adjustment(propulsation_v,0,1000000,1000,10000);
-  Gtk::Adjustment * iteration_adjustment=new Gtk::Adjustment(iterations_v,1,20000,5,10);
-
-  attraction = new Gtk::SpinButton(*attraction_adjustment,5,3);
-  propulsation = new Gtk::SpinButton(*propulsation_adjustment,5,0);
-  iteration = new Gtk::SpinButton(*iteration_adjustment,5,0);
-
-  close_button=new Gtk::Button("Redesign");
-
-  attraction->signal_value_changed().connect(sigc::mem_fun(*this, &DesignWin::emit_attraction));
-  propulsation->signal_value_changed().connect(sigc::mem_fun(*this, &DesignWin::emit_propulsation));
-  iteration->signal_value_changed().connect(sigc::mem_fun(*this, &DesignWin::emit_iteration));
-  close_button->signal_pressed().connect(sigc::mem_fun(*this, &DesignWin::emit_closerun));
-
-  table.attach(*attraction_label,0,1,0,1);
-  table.attach(*propulsation_label,0,1,1,2);
-  table.attach(*iteration_label,0,1,2,3);
-  table.attach(*attraction,1,2,0,1);
-  table.attach(*propulsation,1,2,1,2);
-  table.attach(*iteration,1,2,2,3);
-  table.attach(*close_button,0,2,3,4);
-
-  add(table);
-
-  show_all_children();
-};
-
-void DesignWin::emit_attraction()
-{
-  signal_attraction_ch.emit(attraction->get_value());
-}
-
-void DesignWin::emit_propulsation()
-{
-  signal_propulsation_ch.emit(propulsation->get_value());
-}
-
-void DesignWin::emit_iteration()
-{
-  signal_iteration_ch.emit((int)iteration->get_value());
-}
-
-void DesignWin::set_title(std::string tabname)
-{
-  Gtk::Window::set_title("Design Setup - "+tabname);
-}
-
-void DesignWin::set_data(double attr, double propuls, int it)
-{
-  attraction->set_value(attr);
-  propulsation->set_value(propuls);
-  iteration->set_value(it);
-}
Index: sign_win.h
===================================================================
--- design_win.h	(revision 177)
+++ 	(revision )
@@ -1,69 +1,0 @@
-/* -*- 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 DESWIN_H
-#define DESWIN_H
-
-class DesignWin;
-
-#include <all_include.h>
-#include <nbtab.h>
-#include <libgnomecanvasmm.h>
-#include <libgnomecanvasmm/polygon.h>
-
-class DesignWin : public Gtk::Window
-{
-private:
-  ///\ref NoteBookTab to that the \ref MapWin belongs to.
-  NoteBookTab & mytab;
-
-  Gtk::SpinButton * attraction;
-  Gtk::SpinButton * propulsation;
-  Gtk::SpinButton * iteration;
-  Gtk::Table table;
-  Gtk::Button * close_button;
-
-  sigc::signal<void, double> signal_attraction_ch;
-  sigc::signal<void, double> signal_propulsation_ch;
-  sigc::signal<void, int> signal_iteration_ch;
-  sigc::signal<void> close_run_pr;
-
-  void emit_attraction();
-  void emit_propulsation();
-  void emit_iteration();
-  void emit_closerun(){close_run_pr.emit();};
-
-public:
-  ///Close window if escape key is pressed.
-  bool closeIfEscapeIsPressed(GdkEventKey* e);
-
-  ///Constructor
-
-  ///It builds the window.
-  DesignWin(const std::string&, double, double, int, NoteBookTab & mw);
-
-  sigc::signal<void, double> signal_attraction(){return signal_attraction_ch;};
-  sigc::signal<void, double> signal_propulsation(){return signal_propulsation_ch;};
-  sigc::signal<void, int> signal_iteration(){return signal_iteration_ch;};
-  sigc::signal<void> close_run(){return close_run_pr;};
-
-  void set_title(std::string);
-
-  void set_data(double, double, int);
-};
-#endif //DESWIN_H
Index: jkstrabox.cc
===================================================================
--- dijkstrabox.cc	(revision 188)
+++ 	(revision )
@@ -1,236 +1,0 @@
-/* -*- 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.
- *
- */
-
-#include <dijkstrabox.h>
-#include <lemon/dijkstra.h>
-#include <lemon/suurballe.h>
-#include <lemon/path.h>
-
-enum {INPUT, OUTPUT, MAP_NUM};
-
-DijkstraBox::DijkstraBox(std::vector<std::string> t):AlgoBox()
-{
-  init(t);
-}
-    
-SuurballeBox::SuurballeBox(std::vector<std::string> t):DijkstraBox(t)
-{
-  Gtk::Adjustment * adjustment=new Gtk::Adjustment(2, 1, 20, 1, 5);
-  num_set = new Gtk::SpinButton(*adjustment, 5,0);
-
-  Gtk::Label * label=new Gtk::Label("No. of paths to find: ");
-//   hbox.pack_start(*label);
-//   hbox.pack_start(*num_set);
-//   hbox.show_all_children();
-
-  table.attach(*label, 0,1,2,3);
-  table.attach(*num_set, 1,2,2,3);
-
-
-//   pack_start(hbox);
-}
-    
-void DijkstraBox::run()
-{
-  if(
-     tabcbt.get_active_text()!="" &&
-     (edgemapcbts[INPUT])->get_active_text()!="" &&
-     (edgemapcbts[OUTPUT])->get_active_text()!="" &&
-     source.get_active_text()!="" &&
-     target.get_active_text()!=""
-     )
-    {
-      const Graph &g=mapstorage->graph;
-      Node from, to;
-
-      get_from_to(from, to, (Graph&)g);
-
-      std::ostringstream o;
-
-      if(!(from==to))
-	{
-	  Graph::EdgeMap<double> * inputmap=
-	    (mapstorage->edgemap_storage)[(edgemapcbts[INPUT])->get_active_text()];
-	  Graph::EdgeMap<double> * outputmap=
-	    (mapstorage->edgemap_storage)[(edgemapcbts[OUTPUT])->get_active_text()];
-
-	  //zero out output map
-	  for (EdgeIt i(g); i!=INVALID; ++i)
-	    {
-	      (*outputmap)[i]=0;
-	    }
-	  
-	  Dijkstra<Graph, Graph::EdgeMap<double> > dijkstra(g, *inputmap);
-	  dijkstra.run(from, to);
-	  
-	  if(dijkstra.reached(to))
-	    {
-	      Node n=to;
-	      int length=0;
-	      while (n!=INVALID && n!=from)
-		{
-		  Edge e=dijkstra.predEdge(n);
-		  (*outputmap)[e]=1;
-		  n=dijkstra.predNode(n);
-		  length++;
-		}
-	      o << "Result: " << length << " long path, with cost " << dijkstra.dist(to);
-	    }
-	  else
-	    {
-	      o << "Result: failed to find shortest path between ";
-	      o << source.get_active_text() << " and " << target.get_active_text();
-	    }
-	  resultlabel.set_text(o.str());
-	  
-	  mapstorage->mapChanged(true, (edgemapcbts[OUTPUT])->get_active_text());
-	  //   mapstorage->changeActiveMap(true, E_COLOR,
-	  // 			      (edgemapcbts[OUTPUT])->get_active_text());
-	  //   mapstorage->changeActiveMap(true, E_TEXT,
-	  // 			      (edgemapcbts[INPUT])->get_active_text());
-	}
-    }
-}
-
-void SuurballeBox::run()
-{
-  if(
-     tabcbt.get_active_text()!="" &&
-     (edgemapcbts[INPUT])->get_active_text()!="" &&
-     (edgemapcbts[OUTPUT])->get_active_text()!="" &&
-     source.get_active_text()!="" &&
-     target.get_active_text()!=""
-     )
-    {
-      const Graph &g=mapstorage->graph;
-      Node from, to;
-
-      get_from_to(from, to, (Graph&)g);
-
-      std::ostringstream o;
-
-      if(!(from==to))
-	{
-	  Graph::EdgeMap<double> * inputmap=
-	    (mapstorage->edgemap_storage)[(edgemapcbts[INPUT])->get_active_text()];
-	  Graph::EdgeMap<double> * outputmap=
-	    (mapstorage->edgemap_storage)[(edgemapcbts[OUTPUT])->get_active_text()];
-
-	  //zero out output map
-	  for (EdgeIt i(g); i!=INVALID; ++i)
-	    {
-	      (*outputmap)[i]=0;
-	    }
-	  
-	  Suurballe<Graph, Graph::EdgeMap<double> > sb((Graph&)g, *inputmap, from, to);
-	  
-	  int found=sb.run(num_set->get_value_as_int());
-	  if(found)
-	    {
-	      for(int j=0;j<found;j++)
-		{
-		  Path<Graph> path;
-		  path=sb.path(j);
-		  for(int k=0;k<path.length();k++)
-		    {
-		      (*outputmap)[path.nth(k)]=j+1;
-		    }
-		}
-	      o << "Result: found " << found << " paths between ";
-	      o << source.get_active_text() << " and " << target.get_active_text();
-	    }
-	  else
-	    {
-	      o << "Result: failed to find shortest path between ";
-	      o << source.get_active_text() << " and " << target.get_active_text();
-	    }
-	  resultlabel.set_text(o.str());
-	  
-	  mapstorage->mapChanged(true, (edgemapcbts[OUTPUT])->get_active_text());
-	  //   mapstorage->changeActiveMap(true, E_COLOR,
-	  // 			      (edgemapcbts[OUTPUT])->get_active_text());
-	  //   mapstorage->changeActiveMap(true, E_TEXT,
-	  // 			      (edgemapcbts[INPUT])->get_active_text());
-	}
-    }
-}
-    
-void DijkstraBox::build_box()
-{
-  //if active tab is changed, labels of graph nodes had to be loaded into comboboxes
-  //this can be done after the maps are loaded into ComboBoxes
-  signal_upon_maplist_updated().connect(sigc::mem_fun(*this, &DijkstraBox::maplists_updated));
-
-  addMapSelector("Cost map: ", true);
-  addMapSelector("Edges of path here: ", true);
-
-  Gtk::Label * source_label=new Gtk::Label("Source: ");
-  Gtk::Label * target_label=new Gtk::Label("Target: ");
-
-  table.attach(*source_label, 0,1,0,1);
-  table.attach(*target_label, 0,1,1,2);
-  table.attach(source, 1,2,0,1);
-  table.attach(target, 1,2,1,2);
-
-
-  pack_start(table);
-
-  resultlabel.set_text("Result: algorithm is not run yet.");
-  pack_start(resultlabel);
-}
-
-void SuurballeBox::build_box()
-{
-}
-
-void DijkstraBox::maplists_updated()
-{
-  if(tabcbt.get_active_text()!="")
-    {
-      source.clear();
-      target.clear();
-      const Graph &g=mapstorage->graph;
-      for (NodeIt i(g); i!=INVALID; ++i)
-	{
-	  std::ostringstream text;
-	  text << (*((mapstorage->nodemap_storage)["label"]))[i];
-	  source.prepend_text(text.str());
-	  target.prepend_text(text.str());
-	}
-    }
-}
-
-void DijkstraBox::get_from_to(Node & from, Node & to, Graph & g)
-{
-  int assigned=0;
-  for (NodeIt i(g); (i!=INVALID) && (assigned<2); ++i)
-    {
-      std::ostringstream text;
-      text << (*((mapstorage->nodemap_storage)["label"]))[i];
-      if(!(text.str().compare(source.get_active_text())))
-	{
-	  from=i;
-	  assigned++;
-	}
-      if(!(text.str().compare(target.get_active_text())))
-	{
-	  to=i;
-	  assigned++;
-	}
-    }
-}
Index: jkstrabox.h
===================================================================
--- dijkstrabox.h	(revision 174)
+++ 	(revision )
@@ -1,92 +1,0 @@
-/* -*- 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 DIJKSTRABOX_H
-#define DIJKSTRABOX_H
-
-class DijkstraBox;
-
-#include <all_include.h>
-#include <algobox.h>
-#include <libgnomecanvasmm.h>
-#include <libgnomecanvasmm/polygon.h>
-
-///Graphical interface to run Dijkstra algorithm.
-
-///Child of \ref AlgoBox,
-///therefore the only task to do at implementation was to
-///
-///-call init function with correct parameters from correctly parametrized constructor
-///
-///-implement \ref build_box function
-///
-///-implement \ref run function
-class DijkstraBox : public AlgoBox
-{
-protected:
-  ///Shows result of Dijkstra algorithm
-  Gtk::Label resultlabel;
-
-
-  ///Table for nodeselector widgets
-  Gtk::Table table;
-
-  ///Combobox for select source node
-  Gtk::ComboBoxText source;
-
-  ///Combobox for select target node
-  Gtk::ComboBoxText target;
-
-  ///Gets to and from node from combobox
-  void get_from_to(Node &, Node &, Graph &);
-
-public:
-  ///Calls \ref AlgoBox::init function to initialize class properly, automatically.
-  DijkstraBox(std::vector<std::string> t);
-
-  ///Prepare, run and postprocess Dijkstra algorithm.
-
-  ///\ref glemon works only with maps filled with double values
-  ///at the moment. While Dijkstra nedds a bool map as output.
-  ///As postprocess this bool map should be transformed to
-  ///double map.
-  virtual void run();
-
-  ///Builds the graphical design of the interface.
-  virtual void build_box();
-
-  void maplists_updated();
-};
-
-class SuurballeBox : public DijkstraBox
-{
-  ///number of paths to find
-  int num;
-  
-  ///Widget to set numbewr of paths to find
-  Gtk::SpinButton * num_set;
-
-  ///Holder widget
-  Gtk::HBox hbox;
-
-public:
-  SuurballeBox(std::vector<std::string> t);
-  void run();
-  void build_box();
-};
-#endif //DIJKSTRABOX_H
Index: c-broken_edge.cc
===================================================================
--- gdc-broken_edge.cc	(revision 174)
+++ 	(revision )
@@ -1,255 +1,0 @@
-/* -*- 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.
- *
- */
-
-#include "graph_displayer_canvas.h"
-#include <cmath>
-
-GraphDisplayerCanvas::EdgeBase::EdgeBase(Gnome::Canvas::Group& _group, Edge _edge, GraphDisplayerCanvas& _canvas) : 
-  Gnome::Canvas::Group(_group), edge(_edge), canvas(_canvas), arrow(*this)
-{
-  arrow.property_fill_color().set_value("red");
-  arrow.lower_to_bottom();
-  lower_to_bottom();
-}
-
-GraphDisplayerCanvas::EdgeBase::~EdgeBase()
-{
-}
-
-void GraphDisplayerCanvas::EdgeBase::drawArrow(XY unit_vector_in_dir)
-{
-  MapStorage& ms = canvas.mytab.mapstorage;
-  XY center(ms.arrow_pos[edge]);
-  XY unit_norm_vector(0-unit_vector_in_dir.y, unit_vector_in_dir.x);
-
-  //       /\       // top
-  //      /  \      //
-  //      -  -      // c(enter)l(eft), ccl, ccr, cr
-  //       ||       //
-  //       ||       // b(ottom)l, br
-
-  double size=3;
-
-  XY bl (center - unit_vector_in_dir * 3 * size + unit_norm_vector * size );
-  XY br (center - unit_vector_in_dir * 3 * size - unit_norm_vector * size );
-  XY ccl(center + unit_vector_in_dir *  size + unit_norm_vector * size );
-  XY ccr(center + unit_vector_in_dir *  size - unit_norm_vector * size );
-  XY cl (center + unit_vector_in_dir *  size + unit_norm_vector * 2 * size );
-  XY cr (center + unit_vector_in_dir *  size - unit_norm_vector * 2 * size );
-  XY top(center + unit_vector_in_dir * 3 * size);
-
-  Gnome::Canvas::Points arrow_points;
-  arrow_points.push_back(Gnome::Art::Point( bl.x , bl.y  ) );
-  arrow_points.push_back(Gnome::Art::Point( br.x , br.y  ) );
-  arrow_points.push_back(Gnome::Art::Point( ccr.x, ccr.y ) );
-  arrow_points.push_back(Gnome::Art::Point( cr.x , cr.y  ) );
-  arrow_points.push_back(Gnome::Art::Point( top.x, top.y ) );
-  arrow_points.push_back(Gnome::Art::Point( cl.x , cl.y  ) );
-  arrow_points.push_back(Gnome::Art::Point( ccl.x, ccl.y ) );
-
-  arrow.property_points().set_value(arrow_points);
-}
-
-GraphDisplayerCanvas::BrokenEdge::BrokenEdge(Gnome::Canvas::Group & g,
-    Edge _edge, GraphDisplayerCanvas & gc) : EdgeBase(g, _edge, gc),
-  isbutton(false), line(*this)
-{
-  arrow.signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::BrokenEdge::edgeFormerEventHandler));
-
-  line.property_fill_color().set_value("green");
-  line.property_width_units().set_value(10);    
-  line.lower_to_bottom();
-
-  draw();
-}
-
-GraphDisplayerCanvas::BrokenEdge::~BrokenEdge()
-{
-}
-
-void GraphDisplayerCanvas::BrokenEdge::draw()
-{
-  MapStorage& ms = canvas.mytab.mapstorage;
-
-  //calculating coordinates of the direction indicator arrow
-  XY head(ms.coords[ms.graph.target(edge)]);
-  XY center(ms.arrow_pos[edge]);
-
-  XY unit_vector_in_dir(head-center);
-  double length=sqrt( unit_vector_in_dir.normSquare() );
-
-  unit_vector_in_dir/=length;
-
-  // update the arrow
-  drawArrow(unit_vector_in_dir);
-
-  // update the edge
-  Gnome::Canvas::Points points;
-  Node source = ms.graph.source(edge);
-  Node target = ms.graph.target(edge);
-  points.push_back(Gnome::Art::Point(ms.coords[source].x,
-        ms.coords[source].y));
-  points.push_back(Gnome::Art::Point(ms.arrow_pos[edge].x,
-        ms.arrow_pos[edge].y));
-  points.push_back(Gnome::Art::Point(ms.coords[target].x,
-        ms.coords[target].y));
-  line.property_points().set_value(points);
-}
-
-bool GraphDisplayerCanvas::BrokenEdge::edgeFormerEventHandler(GdkEvent* e)
-{
-  switch(e->type)
-  {
-    case GDK_BUTTON_PRESS:
-      //we mark the location of the event to be able to calculate parameters
-      //of dragging
-      if(canvas.getActualTool()!=CREATE_NODE)
-      {
-        canvas.toggleEdgeActivity(this, true);
-        clicked_x=e->button.x;
-        clicked_y=e->button.y;
-        isbutton=true;
-      }
-      break;
-    case GDK_BUTTON_RELEASE:
-      if(canvas.getActualTool()!=CREATE_NODE)
-      {
-        canvas.toggleEdgeActivity(this, false);
-        isbutton=false;
-      }
-      break;
-    case GDK_MOTION_NOTIFY:
-      //we only have to do sg. if the mouse button is pressed
-      if(isbutton)
-      {
-        //new coordinates will be the old values,
-        //because the item will be moved to the
-        //new coordinate therefore the new movement
-        //has to be calculated from here
-
-        double dx=e->motion.x-clicked_x;
-        double dy=e->motion.y-clicked_y;
-
-        Gnome::Canvas::Points points_new;
-
-        canvas.mytab.mapstorage.arrow_pos.set(edge, canvas.mytab.mapstorage.arrow_pos[edge] + XY(dx, dy));
-
-        draw();
-        canvas.textReposition(canvas.mytab.mapstorage.arrow_pos[edge]);
-
-        clicked_x=e->motion.x;
-        clicked_y=e->motion.y;
-
-      }
-    default: break;
-  }
-
-  return true;
-}
-
-void GraphDisplayerCanvas::BrokenEdge::setLineWidth(int w)
-{
-  line.property_width_units().set_value(w);
-}
-
-void GraphDisplayerCanvas::BrokenEdge::setFillColor(Gdk::Color c)
-{
-  line.property_fill_color_gdk().set_value(c);
-}
-
-GraphDisplayerCanvas::LoopEdge::LoopEdge(Gnome::Canvas::Group& _group,
-    Edge _edge, GraphDisplayerCanvas& _canvas) :
-  EdgeBase(_group, _edge, _canvas), line(*this), isbutton(false)
-{
-  arrow.signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::LoopEdge::edgeFormerEventHandler));
-
-  line.property_outline_color().set_value("green");
-  line.property_width_units().set_value(10);
-  line.lower_to_bottom();
-
-  draw();
-}
-
-GraphDisplayerCanvas::LoopEdge::~LoopEdge()
-{
-}
-
-void GraphDisplayerCanvas::LoopEdge::draw()
-{
-  MapStorage& ms = canvas.mytab.mapstorage;
-
-  Node node = ms.graph.source(edge);
-  XY center = (ms.coords[node] + ms.arrow_pos[edge]) / 2.0;
-
-  XY unit_vector_in_dir(rot90(center - ms.arrow_pos[edge]));
-  double length = sqrt(unit_vector_in_dir.normSquare());
-  unit_vector_in_dir /= length;
-
-  drawArrow(unit_vector_in_dir);
-
-  double radius =
-    sqrt((ms.arrow_pos[edge] - ms.coords[node]).normSquare()) / 2.0;
-
-  XY p1 = center + XY(-radius,  radius);
-  XY p2 = center + XY( radius, -radius);
-  line.property_x1().set_value(p1.x);
-  line.property_y1().set_value(p1.y);
-  line.property_x2().set_value(p2.x);
-  line.property_y2().set_value(p2.y);
-}
-
-void GraphDisplayerCanvas::LoopEdge::setLineWidth(int w)
-{
-  line.property_width_units().set_value(w);
-}
-
-void GraphDisplayerCanvas::LoopEdge::setFillColor(Gdk::Color c)
-{
-  line.property_outline_color_gdk().set_value(c);
-}
-
-bool GraphDisplayerCanvas::LoopEdge::edgeFormerEventHandler(GdkEvent* e)
-{
-  switch(e->type)
-  {
-    case GDK_BUTTON_PRESS:
-      if(canvas.getActualTool()!=CREATE_NODE)
-      {
-        canvas.toggleEdgeActivity(this, true);
-        isbutton=true;
-      }
-      break;
-    case GDK_BUTTON_RELEASE:
-      if(canvas.getActualTool()!=CREATE_NODE)
-      {
-        canvas.toggleEdgeActivity(this, false);
-        isbutton=false;
-      }
-      break;
-    case GDK_MOTION_NOTIFY:
-      if(isbutton)
-      {
-        canvas.mytab.mapstorage.arrow_pos.set(edge, XY(e->motion.x, e->motion.y));
-
-        draw();
-        canvas.textReposition(canvas.mytab.mapstorage.arrow_pos[edge]);
-      }
-    default: break;
-  }
-  return true;
-}
Index: ttext.h
===================================================================
--- gettext.h	(revision 130)
+++ 	(revision )
@@ -1,79 +1,0 @@
-/* Convenience header for conditional use of GNU <libintl.h>.
-   Copyright (C) 1995-1998, 2000-2002, 2004 Free Software Foundation, Inc.
-
-   This program is free software; you can redistribute it and/or modify it
-   under the terms of the GNU Library General Public License as published
-   by the Free Software Foundation; either version 2, or (at your option)
-   any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Library General Public License for more details.
-
-   You should have received a copy of the GNU Library General Public
-   License along with this program; if not, write to the Free Software
-   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
-   USA.  */
-
-#ifndef _LIBGETTEXT_H
-#define _LIBGETTEXT_H 1
-
-/* NLS can be disabled through the configure --disable-nls option.  */
-#if ENABLE_NLS
-
-/* Get declarations of GNU message catalog functions.  */
-# include <libintl.h>
-
-#else
-
-/* Solaris /usr/include/locale.h includes /usr/include/libintl.h, which
-   chokes if dcgettext is defined as a macro.  So include it now, to make
-   later inclusions of <locale.h> a NOP.  We don't include <libintl.h>
-   as well because people using "gettext.h" will not include <libintl.h>,
-   and also including <libintl.h> would fail on SunOS 4, whereas <locale.h>
-   is OK.  */
-#if defined(__sun)
-# include <locale.h>
-#endif
-
-/* Many header files from the libstdc++ coming with g++ 3.3 or newer include
-   <libintl.h>, which chokes if dcgettext is defined as a macro.  So include
-   it now, to make later inclusions of <libintl.h> a NOP.  */
-#if defined(__cplusplus) && defined(__GNUG__) && (__GNUC__ >= 3)
-# include <cstdlib>
-# if (__GLIBC__ >= 2) || _GLIBCXX_HAVE_LIBINTL_H
-#  include <libintl.h>
-# endif
-#endif
-
-/* Disabled NLS.
-   The casts to 'const char *' serve the purpose of producing warnings
-   for invalid uses of the value returned from these functions.
-   On pre-ANSI systems without 'const', the config.h file is supposed to
-   contain "#define const".  */
-# define gettext(Msgid) ((const char *) (Msgid))
-# define dgettext(Domainname, Msgid) ((const char *) (Msgid))
-# define dcgettext(Domainname, Msgid, Category) ((const char *) (Msgid))
-# define ngettext(Msgid1, Msgid2, N) \
-    ((N) == 1 ? (const char *) (Msgid1) : (const char *) (Msgid2))
-# define dngettext(Domainname, Msgid1, Msgid2, N) \
-    ((N) == 1 ? (const char *) (Msgid1) : (const char *) (Msgid2))
-# define dcngettext(Domainname, Msgid1, Msgid2, N, Category) \
-    ((N) == 1 ? (const char *) (Msgid1) : (const char *) (Msgid2))
-# define textdomain(Domainname) ((const char *) (Domainname))
-# define bindtextdomain(Domainname, Dirname) ((const char *) (Dirname))
-# define bind_textdomain_codeset(Domainname, Codeset) ((const char *) (Codeset))
-
-#endif
-
-/* A pseudo function call that serves as a marker for the automated
-   extraction of messages, but does not call gettext().  The run-time
-   translation is done at a different place in the code.
-   The argument, String, should be a literal string.  Concatenated strings
-   and other string expressions won't work.
-   The macro's expansion is not parenthesized, so that it is suitable as
-   initializer for static 'char[]' or 'const char[]' variables.  */
-#define gettext_noop(String) String
-
-#endif /* _LIBGETTEXT_H */
Index: emon.spec.in
===================================================================
--- glemon.spec.in	(revision 164)
+++ 	(revision )
@@ -1,42 +1,0 @@
-Summary: A graph editor for the LEMON Graph Format
-Name: @PACKAGE_TARNAME@
-Version: @PACKAGE_VERSION@
-Release: 1
-License: Boost
-URL: http://lemon.cs.elte.hu
-Source0: %{name}-%{version}.tar.gz
-Group: Development/Libraries
-BuildRoot: %{_tmppath}/%{name}-root
-Requires: lemon
-Requires: gtkmm24 >= 2.6
-Requires: libgnomecanvasmm >= 2.6.0
-BuildRequires: lemon-devel
-BuildRequires: gtkmm24-devel >= 2.6
-BuildRequires: libgnomecanvasmm-devel >= 2.6.0
-
-%description
-glemon is a graphical editor for the LEMON Graph Format (.lgf)
-
-%prep
-%setup -q
-
-%build
-%configure
-make
-
-%install
-rm -rf $RPM_BUILD_ROOT
-make DESTDIR=$RPM_BUILD_ROOT install
-
-%clean
-rm -rf $RPM_BUILD_ROOT
-
-%post -p /sbin/ldconfig
-
-%postun -p /sbin/ldconfig
-
-%files
-%defattr(-,root,root)
-%{_bindir}/glemon
-%{_datadir}/locale
-%doc AUTHORS COPYING LICENSE NEWS README
Index: aph-displayer.cc
===================================================================
--- graph-displayer.cc	(revision 174)
+++ 	(revision )
@@ -1,116 +1,0 @@
-/* -*- 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.
- *
- */
-
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#include "all_include.h"
-#include "mapstorage.h"
-#include "main_win.h"
-#include <libgnomecanvasmm.h>
-#include <libgnomecanvasmm/polygon.h>
-
-#include <locale.h>
-
-#define MAIN_PART
-
-std::vector <std::string> edge_property_strings;
-std::vector <double> edge_property_defaults;
-std::vector <std::string> node_property_strings;
-std::vector <double> node_property_defaults;
-int longest_property_string_length;
-
-int main(int argc, char *argv[])
-{
-  setlocale(LC_ALL, "");
-  bindtextdomain(PACKAGE, LOCALEDIR);
-  bind_textdomain_codeset(PACKAGE, "UTF-8");
-  textdomain(PACKAGE);
-
-  //initializing
-
-  edge_property_strings.resize(EDGE_PROPERTY_NUM);
-  edge_property_strings[E_WIDTH]="Edge Width";
-  edge_property_strings[E_COLOR]="Edge Color";
-  edge_property_strings[E_TEXT]="Edge Text";
-
-  edge_property_defaults.resize(EDGE_PROPERTY_NUM);
-  edge_property_defaults[E_WIDTH]=10.0;
-  edge_property_defaults[E_COLOR]=100;
-  edge_property_defaults[E_TEXT]=0;
-
-  node_property_strings.resize(NODE_PROPERTY_NUM);
-  node_property_strings[N_RADIUS]="Node Radius";
-  node_property_strings[N_COLOR]="Node Color";
-  node_property_strings[N_TEXT]="Node Text";
-
-  node_property_defaults.resize(NODE_PROPERTY_NUM);
-  node_property_defaults[N_RADIUS]=20.0;
-  node_property_defaults[N_COLOR]=100;
-  node_property_defaults[N_TEXT]=0;
-
-  longest_property_string_length=0;
-  for(int i=0;i<EDGE_PROPERTY_NUM;i++)
-    {
-      int j=edge_property_strings[i].size();
-      if(j>longest_property_string_length)
-	{
-	  longest_property_string_length=j;
-	}
-    }
-  for(int i=0;i<NODE_PROPERTY_NUM;i++)
-    {
-      int j=node_property_strings[i].size();
-      if(j>longest_property_string_length)
-	{
-	  longest_property_string_length=j;
-	}
-    }
-
-
-  //initializing GUI
-
-  Gnome::Canvas::init();
-  Gtk::Main app(argc, argv);
-
-  MainWin mytab;
-
-//   if ((argc == 2) && (Glib::file_test(argv[1], Glib::FILE_TEST_IS_REGULAR)))
-//     {
-//       mytab.readFile(argv[1]);
-//     }
-  if(argc>=2)
-    {
-      for(int i=1;i<argc;i++)
-	{
-	  if(Glib::file_test(argv[i], Glib::FILE_TEST_IS_REGULAR))
-	    {
-	      mytab.readFile(argv[i]);
-	    }
-	}
-    }
-  else
-    {
-      mytab.newTab();
-    }
-  
-  app.run(mytab);
-
-  return 0;
-}
Index: aph_displayer_canvas-edge.cc
===================================================================
--- graph_displayer_canvas-edge.cc	(revision 204)
+++ 	(revision )
@@ -1,288 +1,0 @@
-/* -*- 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.
- *
- */
-
-#include "graph_displayer_canvas.h"
-#include <cmath>
-
-const int minimum_edge_width=0;
-
-int GraphDisplayerCanvas::resetEdgeWidth (Edge edge)
-{
-  double min, max;
-
-  min=edge_property_defaults[E_WIDTH];
-  max=edge_property_defaults[E_WIDTH];
-  Graph::EdgeMap<double> actual_map((mytab.mapstorage).graph,edge_property_defaults[E_WIDTH]);
-  
-  if(edge==INVALID)
-    {
-      for (EdgeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
-	{
-	  double v=fabs(actual_map[i]);
-	  int w;
-	  if(min==max)
-	    {
-	      w=(int)(edge_property_defaults[E_WIDTH]);
-	    }
-	  else
-	    {
-	      w=(int)(MIN_EDGE_WIDTH+(v-min)/(max-min)*(MAX_EDGE_WIDTH-MIN_EDGE_WIDTH));
-	    }
-	  if(zoomtrack)
-	    {
-	      double actual_ppu=get_pixels_per_unit();
-	      w=(int)(w/actual_ppu*fixed_zoom_factor);
-	    }
-	  edgesmap[i]->setLineWidth(w);
-	}
-    }
-  else
-    {
-      int w=(int)actual_map[edge];
-      if(w>=0)
-	{
-	  edgesmap[edge]->setLineWidth(w);
-	}
-    }
-  return 0;
-}
-
-
-int GraphDisplayerCanvas::changeEdgeWidth (std::string mapname, Edge edge)
-{
-  Graph::EdgeMap<double> * actual_map;
-  double min, max;
-
-  min=(mytab.mapstorage).minOfEdgeMap(mapname);
-  max=(mytab.mapstorage).maxOfEdgeMap(mapname);
-  actual_map=((mytab.mapstorage).edgemap_storage)[mapname];
-
-  if(edge==INVALID)
-    {
-      for (EdgeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
-	{
-	  double v=(*actual_map)[i];
-	  int w;
-	  if(autoscale)
-	    {
-	      if(min==max)
-		{
-		  w=(int)(edge_property_defaults[E_WIDTH]);
-		}
-	      else
-		{
-		  w=(int)(minimum_edge_width+(v-min)/(max-min)*(edge_width-minimum_edge_width));
-		}
-	    }
-	  else
-	    {
-	      w=(int)(v*edge_width);
-	    }
-	  if(w<0)
-	    {
-	      edgesmap[i]->hide();
-	    }
-	  else
-	    {
-	      edgesmap[i]->show();
-	      if(w<minimum_edge_width)
-		{
-		  w=minimum_edge_width;
-		}
-	      if(zoomtrack)
-		{
-		  double actual_ppu=get_pixels_per_unit();
-		  w=(int)(w/actual_ppu*fixed_zoom_factor);
-		}
-	      edgesmap[i]->setLineWidth(w);
-	    }
-	}
-    }
-  else
-    {
-      int w=(int)(*actual_map)[edge];
-      if(w>=0)
-	{
-	  edgesmap[edge]->setLineWidth(w);
-	}
-    }
-  return 0;
-};
-
-int GraphDisplayerCanvas::changeEdgeColor (std::string mapname, Edge edge)
-{  
-
-  //function maps the range of the maximum and
-  //the minimum of the nodemap to the range of
-  //green in RGB
-  Graph::EdgeMap<double> * actual_map;
-  actual_map=((mytab.mapstorage).edgemap_storage)[mapname];
-
-  double max, min;
-
-  max=(mytab.mapstorage).maxOfEdgeMap(mapname);
-  min=(mytab.mapstorage).minOfEdgeMap(mapname);
-
-  if(edge==INVALID)
-    {
-      for (EdgeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
-	{
-	  double w=(*actual_map)[i];
-
-	  Gdk::Color color;
-	  if(max!=min)
-	    {
-	      color=rainbowColorCounter(min, max, w);
-	    }
-	  else
-	    {
-	      color.set_rgb_p (0, 1, 0);
-	    }
-	  edgesmap[i]->setFillColor(color);
-	}
-    }
-  else
-    {
-      Gdk::Color color;
-
-      double w=(*actual_map)[edge];
-
-      if(max!=min)
-	{
-	  color=rainbowColorCounter(min, max, w);
-	}
-      else
-	{
-	  color.set_rgb_p (0, 1, 0);
-	}
-
-      edgesmap[edge]->setFillColor(color);
-    }
-  return 0;
-};
-
-int GraphDisplayerCanvas::resetEdgeColor (Edge edge)
-{  
-
-  //function maps the range of the maximum and
-  //the minimum of the nodemap to the range of
-  //green in RGB
-  Graph::EdgeMap<double> actual_map((mytab.mapstorage).graph,edge_property_defaults[E_COLOR]);
-
-  double max, min;
-
-  max=edge_property_defaults[E_COLOR];
-  min=edge_property_defaults[E_COLOR];
-
-  if(edge==INVALID)
-    {
-      for (EdgeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
-	{
-	  double w=actual_map[i];
-
-	  Gdk::Color color;
-	  if(max!=min)
-	    {
-	      color.set_rgb_p (0, 100*(w-min)/(max-min), 0);
-	    }
-	  else
-	    {
-	      color.set_rgb_p (0, 100, 0);
-	    }
-	  edgesmap[i]->setFillColor(color);
-	}
-    }
-  else
-    {
-      Gdk::Color color;
-
-      double w=actual_map[edge];
-
-      if(max!=min)
-	{
-	  color.set_rgb_p (0, 100*(w-min)/(max-min), 0);
-	}
-      else
-	{
-	  color.set_rgb_p (0, 100, 0);
-	}
-
-      edgesmap[edge]->setFillColor(color);
-    }
-  return 0;
-};
-
-int GraphDisplayerCanvas::changeEdgeText (std::string mapname, Edge edge)
-{
-  //the number in the map will be written on the edge
-  //EXCEPT when the name of the map is Default, because
-  //in that case empty string will be written, because
-  //that is the deleter map
-  
-  if(edge==INVALID)
-    {
-      for (EdgeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
-	{
-	  edgemap_to_edit=mapname;
-	  double number=(*((mytab.mapstorage).edgemap_storage)[mapname])[i];
-	  
-	  std::ostringstream ostr;
-	  ostr << number;
-	  
-// 	  edgetextmap[i]->property_text().set_value(ostr.str());
-	}
-
-    }
-  else
-    {
-	  double number=(*((mytab.mapstorage).edgemap_storage)[mapname])[edge];
-
-	  std::ostringstream ostr;
-	  ostr << number;
-	  
-// 	  edgetextmap[edge]->property_text().set_value(ostr.str());
-    }
-
-  return 0;
-
-};
-
-int GraphDisplayerCanvas::resetEdgeText (Edge edge)
-{
-  //the number in the map will be written on the edge
-  //EXCEPT when the name of the map is Default, because
-  //in that case empty string will be written, because
-  //that is the deleter map
-  
-  if(edge==INVALID)
-    {
-      for (EdgeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
-	{
-	  edgemap_to_edit="";
-// 	  edgetextmap[i]->property_text().set_value("");
-	}
-
-    }
-  else
-    {
-//       edgetextmap[edge]->property_text().set_value("");
-    }
-
-  return 0;
-
-};
Index: aph_displayer_canvas-event.cc
===================================================================
--- graph_displayer_canvas-event.cc	(revision 204)
+++ 	(revision )
@@ -1,973 +1,0 @@
-/* -*- 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.
- *
- */
-
-#include "graph_displayer_canvas.h"
-#include <cmath>
-
-
-bool GraphDisplayerCanvas::on_expose_event(GdkEventExpose *event)
-{
-  Gnome::Canvas::CanvasAA::on_expose_event(event);
-  //usleep(10000);
-  //rezoom();
-  return true;
-}
-
-void GraphDisplayerCanvas::changeEditorialTool(int newtool)
-{
-  if(actual_tool!=newtool)
-    {
-
-      actual_handler.disconnect();
-
-      switch(actual_tool)
-	{
-	case CREATE_EDGE:
-	  {
-	    GdkEvent * generated=new GdkEvent();
-	    generated->type=GDK_BUTTON_RELEASE;
-	    generated->button.button=3;
-	    createEdgeEventHandler(generated);      
-	    break;
-	  }
-	case MAP_EDIT:
-	  {
-	    break;
-	  }
-	default:
-	  break;
-	}
-
-      active_item=NULL; 
-      target_item=NULL; 
-      active_edge=INVALID;	
-      active_node=INVALID;	
-
-
-      actual_tool=newtool;
-  
-      switch(newtool)
-	{
-	case MOVE:
-	  actual_handler=signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::moveEventHandler), false);
-	  break;
-
-	case CREATE_NODE:
-	  actual_handler=signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::createNodeEventHandler), false);
-	  break;
-
-	case CREATE_EDGE:
-	  actual_handler=signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::createEdgeEventHandler), false);
-	  break;
-
-	case ERASER:
-	  actual_handler=signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::eraserEventHandler), false);
-	  break;
-
-	case MAP_EDIT:
-	  grab_focus();
-	  actual_handler=signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::mapEditEventHandler), false);
-	  break;
-
-	default:
-	  break;
-	}
-    }
-}
-
-int GraphDisplayerCanvas::getActualTool()
-{
-  return actual_tool;
-}
-
-bool GraphDisplayerCanvas::scrollEventHandler(GdkEvent* e)
-{
-  bool handled=false;
-  if(e->type==GDK_SCROLL)
-    {
-
-      //pointer shows this win point before zoom
-      XY win_coord(((GdkEventScroll*)e)->x, ((GdkEventScroll*)e)->y);
-
-      //the original scroll settings
-      int scroll_offset_x, scroll_offset_y;
-      get_scroll_offsets(scroll_offset_x, scroll_offset_y);
-
-      //pointer shows this canvas point before zoom
-      XY canvas_coord;
-      window_to_world(win_coord.x, win_coord.y, canvas_coord.x, canvas_coord.y);
-
-      if(((GdkEventScroll*)e)->direction) //IN
-	{
-	  zoomIn();
-	}
-      else
-	{
-	  zoomOut();
-	}
-
-      //pointer shows this window point after zoom
-      XY post_win_coord;
-      world_to_window(canvas_coord.x, canvas_coord.y, post_win_coord.x, post_win_coord.y);
-
-      //we have to add the difference between new and old window point to original scroll offset
-      scroll_to(scroll_offset_x+(int)(post_win_coord.x-win_coord.x),scroll_offset_y+(int)(post_win_coord.y-win_coord.y));
-      
-      //no other eventhandler is needed
-      handled=true;
-    }
-  return handled;
-}
-
-bool GraphDisplayerCanvas::moveEventHandler(GdkEvent* e)
-{
-  static Gnome::Canvas::Text *coord_text = 0;
-  switch(e->type)
-    {
-    case GDK_BUTTON_PRESS:
-      //we mark the location of the event to be able to calculate parameters of dragging
-      window_to_world (e->button.x, e->button.y, clicked_x, clicked_y);
-      
-      active_item=(get_item_at(clicked_x, clicked_y));
-      active_node=INVALID;
-      for (NodeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
-	{
-	  if(nodesmap[i]==active_item)
-	    {
-	      active_node=i;
-	    }
-	}
-      isbutton=e->button.button;
-      break;
-    case GDK_BUTTON_RELEASE:
-      if (coord_text)
-	{
-	  delete coord_text;
-	  coord_text = 0;
-	}
-      isbutton=0;
-      active_item=NULL;
-      active_node=INVALID;
-      break;
-    case GDK_MOTION_NOTIFY:
-      //we only have to do sg. if the mouse button is pressed AND the click was on a node that was found in the set of nodes
-      if(active_node!=INVALID)
-	{
-	  (mytab.mapstorage).modified = true;
-	  
-	  //new coordinates will be the old values,
-	  //because the item will be moved to the
-	  //new coordinate therefore the new movement
-	  //has to be calculated from here
-	  
-	  double new_x, new_y;
-	  
-	  window_to_world (e->motion.x, e->motion.y, new_x, new_y);
-	  
-	  double dx=new_x-clicked_x;
-	  double dy=new_y-clicked_y;
-	  
-	  moveNode(dx, dy);
-
-	  clicked_x=new_x;
-	  clicked_y=new_y;
-
-	  // reposition the coordinates text
-	  std::ostringstream ostr;
-	  ostr << "(" <<
-	    (mytab.mapstorage).coords[active_node].x << ", " <<
-	    (mytab.mapstorage).coords[active_node].y << ")";
-	  double radius =
-	    (nodesmap[active_node]->property_x2().get_value() -
-	     nodesmap[active_node]->property_x1().get_value()) / 2.0;
-	  if (coord_text)
-	    {
-	      coord_text->property_text().set_value(ostr.str());
-	      coord_text->property_x().set_value((mytab.mapstorage).coords[active_node].x +
-						 radius);
-	      coord_text->property_y().set_value((mytab.mapstorage).coords[active_node].y -
-						 radius);
-	    }
-	  else
-	    {
-	      coord_text = new Gnome::Canvas::Text(
-						   displayed_graph,
-						   (mytab.mapstorage).coords[active_node].x + radius,
-						   (mytab.mapstorage).coords[active_node].y - radius,
-						   ostr.str());
-	      coord_text->property_fill_color().set_value("black");
-	      coord_text->property_anchor().set_value(Gtk::ANCHOR_SOUTH_WEST);
-	    }
-
-
-	}
-    default: break;
-    }
-
-return false;
-}
-
-XY GraphDisplayerCanvas::calcArrowPos(XY moved_node_1, XY moved_node_2, XY fix_node, XY old_arrow_pos, int move_code)
-{
-  switch(move_code)
-    {
-    case 1:
-      return XY((moved_node_2.x + fix_node.x) / 2.0, (moved_node_2.y + fix_node.y) / 2.0);
-      break;
-    case 2:
-      return old_arrow_pos;
-      break;
-    case 3:
-      {
-	//////////////////////////////////////////////////////////////////////////////////////////////////////
-	/////////// keeps shape-with scalar multiplication - version 2.
-	//////////////////////////////////////////////////////////////////////////////////////////////////////
-
-	//old vector from one to the other node - a
-	XY a_v(moved_node_1.x-fix_node.x,moved_node_1.y-fix_node.y);
-	//new vector from one to the other node - b
-	XY b_v(moved_node_2.x-fix_node.x,moved_node_2.y-fix_node.y);
-
-	double absa=sqrt(a_v.normSquare());
-	double absb=sqrt(b_v.normSquare());
-
-	if ((absa == 0.0) || (absb == 0.0))
-	  {
-	    return old_arrow_pos;
-	  }
-	else
-	  {
-	    //old vector from one node to the breakpoint - c
-	    XY c_v(old_arrow_pos.x-fix_node.x,old_arrow_pos.y-fix_node.y);
-
-	    //unit vector with the same direction to a_v
-	    XY a_v_u(a_v.x/absa,a_v.y/absa);
-
-	    //normal vector of unit vector with the same direction to a_v
-	    XY a_v_u_n(((-1)*a_v_u.y),a_v_u.x);
-
-	    //unit vector with the same direction to b_v
-	    XY b_v_u(b_v.x/absb,b_v.y/absb);
-
-	    //normal vector of unit vector with the same direction to b_v
-	    XY b_v_u_n(((-1)*b_v_u.y),b_v_u.x);
-
-	    //vector c in a_v_u and a_v_u_n co-ordinate system
-	    XY c_a(c_v*a_v_u,c_v*a_v_u_n);
-
-	    //new vector from one node to the breakpoint - d - we have to calculate this one
-	    XY d_v=absb/absa*(c_a.x*b_v_u+c_a.y*b_v_u_n);
-
-	    return XY(d_v.x+fix_node.x,d_v.y+fix_node.y);
-	  }
-	break;
-      }
-    default:
-      break;
-    }
-}
-
-
-bool GraphDisplayerCanvas::createNodeEventHandler(GdkEvent* e)
-{
-  switch(e->type)
-  {
-    //move the new node
-    case GDK_MOTION_NOTIFY:
-      {
-        GdkEvent * generated=new GdkEvent();
-        generated->motion.x=e->motion.x;
-        generated->motion.y=e->motion.y;
-        generated->type=GDK_MOTION_NOTIFY;
-        moveEventHandler(generated);      
-        break;
-      }
-
-    case GDK_BUTTON_RELEASE:
-      (mytab.mapstorage).modified = true;
-
-      is_drawn=true;
-
-      isbutton=1;
-
-      active_node=(mytab.mapstorage).graph.addNode();
-
-      //initiating values corresponding to new node in maps
-
-      window_to_world (e->button.x, e->button.y, clicked_x, clicked_y);
-
-      // update coordinates
-      (mytab.mapstorage).coords.set(active_node, XY(clicked_x, clicked_y));
-
-      // update all other maps
-      for (std::map<std::string, Graph::NodeMap<double>*>::const_iterator it =
-          (mytab.mapstorage).nodemap_storage.begin(); it !=
-          (mytab.mapstorage).nodemap_storage.end(); ++it)
-      {
-        if ((it->first != "coordinates_x") &&
-            (it->first != "coordinates_y"))
-        {
-          (*(it->second))[active_node] =
-            (mytab.mapstorage).nodemap_default[it->first];
-        }
-      }
-      // increment the id map's default value
-      (mytab.mapstorage).nodemap_default["label"] += 1.0;
-
-      nodesmap[active_node]=new Gnome::Canvas::Ellipse(displayed_graph,
-          clicked_x-20, clicked_y-20, clicked_x+20, clicked_y+20);
-      active_item=(Gnome::Canvas::Item *)(nodesmap[active_node]);
-      *(nodesmap[active_node]) <<
-        Gnome::Canvas::Properties::fill_color("blue");
-      *(nodesmap[active_node]) <<
-        Gnome::Canvas::Properties::outline_color("black");
-      active_item->raise_to_top();
-
-      (nodesmap[active_node])->show();
-
-//       nodetextmap[active_node]=new Gnome::Canvas::Text(displayed_graph,
-//           clicked_x+node_property_defaults[N_RADIUS]+5,
-//           clicked_y+node_property_defaults[N_RADIUS]+5, "");
-//       nodetextmap[active_node]->property_fill_color().set_value("darkblue");
-//       nodetextmap[active_node]->raise_to_top();
-
-//       mapwin.updateNode(active_node);
-      propertyUpdate(active_node);
-
-      isbutton=0;
-      target_item=NULL;
-      active_item=NULL;
-      active_node=INVALID;
-      break;
-    default:
-      break;
-  }
-  return false;
-}
-
-bool GraphDisplayerCanvas::createEdgeEventHandler(GdkEvent* e)
-{
-  switch(e->type)
-  {
-    case GDK_BUTTON_PRESS:
-      //in edge creation right button has special meaning
-      if(e->button.button!=3)
-      {
-        //there is not yet selected node
-        if(active_node==INVALID)
-        {
-          //we mark the location of the event to be able to calculate parameters of dragging
-
-          window_to_world (e->button.x, e->button.y, clicked_x, clicked_y);
-
-          active_item=(get_item_at(clicked_x, clicked_y));
-          active_node=INVALID;
-          for (NodeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
-          {
-            if(nodesmap[i]==active_item)
-            {
-              active_node=i;
-            }
-          }
-          //the clicked item is really a node
-          if(active_node!=INVALID)
-          {
-            *(nodesmap[active_node]) << Gnome::Canvas::Properties::fill_color("red");
-            isbutton=1;
-          }
-          //clicked item was not a node. It could be e.g. edge.
-          else
-          {
-            active_item=NULL;
-          }
-        }
-        //we only have to do sg. if the mouse button
-        // is pressed already once AND the click was
-        // on a node that was found in the set of 
-        //nodes, and now we only search for the second 
-        //node
-        else
-        {
-          window_to_world (e->button.x, e->button.y, clicked_x, clicked_y);
-          target_item=(get_item_at(clicked_x, clicked_y));
-          Node target_node=INVALID;
-          for (NodeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
-          {
-            if(nodesmap[i]==target_item)
-            {
-              target_node=i;
-            }
-          }
-          //the clicked item is a node, the edge can be drawn
-          if(target_node!=INVALID)
-          {
-            (mytab.mapstorage).modified = true;
-
-            *(nodesmap[target_node]) <<
-              Gnome::Canvas::Properties::fill_color("red");
-
-            //creating new edge
-            active_edge=(mytab.mapstorage).graph.addEdge(active_node,
-                target_node);
-
-            // update maps
-            for (std::map<std::string,
-                Graph::EdgeMap<double>*>::const_iterator it =
-                (mytab.mapstorage).edgemap_storage.begin(); it !=
-                (mytab.mapstorage).edgemap_storage.end(); ++it)
-            {
-              (*(it->second))[active_edge] =
-                (mytab.mapstorage).edgemap_default[it->first];
-            }
-            // increment the id map's default value
-            (mytab.mapstorage).edgemap_default["label"] += 1.0;
-
-            if(target_node!=active_node)		
-            {
-              // set the coordinates of the arrow on the new edge
-              MapStorage& ms = mytab.mapstorage;
-              ms.arrow_pos.set(active_edge,
-                  (ms.coords[ms.graph.source(active_edge)] +
-                   ms.coords[ms.graph.target(active_edge)])/ 2.0);
-
-              //drawing new edge
-              edgesmap[active_edge]=new BrokenEdge(displayed_graph, active_edge,
-                  *this);
-            }
-            else
-            {
-              // set the coordinates of the arrow on the new edge
-              MapStorage& ms = mytab.mapstorage;
-              ms.arrow_pos.set(active_edge,
-                  (ms.coords[ms.graph.source(active_edge)] +
-                   XY(0.0, 80.0)));
-
-              //drawing new edge
-              edgesmap[active_edge]=new LoopEdge(displayed_graph, active_edge,
-                  *this);
-            }
-
-            //initializing edge-text as well, to empty string
-            XY text_pos=mytab.mapstorage.arrow_pos[active_edge];
-            text_pos+=(XY(10,10));
-
-//             edgetextmap[active_edge]=new Gnome::Canvas::Text(displayed_graph,
-//                 text_pos.x, text_pos.y, "");
-//             edgetextmap[active_edge]->property_fill_color().set_value(
-//                 "darkgreen");
-//             edgetextmap[active_edge]->raise_to_top();
-
-            propertyUpdate(active_edge);
-          }
-          //clicked item was not a node. it could be an e.g. edge. we do not
-          //deal with it furthermore.
-          else
-          {
-            target_item=NULL;
-          }
-        }
-      }
-      break;
-    case GDK_BUTTON_RELEASE:
-      isbutton=0;
-      //we clear settings in two cases
-      //1: the edge is ready (target_item has valid value)
-      //2: the edge creation is cancelled with right button
-      if((target_item)||(e->button.button==3))
-      {
-        if(active_item)
-        {
-	  propertyUpdate(active_node,N_COLOR);
-          active_item=NULL;
-        }
-        if(target_item)
-        {
-	  propertyUpdate((mytab.mapstorage).graph.target(active_edge),N_COLOR);
-          target_item=NULL;
-        }
-        active_node=INVALID;
-        active_edge=INVALID;
-      }
-      break;
-    default:
-      break;
-  }
-  return false;
-}
-
-bool GraphDisplayerCanvas::eraserEventHandler(GdkEvent* e)
-{
-  switch(e->type)
-    {
-    case GDK_BUTTON_PRESS:
-      //finding the clicked items
-      window_to_world (e->button.x, e->button.y, clicked_x, clicked_y);
-      active_item=(get_item_at(clicked_x, clicked_y));
-      active_node=INVALID;
-      active_edge=INVALID;
-      //was it a node?
-      for (NodeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
-	{
-	  if(nodesmap[i]==active_item)
-	    {
-	      active_node=i;
-	    }
-	}
-      //or was it an edge?
-      if(active_node==INVALID)
-	{
-	  for (EdgeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
-	    {
-	      if(edgesmap[i]->getLine()==active_item)
-		{
-		  active_edge=i;
-		}
-	    }
-	}
-
-      // return if the clicked object is neither an edge nor a node
-      if (active_edge == INVALID) return false;
-      
-      //recolor activated item
-      if(active_item)
-	{
-	  *active_item << Gnome::Canvas::Properties::fill_color("red");
-	}
-      break;
-
-    case GDK_BUTTON_RELEASE:
-      window_to_world (e->button.x, e->button.y, clicked_x, clicked_y);
-      if(active_item)
-	{
-	  //the cursor was not moved since pressing it
-	  if( active_item == ( get_item_at (clicked_x, clicked_y) ) )
-	    {
-	      //a node was found
-	      if(active_node!=INVALID)
-		{
-                  (mytab.mapstorage).modified = true;
-
-		  std::set<Graph::Edge> edges_to_delete;
-
-		  for(OutEdgeIt e((mytab.mapstorage).graph,active_node);e!=INVALID;++e)
-		    {
-		      edges_to_delete.insert(e);
-		    }
-		  
-		  for(InEdgeIt e((mytab.mapstorage).graph,active_node);e!=INVALID;++e)
-		    {
-		      edges_to_delete.insert(e);
-		    }
-		  
-		  //deleting collected edges
-		  for(std::set<Graph::Edge>::iterator
-			edge_set_it=edges_to_delete.begin();
-		      edge_set_it!=edges_to_delete.end();
-		      ++edge_set_it)
-		    {
-		      deleteItem(*edge_set_it);
-		    }
-		  deleteItem(active_node);
-		}
-	      //a simple edge was chosen
-	      else if (active_edge != INVALID)
-		{
-		  deleteItem(active_edge);
-		}
-	    }
-	  //pointer was moved, deletion is cancelled
-	  else
-	    {
-	      if(active_node!=INVALID)
-		{
-		  *active_item << Gnome::Canvas::Properties::fill_color("blue");
-		}
-	      else if (active_edge != INVALID)
-		{
-		  *active_item << Gnome::Canvas::Properties::fill_color("green");
-		}
-	    }
-	}
-      //reseting datas
-      active_item=NULL;
-      active_edge=INVALID;
-      active_node=INVALID;
-      break;
-
-    case GDK_MOTION_NOTIFY:
-      break;
-
-    default:
-      break;
-    }
-  return false;
-}
-
-bool GraphDisplayerCanvas::mapEditEventHandler(GdkEvent* e)
-{
-  if(actual_tool==MAP_EDIT)
-    {
-      switch(e->type)
-	{
-	case GDK_BUTTON_PRESS:
-	  {
-	    //for determine, whether it was an edge
-	    Edge clicked_edge=INVALID;
-	    //for determine, whether it was a node
-	    Node clicked_node=INVALID;
-
-	    window_to_world (e->button.x, e->button.y, clicked_x, clicked_y);
-	    active_item=(get_item_at(clicked_x, clicked_y));
-
-	    //find the activated item between text of nodes
-	    for (NodeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
-	      {
-		//at the same time only one can be active
-// 		if(nodetextmap[i]==active_item)
-// 		  {
-// 		    clicked_node=i;
-// 		  }
-	      }
-
-	    //if there was not, search for it between nodes
-	    if(clicked_node==INVALID)
-	      {
-		for (NodeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
-		  {
-		    //at the same time only one can be active
-		    if(nodesmap[i]==active_item)
-		      {
-			clicked_node=i;
-		      }
-		  }
-	      }
-
-	    if(clicked_node==INVALID)
-	      {
-		//find the activated item between texts
-		for (EdgeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
-		  {
-		    //at the same time only one can be active
-// 		    if(edgetextmap[i]==active_item)
-// 		      {
-// 			clicked_edge=i;
-// 		      }
-		  }
-
-		//if it was not between texts, search for it between edges
-		if(clicked_edge==INVALID)
-		  {
-		    for (EdgeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
-		      {
-			//at the same time only one can be active
-			if((edgesmap[i]->getLine())==active_item)
-			  {
-			    clicked_edge=i;
-			  }
-		      }
-		  }
-	      }
-
-	    //if it was really a node...
-	    if(clicked_node!=INVALID)
-	      {
-		// the id map is not editable
-		if (nodemap_to_edit == "label") return 0;
-
-		//and there is activated map
-// 		if(nodetextmap[clicked_node]->property_text().get_value()!="")
-// 		  {
-// 		    //activate the general variable for it
-// 		    active_node=clicked_node;
-
-// 		    //create a dialog
-// 		    Gtk::Dialog dialog("Edit value", true);
-// 		    dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
-// 		    dialog.add_button(Gtk::Stock::OK, Gtk::RESPONSE_ACCEPT);
-// 		    Gtk::VBox* vbox = dialog.get_vbox();
-// 		    Gtk::SpinButton spin(0.0, 4);
-// 		    spin.set_increments(1.0, 10.0);
-// 		    spin.set_range(-1000000.0, 1000000.0);
-// 		    spin.set_numeric(true);
-// 		    spin.set_value(atof(nodetextmap[active_node]->property_text().get_value().c_str()));
-// 		    vbox->add(spin);
-// 		    spin.show();
-// 		    switch (dialog.run())
-// 		      {
-// 		      case Gtk::RESPONSE_NONE:
-// 		      case Gtk::RESPONSE_CANCEL:
-// 			break;
-// 		      case Gtk::RESPONSE_ACCEPT:
-// 			double new_value = spin.get_value();
-// 			(*(mytab.mapstorage).nodemap_storage[nodemap_to_edit])[active_node] =
-// 			  new_value;
-// 			std::ostringstream ostr;
-// 			ostr << new_value;
-// 			nodetextmap[active_node]->property_text().set_value(ostr.str());
-// 			//mapwin.updateNode(active_node);
-// 			//mapwin.updateNode(Node(INVALID));
-// 			propertyUpdate(Node(INVALID));
-// 		      }
-// 		  }
-	      }
-	    else
-	      //if it was really an edge...
-	      if(clicked_edge!=INVALID)
-		{
-		  // the id map is not editable
-		  if (edgemap_to_edit == "label") return 0;
-
-		  //and there is activated map
-// 		  if(edgetextmap[clicked_edge]->property_text().get_value()!="")
-// 		    {
-// 		      //activate the general variable for it
-// 		      active_edge=clicked_edge;
-
-// 		      //create a dialog
-// 		      Gtk::Dialog dialog("Edit value", true);
-// 		      dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
-// 		      dialog.add_button(Gtk::Stock::OK, Gtk::RESPONSE_ACCEPT);
-// 		      Gtk::VBox* vbox = dialog.get_vbox();
-// 		      Gtk::SpinButton spin(0.0, 4);
-// 		      spin.set_increments(1.0, 10.0);
-// 		      spin.set_range(-1000000.0, 1000000.0);
-// 		      spin.set_numeric(true);
-// 		      spin.set_value(atof(edgetextmap[active_edge]->property_text().get_value().c_str()));
-// 		      vbox->add(spin);
-// 		      spin.show();
-// 		      switch (dialog.run())
-// 			{
-// 			case Gtk::RESPONSE_NONE:
-// 			case Gtk::RESPONSE_CANCEL:
-// 			  break;
-// 			case Gtk::RESPONSE_ACCEPT:
-// 			  double new_value = spin.get_value();
-// 			  (*(mytab.mapstorage).edgemap_storage[edgemap_to_edit])[active_edge] =
-// 			    new_value;
-// 			  std::ostringstream ostr;
-// 			  ostr << new_value;
-// 			  edgetextmap[active_edge]->property_text().set_value(
-// 									      ostr.str());
-// 			  //mapwin.updateEdge(active_edge);
-// 			  //                   mapwin.updateEdge(Edge(INVALID));
-// 			  propertyUpdate(Edge(INVALID));
-// 			}
-// 		    }
-		}
-	    break;
-	  }
-	default:
-	  break;
-	}
-    }
-  return false;  
-}
-
-void GraphDisplayerCanvas::deleteItem(Node node_to_delete)
-{
-  //  delete(nodetextmap[node_to_delete]);
-  delete(nodesmap[node_to_delete]);
-  (mytab.mapstorage).graph.erase(node_to_delete);
-}
-
-void GraphDisplayerCanvas::deleteItem(Edge edge_to_delete)
-{
-  //  delete(edgetextmap[edge_to_delete]);
-  delete(edgesmap[edge_to_delete]);
-  (mytab.mapstorage).graph.erase(edge_to_delete);
-}
-
-void GraphDisplayerCanvas::textReposition(XY new_place)
-{
-  new_place+=(XY(10,10));
-//   edgetextmap[forming_edge]->property_x().set_value(new_place.x);
-//   edgetextmap[forming_edge]->property_y().set_value(new_place.y);
-}
-
-void GraphDisplayerCanvas::toggleEdgeActivity(EdgeBase* active_bre, bool on)
-{
-  if(on)
-  {
-    if(forming_edge!=INVALID)
-    {
-      std::cerr << "ERROR!!!! Valid edge found!" << std::endl;
-    }
-    else
-    {
-      for (EdgeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
-      {
-        if(edgesmap[i]==active_bre)
-        {
-          forming_edge=i;
-        }
-      }
-    }
-  }
-  else
-    {
-      if(forming_edge!=INVALID)
-	{
-	  forming_edge=INVALID;
-	}
-      else
-	{
-	  std::cerr << "ERROR!!!! Invalid edge found!" << std::endl;
-	}
-    }
-}
-
-void GraphDisplayerCanvas::moveNode(double dx, double dy, Gnome::Canvas::Item * item, Node node)
-{
-  Gnome::Canvas::Item * moved_item=item;
-  Node moved_node=node;
-
-  if(item==NULL && node==INVALID)
-    {
-      moved_item=active_item;
-      moved_node=active_node;
-    }
-  else
-    {
-      isbutton=1;
-    }
-
-  //repositioning node and its text
-  moved_item->move(dx, dy);
-  //  nodetextmap[moved_node]->move(dx, dy);
-
-  // the new coordinates of the centre of the node 
-  double coord_x = dx + (mytab.mapstorage).coords[moved_node].x;
-  double coord_y = dy + (mytab.mapstorage).coords[moved_node].y;
-
-  // write back the new coordinates to the coords map
-  (mytab.mapstorage).coords.set(moved_node, XY(coord_x, coord_y));
-
-  //all the edges connected to the moved point has to be redrawn
-  for(OutEdgeIt ei((mytab.mapstorage).graph,moved_node);ei!=INVALID;++ei)
-    {
-      XY arrow_pos;
-
-      if (mytab.mapstorage.graph.source(ei) == mytab.mapstorage.graph.target(ei))
-	{
-	  arrow_pos = mytab.mapstorage.arrow_pos[ei] + XY(dx, dy);
-	}
-      else
-	{
-	  XY moved_node_1(coord_x - dx, coord_y - dy);
-	  XY moved_node_2(coord_x, coord_y);
-	  Node target = mytab.mapstorage.graph.target(ei);
-	  XY fix_node(mytab.mapstorage.coords[target].x,
-		      mytab.mapstorage.coords[target].y);
-	  XY old_arrow_pos(mytab.mapstorage.arrow_pos[ei]);
-
-	  arrow_pos = calcArrowPos(moved_node_1, moved_node_2, fix_node, old_arrow_pos, isbutton);
-	}
-
-      mytab.mapstorage.arrow_pos.set(ei, arrow_pos);
-      edgesmap[ei]->draw();
-
-      //reposition of edgetext
-      XY text_pos=mytab.mapstorage.arrow_pos[ei];
-      text_pos+=(XY(10,10));
-//       edgetextmap[ei]->property_x().set_value(text_pos.x);
-//       edgetextmap[ei]->property_y().set_value(text_pos.y);
-    }
-
-  for(InEdgeIt ei((mytab.mapstorage).graph,moved_node);ei!=INVALID;++ei)
-    {
-      if (mytab.mapstorage.graph.source(ei) != mytab.mapstorage.graph.target(ei))
-	{
-	  XY moved_node_1(coord_x - dx, coord_y - dy);
-	  XY moved_node_2(coord_x, coord_y);
-	  Node source = mytab.mapstorage.graph.source(ei);
-	  XY fix_node(mytab.mapstorage.coords[source].x,
-		      mytab.mapstorage.coords[source].y);
-	  XY old_arrow_pos(mytab.mapstorage.arrow_pos[ei]);
-
-	  XY arrow_pos;
-	  arrow_pos = calcArrowPos(moved_node_1, moved_node_2, fix_node, old_arrow_pos, isbutton);
-
-	  mytab.mapstorage.arrow_pos.set(ei, arrow_pos);
-	  edgesmap[ei]->draw();
-
-	  //reposition of edgetext
-	  XY text_pos=mytab.mapstorage.arrow_pos[ei];
-	  text_pos+=(XY(10,10));
-// 	  edgetextmap[ei]->property_x().set_value(text_pos.x);
-// 	  edgetextmap[ei]->property_y().set_value(text_pos.y);
-	}
-    }
-}
-
-Gdk::Color GraphDisplayerCanvas::rainbowColorCounter(double min, double max, double w)
-{
-  Gdk::Color color;
-
-  double pos=(w-min)/(max-min);
-  int phase=0;
-
-  //rainbow transitions contain 6 phase
-  //in each phase only one color is changed
-  //first we determine the phase, in which
-  //the actual value belongs to
-  for (int i=0;i<=5;i++)
-    {
-      if(((double)i/6<pos)&&(pos<=(double(i+1)/6)))
-	{
-	  phase=i;
-	}
-    }
-  if(phase<6)
-    {
-      //within its 1/6 long phase the relativ position
-      //determines the power of the color changed in
-      //that phase
-      //we normalize that to one, to be able to give percentage
-      //value for the function
-      double rel_pos=(pos-(phase/6))*6;
-
-      switch(phase)
-	{
-	case 0:
-	  color.set_rgb_p (1, 0, 1-rel_pos);
-	  break;
-	case 1:
-	  color.set_rgb_p (1, rel_pos, 0);
-	  break;
-	case 2:
-	  color.set_rgb_p (1-rel_pos, 1, 0);
-	  break;
-	case 3:
-	  color.set_rgb_p (0, 1, rel_pos);
-	  break;
-	case 4:
-	  color.set_rgb_p (0, 1-rel_pos, 1);
-	  break;
-	case 5:
-	  color.set_rgb_p ((rel_pos/3), 0, 1);
-	  break;
-	default:
-	  std::cout << "Wrong phase: " << phase << " " << pos << std::endl;
-	}
-    }
-  else
-    {
-      std::cout << "Wrong phase: " << phase << " " << pos << std::endl;
-    }
-  return color;
-}
Index: aph_displayer_canvas-node.cc
===================================================================
--- graph_displayer_canvas-node.cc	(revision 204)
+++ 	(revision )
@@ -1,330 +1,0 @@
-/* -*- 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.
- *
- */
-
-#include "graph_displayer_canvas.h"
-#include <cmath>
-
-const int minimum_node_radius=5;
-
-int GraphDisplayerCanvas::changeNodeRadius (std::string mapname, Node node)
-{
-  Graph::NodeMap<double> * actual_map;
-  double min, max;
-  min=(mytab.mapstorage).minOfNodeMap(mapname);
-  max=(mytab.mapstorage).maxOfNodeMap(mapname);
-  actual_map=((mytab.mapstorage).nodemap_storage)[mapname];
-
-  if(node==INVALID)
-    {
-      for (NodeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
-	{
-	  double v=fabs((*actual_map)[i]);
-	  int w;
-	  if(autoscale)
-	    {
-	      if(min==max)
-		{
-		  w=(int)(node_property_defaults[N_RADIUS]);
-		}
-	      else
-		{
-		  w=(int)(minimum_node_radius+(v-min)/(max-min)*(radius_size-minimum_node_radius));
-		}
-	    }
-	  else
-	    {
-	      w=(int)(v*radius_size);
-	    }
-
-	  if(w<minimum_node_radius)
-	    {
-	      w=minimum_node_radius;
-	    }
-
-	  if(zoomtrack)
-	    {
-	      double actual_ppu=get_pixels_per_unit();
-	      w=(int)(w/actual_ppu*fixed_zoom_factor);
-	    }
-
-	  if(w>=0)
-	    {
-	      double x1, y1, x2, y2;
-	      x1=nodesmap[i]->property_x1().get_value();
-	      x2=nodesmap[i]->property_x2().get_value();
-	      y1=nodesmap[i]->property_y1().get_value();
-	      y2=nodesmap[i]->property_y2().get_value();
-	      nodesmap[i]->property_x1().set_value((x1+x2)/2-w);
-	      nodesmap[i]->property_x2().set_value((x1+x2)/2+w);
-	      nodesmap[i]->property_y1().set_value((y1+y2)/2-w);
-	      nodesmap[i]->property_y2().set_value((y1+y2)/2+w);
-	    }
-	}
-    }
-  else
-    {
-      //I think only new nodes use this case
-      //that has no own value, only the default one
-      //int w=(int)(*actual_map)[node];
-      int w=(int)(node_property_defaults[N_RADIUS]);
-      if(w>=0)
-	{
-	  double x1, y1, x2, y2;
-	  x1=nodesmap[node]->property_x1().get_value();
-	  x2=nodesmap[node]->property_x2().get_value();
-	  y1=nodesmap[node]->property_y1().get_value();
-	  y2=nodesmap[node]->property_y2().get_value();
-	  nodesmap[node]->property_x1().set_value((x1+x2)/2-w);
-	  nodesmap[node]->property_x2().set_value((x1+x2)/2+w);
-	  nodesmap[node]->property_y1().set_value((y1+y2)/2-w);
-	  nodesmap[node]->property_y2().set_value((y1+y2)/2+w);
-	}
-    }
-  return 0;
-};
-
-int GraphDisplayerCanvas::resetNodeRadius (Node node)
-{
-  double min, max;
-  min=node_property_defaults[N_RADIUS];
-  max=node_property_defaults[N_RADIUS];
-  Graph::NodeMap<double> actual_map((mytab.mapstorage).graph,node_property_defaults[N_RADIUS]);
-  
-  if(node==INVALID)
-    {
-      for (NodeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
-	{
-	  double v=fabs(actual_map[i]);
-	  int w;
-	  if(min==max)
-	    {
-	      w=(int)(node_property_defaults[N_RADIUS]);
-	    }
-	  else
-	    {
-	      w=(int)(MIN_NODE_RADIUS+(v-min)/(max-min)*(MAX_NODE_RADIUS-MIN_NODE_RADIUS));
-	    }
-	  if(zoomtrack)
-	    {
-	      double actual_ppu=get_pixels_per_unit();
-	      w=(int)(w/actual_ppu*fixed_zoom_factor);
-	    }
-	  if(w>=0)
-	    {
-	      double x1, y1, x2, y2;
-	      x1=nodesmap[i]->property_x1().get_value();
-	      x2=nodesmap[i]->property_x2().get_value();
-	      y1=nodesmap[i]->property_y1().get_value();
-	      y2=nodesmap[i]->property_y2().get_value();
-	      nodesmap[i]->property_x1().set_value((x1+x2)/2-w);
-	      nodesmap[i]->property_x2().set_value((x1+x2)/2+w);
-	      nodesmap[i]->property_y1().set_value((y1+y2)/2-w);
-	      nodesmap[i]->property_y2().set_value((y1+y2)/2+w);
-	    }
-	}
-    }
-  else
-    {
-      //I think only new nodes use this case
-//       int w=(int)actual_map[node];
-      int w=(int)(node_property_defaults[N_RADIUS]);
-      if(w>=0)
-	{
-	  double x1, y1, x2, y2;
-	  x1=nodesmap[node]->property_x1().get_value();
-	  x2=nodesmap[node]->property_x2().get_value();
-	  y1=nodesmap[node]->property_y1().get_value();
-	  y2=nodesmap[node]->property_y2().get_value();
-	  nodesmap[node]->property_x1().set_value((x1+x2)/2-w);
-	  nodesmap[node]->property_x2().set_value((x1+x2)/2+w);
-	  nodesmap[node]->property_y1().set_value((y1+y2)/2-w);
-	  nodesmap[node]->property_y2().set_value((y1+y2)/2+w);
-	}
-    }
-  return 0;
-};
-
-int GraphDisplayerCanvas::changeNodeColor (std::string mapname, Node node)
-{  
-
-  //function maps the range of the maximum and
-  //the minimum of the nodemap to the range of
-  //green in RGB
-
-  Graph::NodeMap<double> * actual_map;
-  actual_map=((mytab.mapstorage).nodemap_storage)[mapname];
-
-  double max, min;
-
-  max=(mytab.mapstorage).maxOfNodeMap(mapname);
-  min=(mytab.mapstorage).minOfNodeMap(mapname);
-
-  if(node==INVALID)
-    {
-
-      for (NodeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
-	{
-	  Gdk::Color color;
-
-	  double w=(*actual_map)[i];
-
-	  if(max!=min)
-	    {
-	      color=rainbowColorCounter(min, max, w);
-	    }
-	  else
-	    {
-	      color.set_rgb_p (0, 0, 1);
-	    }
-
-	  nodesmap[i]->property_fill_color_gdk().set_value(color);
-	}
-    }
-  else
-    {
-      Gdk::Color color;
-
-      double w=(*actual_map)[node];
-
-      if(max!=min)
-	{
-	  color=rainbowColorCounter(min, max, w);
-	}
-      else
-	{
-	  color.set_rgb_p (0, 0, 1);
-	}
-
-      nodesmap[node]->property_fill_color_gdk().set_value(color);
-    }
-  return 0;
-};
-
-int GraphDisplayerCanvas::resetNodeColor (Node node)
-{  
-
-  //function maps the range of the maximum and
-  //the minimum of the nodemap to the range of
-  //green in RGB
-
-  Graph::NodeMap<double> actual_map((mytab.mapstorage).graph,node_property_defaults[N_COLOR]);
-
-  double max, min;
-
-  max=node_property_defaults[N_COLOR];
-  min=node_property_defaults[N_COLOR];
-
-  if(node==INVALID)
-    {
-
-      for (NodeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
-	{
-	  Gdk::Color color;
-
-	  double w=actual_map[i];
-
-	  if(max!=min)
-	    {
-	      color.set_rgb_p (0, 0, 100*(w-min)/(max-min));
-	    }
-	  else
-	    {
-	      color.set_rgb_p (0, 0, 100);
-	    }
-
-	  nodesmap[i]->property_fill_color_gdk().set_value(color);
-	}
-    }
-  else
-    {
-      Gdk::Color color;
-
-      double w=actual_map[node];
-
-      if(max!=min)
-	{
-	  color.set_rgb_p (0, 0, 100*(w-min)/(max-min));
-	}
-      else
-	{
-	  color.set_rgb_p (0, 0, 100);
-	}
-
-      nodesmap[node]->property_fill_color_gdk().set_value(color);
-    }
-  return 0;
-};
-
-int GraphDisplayerCanvas::changeNodeText (std::string mapname, Node node)
-{
-
-  //the number in the map will be written on the node
-  //EXCEPT when the name of the map is Text, because
-  //in that case empty string will be written, because
-  //that is the deleter map
-
-  Graph::NodeMap<double> * actual_map=NULL;
-  actual_map=((mytab.mapstorage).nodemap_storage)[mapname];
-
-  if(node==INVALID)
-    {
-      for (NodeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
-	{
-	  nodemap_to_edit=mapname;
-	  double number=(*actual_map)[i];
-
-	  std::ostringstream ostr;
-	  ostr << number;
-	      
-	  //	  nodetextmap[i]->property_text().set_value(ostr.str());
-	}
-    }
-  else
-    {
-      double number=(*actual_map)[node];
-
-      std::ostringstream ostr;
-      ostr << number;
-	      
-      //      nodetextmap[node]->property_text().set_value(ostr.str());
-    }
-  return 0;
-};
-
-int GraphDisplayerCanvas::resetNodeText (Node node)
-{
-
-  //the number in the map will be written on the node
-  //EXCEPT when the name of the map is Text, because
-  //in that case empty string will be written, because
-  //that is the deleter map
-
-  if(node==INVALID)
-    {
-      for (NodeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
-	{
-	  nodemap_to_edit="";
-	  //	  nodetextmap[i]->property_text().set_value("");
-	}
-    }
-  else
-    {
-      //      nodetextmap[node]->property_text().set_value("");
-    }
-  return 0;
-};
Index: aph_displayer_canvas-zoom.cc
===================================================================
--- graph_displayer_canvas-zoom.cc	(revision 174)
+++ 	(revision )
@@ -1,90 +1,0 @@
-/* -*- 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.
- *
- */
-
-#include "graph_displayer_canvas.h"
-#include <cmath>
-
-void GraphDisplayerCanvas::zoomIn()
-{
-  set_pixels_per_unit(
-      (1.0 + (double) zoom_step / 100.0) * get_pixels_per_unit());
-  if(zoomtrack)
-    {
-      propertyChange(false, N_RADIUS);
-      propertyChange(true, E_WIDTH);
-    }
-}
-
-void GraphDisplayerCanvas::zoomOut()
-{
-  set_pixels_per_unit(
-      (1.0 - (double) zoom_step / 100.0) * get_pixels_per_unit());
-  if(zoomtrack)
-    {
-      propertyChange(true, E_WIDTH);
-      propertyChange(false, N_RADIUS);
-    }
-}
-
-void GraphDisplayerCanvas::zoomFit()
-{
-  updateScrollRegion();
-
-  // get the height and width of the canvas
-  Gtk::Allocation a = get_allocation();
-  int aw = a.get_width();
-  int ah = a.get_height();
-
-  // get the bounding box of the graph
-  update_now();
-  double x1, y1, x2, y2;
-  root()->get_bounds(x1, y1, x2, y2);
-
-  // fit the graph to the window
-  double ppu1 = (double) aw / fabs(x2 - x1);
-  double ppu2 = (double) ah / fabs(y2 - y1);
-  set_pixels_per_unit((ppu1 < ppu2) ? ppu1 : ppu2);
-
-  if(zoomtrack)
-    {
-      propertyChange(true, E_WIDTH);
-      propertyChange(false, N_RADIUS);
-    }
-}
-
-void GraphDisplayerCanvas::zoom100()
-{
-  updateScrollRegion();
-  set_pixels_per_unit(1.0);
-
-  if(zoomtrack)
-    {
-      propertyChange(true, E_WIDTH);
-      propertyChange(false, N_RADIUS);
-    }
-}
-
-void GraphDisplayerCanvas::updateScrollRegion()
-{
-  // get_bounds() yields something sane only when no updates are pending
-  // and it returns a sufficient, not an exact bounding box
-  update_now();
-  double x1, y1, x2, y2;
-  root()->get_bounds(x1, y1, x2, y2);
-  set_scroll_region(x1, y1, x2, y2);
-}
Index: aph_displayer_canvas.cc
===================================================================
--- graph_displayer_canvas.cc	(revision 204)
+++ 	(revision )
@@ -1,433 +1,0 @@
-/* -*- 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.
- *
- */
-
-#include "graph_displayer_canvas.h"
-#include <lemon/random.h>
-#include <cmath>
-
-GraphDisplayerCanvas::GraphDisplayerCanvas(NoteBookTab & mainw) :
-  nodesmap(mainw.mapstorage.graph), edgesmap(mainw.mapstorage.graph), edgetextmap(mainw.mapstorage.graph),
-  nodetextmap(mainw.mapstorage.graph), displayed_graph(*(root()), 0, 0),
-  isbutton(0), active_item(NULL), target_item(NULL), nodemap_to_edit(""),
-  edgemap_to_edit(""), autoscale(true), zoomtrack(false), radius_size(20), edge_width(10),
-  was_redesigned(false), is_drawn(false), mytab(mainw),
-  background_set(false)
-{
-  //add mouse scroll event handler - it won't be changed, it handles zoom
-  signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::scrollEventHandler), false);
-
-  //base event handler is move tool
-  actual_handler=signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::moveEventHandler), false);
-  actual_tool=MOVE;
-
-
-  active_node=INVALID;
-  active_edge=INVALID;
-  forming_edge=INVALID;
-
-  setBackground();
-}
-
-void GraphDisplayerCanvas::setBackground()
-{
-  if (background_set)
-  {
-    delete background;
-  }
-  if (mytab.mapstorage.isBackgroundSet())
-  {
-    background_set = true;
-    refBackground = Gdk::Pixbuf::create_from_file(
-      mytab.mapstorage.getBackgroundFilename());
-    background = new Gnome::Canvas::Pixbuf(
-        *(root()),
-        0.0 - refBackground->get_width() / 2.0,
-        0.0 - refBackground->get_height() / 2.0,
-        refBackground);
-    background->lower_to_bottom();
-  }
-  else
-  {
-    background_set = false;
-  }
-}
-
-GraphDisplayerCanvas::~GraphDisplayerCanvas()
-{
-  for (NodeIt n((mytab.mapstorage).graph); n != INVALID; ++n)
-    {
-      delete nodesmap[n];
-      //      delete nodetextmap[n];
-    }
-  
-  for (EdgeIt e((mytab.mapstorage).graph); e != INVALID; ++e)
-    {
-      delete edgesmap[e];
-      //      delete edgetextmap[e];
-    }
-}
-
-void GraphDisplayerCanvas::propertyChange(bool itisedge, int prop)
-{
-  if(itisedge)
-    {
-      propertyUpdate(Edge(INVALID), prop);
-    }
-  else
-    {
-      propertyUpdate(Node(INVALID), prop);
-    }
-}
-
-void GraphDisplayerCanvas::propertyUpdate(Edge edge)
-{
-  for(int i=0;i<EDGE_PROPERTY_NUM;i++)
-    {
-      propertyUpdate(edge, i);
-    }
-}
-
-void GraphDisplayerCanvas::propertyUpdate(Node node)
-{
-  for(int i=0;i<NODE_PROPERTY_NUM;i++)
-    {
-      propertyUpdate(node, i);
-    }
-}
-
-void GraphDisplayerCanvas::propertyUpdate(Node node, int prop)
-{
-  std::string mapname=mytab.getActiveNodeMap(prop);
-
-  if(is_drawn)
-    {
-      if(mapname!="")
-	{
-	  if( ( ((mytab.mapstorage).nodemap_storage).find(mapname) != ((mytab.mapstorage).nodemap_storage).end() ) )
-	    {
-	      switch(prop)
-		{
-		case N_RADIUS:
-		  changeNodeRadius(mapname, node);
-		  break;
-		case N_COLOR:
-		  changeNodeColor(mapname, node);
-		  break;
-		case N_TEXT:
-		  changeNodeText(mapname, node);
-		  break;
-		default:
-		  std::cerr<<"Error\n";
-		}
-	    }
-	}
-      else //mapname==""
-	{
-	  Node node=INVALID;	
-	  switch(prop)
-	    {
-	    case N_RADIUS:
-	      resetNodeRadius(node);
-	      break;
-	    case N_COLOR:
-	      resetNodeColor(node);
-	      break;
-	    case N_TEXT:
-	      resetNodeText(node);
-	      break;
-	    default:
-	      std::cerr<<"Error\n";
-	    }
-	}
-    }
-}
-
-void GraphDisplayerCanvas::propertyUpdate(Edge edge, int prop)
-{
-  std::string mapname=mytab.getActiveEdgeMap(prop);
-
-  if(is_drawn)
-    {
-      if(mapname!="")
-	{
-	  if( ( ((mytab.mapstorage).edgemap_storage).find(mapname) != ((mytab.mapstorage).edgemap_storage).end() ) )
-	    {
-	      switch(prop)
-		{
-		case E_WIDTH:
-		  changeEdgeWidth(mapname, edge);
-		  break;
-		case E_COLOR:
-		  changeEdgeColor(mapname, edge);
-		  break;
-		case E_TEXT:
-		  changeEdgeText(mapname, edge);
-		  break;
-		default:
-		  std::cerr<<"Error\n";
-		}
-	    }
-	}
-      else //mapname==""
-	{
-	  switch(prop)
-	    {
-	    case E_WIDTH:
-	      resetEdgeWidth(edge);
-	      break;
-	    case E_COLOR:
-	      resetEdgeColor(edge);
-	      break;
-	    case E_TEXT:
-	      resetEdgeText(edge);
-	      break;
-	    default:
-	      std::cerr<<"Error\n";
-	    }
-	}
-    }
-}
-
-void GraphDisplayerCanvas::drawGraph()
-{
-  //first edges are drawn, to hide joining with nodes later
-
-  for (EdgeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
-  {
-    if (mytab.mapstorage.graph.source(i) == mytab.mapstorage.graph.target(i))
-    {
-      edgesmap[i]=new LoopEdge(displayed_graph, i, *this);
-    }
-    else
-    {
-      edgesmap[i]=new BrokenEdge(displayed_graph, i, *this);
-    }
-    //initializing edge-text as well, to empty string
-
-    XY text_pos=mytab.mapstorage.arrow_pos[i];
-    text_pos+=(XY(10,10));
-
-//     edgetextmap[i]=new Gnome::Canvas::Text(displayed_graph, text_pos.x, text_pos.y, "");
-//     edgetextmap[i]->property_fill_color().set_value("darkgreen");
-//     edgetextmap[i]->signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::mapEditEventHandler), false);
-//     edgetextmap[i]->raise_to_top();
-  }
-
-  //afterwards nodes come to be drawn
-
-  for (NodeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
-  {
-    //drawing bule nodes, with black line around them
-
-    nodesmap[i]=new Gnome::Canvas::Ellipse(
-        displayed_graph,
-        (mytab.mapstorage).coords[i].x-20,
-        (mytab.mapstorage).coords[i].y-20,
-        (mytab.mapstorage).coords[i].x+20,
-        (mytab.mapstorage).coords[i].y+20);
-    *(nodesmap[i]) << Gnome::Canvas::Properties::fill_color("blue");
-    *(nodesmap[i]) << Gnome::Canvas::Properties::outline_color("black");
-    nodesmap[i]->raise_to_top();
-
-    //initializing edge-text as well, to empty string
-
-    XY text_pos(
-        ((mytab.mapstorage).coords[i].x+node_property_defaults[N_RADIUS]+5),
-        ((mytab.mapstorage).coords[i].y+node_property_defaults[N_RADIUS]+5));
-
-//     nodetextmap[i]=new Gnome::Canvas::Text(displayed_graph,
-//         text_pos.x, text_pos.y, "");
-//     nodetextmap[i]->property_fill_color().set_value("darkblue");
-//     nodetextmap[i]->signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::mapEditEventHandler), false);
-//     nodetextmap[i]->raise_to_top();
-  }
-
-  is_drawn=true;
-
-  //upon drawing graph
-  //properties have to
-  //be set in as well
-  for(int i=0;i<NODE_PROPERTY_NUM;i++)
-    {
-      propertyUpdate(Node(INVALID), i);
-    }
-
-  for(int i=0;i<EDGE_PROPERTY_NUM;i++)
-    {
-      propertyUpdate(Edge(INVALID), i);
-    }
-
-  updateScrollRegion();
-}
-
-void GraphDisplayerCanvas::clear()
-{
-  active_node=INVALID;
-  active_edge=INVALID;
-  forming_edge=INVALID;
-
-  for (NodeIt n((mytab.mapstorage).graph); n != INVALID; ++n)
-  {
-    delete nodesmap[n];
-    //    delete nodetextmap[n];
-  }
-
-  for (EdgeIt e((mytab.mapstorage).graph); e != INVALID; ++e)
-  {
-    delete edgesmap[e];
-    //    delete edgetextmap[e];
-  }
-
-  is_drawn=false;
-}
-
-void GraphDisplayerCanvas::setView(bool autoscale_p, bool zoomtrack_p, double width_p, double radius_p)
-{
-  autoscale=autoscale_p;
-  edge_width=width_p;
-  radius_size=radius_p;
-
-  if((!zoomtrack) && zoomtrack_p)
-    {
-      fixed_zoom_factor=get_pixels_per_unit();
-    }
-
-  zoomtrack=zoomtrack_p;
-
-  propertyChange(false, N_RADIUS);
-  propertyChange(true, E_WIDTH);
-}
-
-void GraphDisplayerCanvas::getView(bool & autoscale_p, bool & zoomtrack_p, double& width_p, double& radius_p)
-{
-  autoscale_p=autoscale;
-  zoomtrack_p=zoomtrack;
-  width_p=edge_width;
-  radius_p=radius_size;
-}
-
-void GraphDisplayerCanvas::reDesignGraph()
-{
-  double max_coord=50000;
-  double min_dist=20;
-  double init_vector_length=25;
-
-  if(!was_redesigned)
-    {
-      NodeIt i((mytab.mapstorage).graph);
-
-      dim2::Point<double> init(init_vector_length*rnd(),
-			       init_vector_length*rnd());
-      moveNode(init.x, init.y, nodesmap[i], i);
-      was_redesigned=true;
-    }
-
-  double attraction;
-  double propulsation;
-  int iterations;
-
-  (mytab.mapstorage).get_design_data(attraction, propulsation, iterations);
-
-  //iteration counter
-  for(int l=0;l<iterations;l++)
-    {
-      Graph::NodeMap<double> x(mytab.mapstorage.graph);
-      Graph::NodeMap<double> y(mytab.mapstorage.graph);
-      XYMap<Graph::NodeMap<double> > actual_forces;
-      actual_forces.setXMap(x);
-      actual_forces.setYMap(y);
-
-      //count actual force for each nodes
-      for (NodeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
-	{
-	  //propulsation of nodes
-	  for (NodeIt j((mytab.mapstorage).graph); j!=INVALID; ++j)
-	    {
-	      if(i!=j)
-		{
-		  lemon::dim2::Point<double> delta =
-		    ((mytab.mapstorage).coords[i]-
-		     (mytab.mapstorage).coords[j]);
-
-		  const double length_sqr=std::max(delta.normSquare(),min_dist);
-
-		  //normalize vector
-		  delta/=sqrt(length_sqr);
-
-		  //calculating propulsation strength
-		  //greater distance menas smaller propulsation strength
-		  delta*=propulsation/length_sqr;
-		    
-		  actual_forces.set(i,(actual_forces[i]+delta));
-		}
-	    }
-	  //attraction of nodes, to which actual node is bound
-	  for(OutEdgeIt ei((mytab.mapstorage).graph,i);ei!=INVALID;++ei)
-	    {
-	      lemon::dim2::Point<double> delta =
-		((mytab.mapstorage).coords[i]-
-		 (mytab.mapstorage).coords[mytab.mapstorage.
-					   graph.target(ei)]);
-		
-		//calculating attraction strength
-		//greater distance means greater strength
-		delta*=attraction;
-		
-		actual_forces.set(i,actual_forces[i]-delta);
-	    }
-	  for(InEdgeIt ei((mytab.mapstorage).graph,i);ei!=INVALID;++ei)
-	    {
-	      lemon::dim2::Point<double> delta =
-		((mytab.mapstorage).coords[i]-
-		 (mytab.mapstorage).coords[mytab.mapstorage.
-					   graph.source(ei)]);
-		
-		//calculating attraction strength
-		//greater distance means greater strength
-		delta*=attraction;
-		
-		actual_forces.set(i,actual_forces[i]-delta);
-	    }
-	}
-      for (NodeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)
-	{
-	  if(((mytab.mapstorage).coords[i].x)+actual_forces[i].x>max_coord)
-	    {
-	      actual_forces[i].x=max_coord-((mytab.mapstorage).coords[i].x);
-	      std::cout << "Correction! " << (((mytab.mapstorage).coords[i].x)+actual_forces[i].x) << std::endl;
-	    }
-	  else if(((mytab.mapstorage).coords[i].x)+actual_forces[i].x<(0-max_coord))
-	    {
-	      actual_forces[i].x=0-max_coord-((mytab.mapstorage).coords[i].x);
-	      std::cout << "Correction! " << (((mytab.mapstorage).coords[i].x)+actual_forces[i].x) << std::endl;
-	    }
-	  if(((mytab.mapstorage).coords[i].y)+actual_forces[i].y>max_coord)
-	    {
-	      actual_forces[i].y=max_coord-((mytab.mapstorage).coords[i].y);
-	      std::cout << "Correction! " << (((mytab.mapstorage).coords[i].y)+actual_forces[i].y) << std::endl;
-	    }
-	  else if(((mytab.mapstorage).coords[i].y)+actual_forces[i].y<(0-max_coord))
-	    {
-	      actual_forces[i].y=0-max_coord-((mytab.mapstorage).coords[i].y);
-	      std::cout << "Correction! " << (((mytab.mapstorage).coords[i].y)+actual_forces[i].y) << std::endl;
-	    }
-	  moveNode(actual_forces[i].x, actual_forces[i].y, nodesmap[i], i);
-	}
-    }
-}
-
Index: aph_displayer_canvas.h
===================================================================
--- graph_displayer_canvas.h	(revision 187)
+++ 	(revision )
@@ -1,454 +1,0 @@
-/* -*- 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 GRAPH_DISPLAYER_CANVAS_H
-#define GRAPH_DISPLAYER_CANVAS_H
-
-class GraphDisplayerCanvas;
-
-#include "all_include.h"
-#include "nbtab.h"
-#include <libgnomecanvasmm.h>
-#include <libgnomecanvasmm/polygon.h>
-#include <lemon/dim2.h>
-
-///This class is the canvas, on which the graph can be drawn.
-class GraphDisplayerCanvas : public Gnome::Canvas::CanvasAA
-{
-  friend class BrokenEdge;
-  friend class LoopEdge;
-
-  class EdgeBase : public Gnome::Canvas::Group
-  {
-    protected:
-      ///Reference to the canvas, on which the graph is drawn.
-
-      ///It is needed, because some datas needed from
-      ///graph can be accessed by this or should be sent
-      ///as parameter, but it would be complicated
-      GraphDisplayerCanvas& canvas;
-
-      ///The edge that the class displays.
-
-      ///It is needed, because some datas needed from
-      ///graph can be accessed by this or should be sent
-      ///as parameter, but it would be complicated
-      Edge edge;
-
-      Gnome::Canvas::Polygon arrow;
-
-      void drawArrow(XY);
-    public:
-      EdgeBase(Gnome::Canvas::Group&, Edge, GraphDisplayerCanvas&);
-      virtual ~EdgeBase();
-      virtual void draw() = 0;
-      virtual void setLineWidth(int) = 0;
-      virtual void setFillColor(Gdk::Color) = 0;
-      virtual Gnome::Canvas::Item * getLine() = 0;
-  };
-
-  ///Edge displayer class
-
-  ///This class is responsible for displaying edges in graph.
-  ///The displayed edge is broken in the middle. The
-  ///aim of this is to be able to indicate direction of edges
-  ///and to be able to display more then one edges between the
-  ///same source and target
-  class BrokenEdge : public EdgeBase
-  {
-    private:
-      Gnome::Canvas::Line line;
-
-      ///Indicates whether the button of mouse is pressed or not at the moment.
-      bool isbutton;
-
-      ///At this location was the mousebutton pressed. Horizontal component.
-
-      ///It helps to calculate the
-      ///distance of dragging.
-      double clicked_x;
-
-      ///At this location was the mousebutton pressed. Vertical component.
-
-      ///It helps to calculate the
-      ///distance of dragging.
-      double clicked_y;
-
-      ///event handler for forming broken edges
-
-      ///\param event the
-      ///event to handle
-      bool edgeFormerEventHandler(GdkEvent* event);
-
-    public:
-      ///Constructor of broken edge class.
-
-      ///\param g the group to which the edge belongs
-      ///\param _edge the represented edge
-      ///\param gc the canvas
-      BrokenEdge(Gnome::Canvas::Group&, Edge, GraphDisplayerCanvas&);
-
-      ///Destructor of broken edge class
-
-      ///Frees up
-      ///reserved memory
-      ~BrokenEdge();
-
-      ///The function that draws the edge based on collected data
-      void draw();
-
-      void setLineWidth(int);
-      void setFillColor(Gdk::Color);
-
-      Gnome::Canvas::Item * getLine() { return (Gnome::Canvas::Item *)(&line); };
-  };
-
-  class LoopEdge : public EdgeBase
-  {
-    private:
-      Gnome::Canvas::Ellipse line;
-      bool edgeFormerEventHandler(GdkEvent* e);
-      bool isbutton;
-    public:
-      LoopEdge(Gnome::Canvas::Group&, Edge, GraphDisplayerCanvas&);
-      ~LoopEdge();
-      void draw();
-      void setLineWidth(int);
-      void setFillColor(Gdk::Color);
-      Gnome::Canvas::Item * getLine() { return (Gnome::Canvas::Item *)(&line); };
-  };
-
-  ///Type of canvas, on which the graph is drawn
-  typedef Gnome::Canvas::CanvasAA Parent;
-
-public:
-  ///Constructor
-
-  ///\param nbt the tab of the window, in which the graph is displayed
-  GraphDisplayerCanvas(NoteBookTab & nbt);
-
-  ///destructor of the class
-  virtual ~GraphDisplayerCanvas();
-
-  ///Returns a color of the rainbow based on a map value and the min and max value of the given map
-
-  ///min and max is purple, between them there is a linear assign
-  Gdk::Color rainbowColorCounter(double, double, double);
-
-  ///Changes the width of edge(s) according to the given map.
-
-  ///\param mapname is the name of the map which contains the values to be set
-  ///\param edge if it is given, only the width of the given edge will be set, instead of all of them.
-  int changeEdgeWidth (std::string mapname, Edge edge=INVALID);
-
-  ///Resets width of edge(s) to the default value
-
-  ///\param edge if it is given, only the width of the
-  ///given edge will be reset, instead of all of them.
-  int resetEdgeWidth (Edge edge=INVALID);
-
-  ///Changes the color of edge(s) according to the given map.
-
-  ///\param mapname is the name of the map which contains the new values
-  ///\param edge if it is given, only the color of the given edge will be set, instead of all of them.
-  int changeEdgeColor (std::string mapname, Edge edge=INVALID);
-
-  ///Resets color of edge(s) to the default value
-
-  ///\param edge if it is given, only the color of the
-  ///given edge will be reset, instead of all of them.
-  int resetEdgeColor (Edge edge=INVALID);
-
-  ///Changes the label of edge(s) according to the given map.
-
-  ///\param mapname is the name of the map which contains the new values
-  ///\param edge if it is given, only the label of the given edge will be set, instead of all of them.
-  int changeEdgeText (std::string mapname, Edge edge=INVALID);
-
-  ///Resets label of edge(s) to the default value
-
-  ///\param edge if it is given, only the color of the
-  ///given edge will be reset, instead of all of them.
-  int resetEdgeText (Edge edge=INVALID);
-
-  ///Changes the radius of node(s) according to the given map.
-
-  ///\param mapname is the name of the map which contains the new values
-  ///\param node if it is given, only the radius of the given node will be set, instead of all of them.
-  int changeNodeRadius (std::string mapname, Node node=INVALID);
-
-  ///Resets radius of node(s) to the default value
-
-  ///\param node if it is given, only the radius of the
-  ///given node will be reset, instead of all of them.
-  int resetNodeRadius (Node node=INVALID);
-
-  ///Changes the color of node(s) according to the given map.
-
-  ///\param mapname is the name of the map which contains the new values
-  ///\param node if it is given, only the color of the given node will be set, instead of all of them.
-  int changeNodeColor (std::string mapname, Node node=INVALID);
-
-  ///Resets color of node(s) to the default value
-
-  ///\param node if it is given, only the color of the
-  ///given node will be reset, instead of all of them.
-  int resetNodeColor (Node node=INVALID);
-
-  ///Changes the label of node(s) according to the given map.
-
-  ///\param mapname is the name of the map which contains the new values
-  ///\param node if it is given, only the label of the given node will be set, instead of all of them.
-  int changeNodeText (std::string mapname, Node node=INVALID);
-
-  ///Resets label of node(s) to the default value
-
-  ///\param node if it is given, only the label of the
-  ///given node will be reset, instead of all of them.
-  int resetNodeText (Node node=INVALID);
-
-  ///This function is called, when any of the displayed attributes have to be updated, or changed
-
-  ///\param itisedge if true, edge property has to be changed, else node property
-  ///\param prop the id of property that has to changed or updated
-  void propertyChange(bool itisedge, int prop);
-
-  ///updates the given property
-
-  ///\param edge if it is not INVALID, only the property of the given edge will be updated, instead of all of them
-  ///\param prop the property to update
-  void propertyUpdate(Edge edge, int prop);
-
-  ///updates the given property
-
-  ///\param node if it is not INVALID, only the property of the given node will be updated, instead of all of them
-  ///\param prop the property to update
-  void propertyUpdate(Node node, int prop);
-
-  ///updates all the property for the given edge
-  void propertyUpdate(Edge);
-
-  ///updates all the property for the given node
-  void propertyUpdate(Node);
-
-  ///Callback for 'ViewZoomIn' action.
-  virtual void zoomIn();
-  ///Callback for 'ViewZoomOut' action.
-  virtual void zoomOut();
-  ///Callback for 'ViewZoomFit' action.
-  virtual void zoomFit();
-  ///Callback for 'ViewZoom100' action.
-  virtual void zoom100();
-  ///Sets the scroll region of the convas to the bounding box of the graph.
-  void updateScrollRegion();
-
-  ///This function changes the tool in the graph-editor's hand
-  void changeEditorialTool(int);
-
-protected:
-
-  //maximizing, minimizing, restoring window, etc.
-  virtual bool on_expose_event(GdkEventExpose *);
-
-private:
-
-  ///This function is responsible for the correct
-  ///reaction of any action happened in the territory
-  ///of the canvas
-  ///DEPRECATED!!!!
-  bool eventHandler(GdkEvent* e, Node n);
-
-  ///actual event handler
-  ///
-  ///Actual event handler should be stored, to be able to disconnect it and later reconnect it.
-  sigc::connection actual_handler;
-
-  ///event handler for the case when move-tool is active
-  bool moveEventHandler(GdkEvent*);
-  ///event handler for the case when create_node-tool is active
-  bool createNodeEventHandler(GdkEvent*);
-  ///event handler for the case when create_edge-tool is active
-  bool createEdgeEventHandler(GdkEvent*);
-  ///event handler for the case when eraser-tool is active
-  bool eraserEventHandler(GdkEvent*);
-  ///event handler for the case when map editor tool is active
-  bool mapEditEventHandler(GdkEvent*);
-  ///event handler for the case when user scrolls the mouse
-  bool scrollEventHandler(GdkEvent*);
-
-private:
-  ///moves node according to the given parameters
-  void moveNode(double, double,  Gnome::Canvas::Item * item=NULL, Node node=INVALID);
-
-public:
-  ///Moves the text to new place
-  void textReposition(XY);
-
-  ///Activates an edge belonging to an EdgeBase
-
-  ///After we have activated an edge this way,
-  ///the GDC object will know, which edge is under forming
-  ///therefore it can redraw the necessary elements on the canvas,
-  ///for example the text belonging to the \ref EdgeBase can be
-  ///redrawn (\ref textReposition).
-  void toggleEdgeActivity(EdgeBase*, bool);
-
-public:
-
-  ///Returns the actual tool in hand
-  int getActualTool();
-
-  ///Sets node representation settings
-  void setView(bool, bool, double, double);
-
-  ///Gets node representation settings
-  void getView(bool &, bool &, double&, double&);
-
-  ///draws the graph
-
-  ///Called when opening a file.
-  void drawGraph();
-
-  ///Clears the canvas
-
-  ///It achieves this by deleting all data
-  ///structure used to help handle the displayed graph.
-  void clear();
-
-  ///creates a new Nodemap
-
-  ///\param init initial value of the map
-  ///\param mapname name of new map
-  int addNewNodeMap(double init,std::string mapname);
-  ///creates a new Edgemap
-
-  ///\param init initial value of the map
-  ///\param mapname name of new map
-  int addNewEdgeMap(double init,std::string mapname);
-
-  void reDesignGraph();
-
-  ///Show whether the graph is already drawn.
-  bool is_drawn;
-
-private:
-  ///Deletes the given element.
-  void deleteItem(Node);
-  ///Deletes the given element.
-  void deleteItem(Edge);
-
-private:
-
-  ///Map of nodes of graph
-  Graph::NodeMap<Gnome::Canvas::Ellipse *> nodesmap;
-
-  ///Map of edges of graph
-  Graph::EdgeMap<EdgeBase*> edgesmap;
-
-  ///Map of texts to write on edges
-  Graph::EdgeMap<Gnome::Canvas::Text *> edgetextmap;
-
-  ///Map of texts to write on nodes
-  Graph::NodeMap<Gnome::Canvas::Text *> nodetextmap;
-
-  ///Group of graphical elements of displayed_graph
-  Gnome::Canvas::Group displayed_graph;
-
-private:
-  ///Indicates whether the button of mouse is pressed or not
-  int isbutton;
-
-  ///Stores the actual tool in hand
-  int actual_tool;
-
-  ///At this location was the mousebutton pressed.
-  ///It helps to calculate the distance of dragging.
-  double clicked_x, clicked_y;
-
-  ///Remembers which Gnome::Canvas::Item was pressed.
-
-  ///this variable is needed, to work on it after selection
-  Gnome::Canvas::Item * active_item;
-
-  ///Remembers which Gnome::Canvas::Item was pressed.
-
-  ///this variable is used at edge creation, it will
-  ///be the secondly selected node. No local variable
-  ///can be used for this purpose inside the function,
-  ///because the node selected by button press, and
-  ///the edge is created by button release. Both of
-  ///them is different function call.
-  Gnome::Canvas::Item * target_item;
-
-  ///selected node (for any editing)
-  Node active_node;
-
-  ///selected edge (for any editing)
-  Edge active_edge;
-
-  ///the edge that is selected by clicking on the red arrow in the middle of it
-
-  ///This edge is stored only for the purpose of reshape it.
-  ///That is why it is selected in a different manner.
-  Edge forming_edge;
-
-  ///Map displayed by label can be edited.
-  std::string nodemap_to_edit;
-
-  ///Map displayed by label can be edited.
-  std::string edgemap_to_edit;
-
-  static const int zoom_step = 5;
-
-  ///Is node radius autoscaled
-  bool autoscale;
-  
-  ///Should we track zoomfactor changes
-  bool zoomtrack;
-
-  ///to store the zoom factor when it was "fixed"
-  double fixed_zoom_factor;
-  
-  ///Node radius size
-  double radius_size;
-
-  ///Edge width
-  double edge_width;
-
-  ///Was redesign run on this graph already?
-  ///
-  ///If not, the layout will be modified randomly
-  ///to avoid frozen layout because of wrong
-  ///initial state
-  bool was_redesigned;
-  
-private:
-
-  ///reference to the container, in which the canvas is
-  NoteBookTab & mytab;
-
-  XY calcArrowPos(XY, XY, XY, XY, int);
-
-  bool background_set;
-  Glib::RefPtr<Gdk::Pixbuf> refBackground;
-  Gnome::Canvas::Pixbuf *background;
-public:
-  void setBackground();
-};
-
-#endif //GRAPH_DISPLAYER_CANVAS_H
Index: aphocska.lgf
===================================================================
--- graphocska.lgf	(revision 126)
+++ 	(revision )
@@ -1,39 +1,0 @@
-@nodeset
-label	coordinates_x	coordinates_y data
-1	230	-80	1.123
-2	230	100	3.234
-3	120	-80	5.345
-4	120	100	7.456
-5	20	100	9.567
-6	20	-80	11.678
-7	-40	10	13.789
-8	-100	100	15.890
-9	-100	10	17.901
-10	-100	-80	19.012
-11	-200	-80	21.000
-12	-200	10	23.001
-13	-200	100	25.003
-14	-300	100	27.004
-15	-300	-80	29.9999
-
-@edgeset
-	        cap	map1	map2	map3	map4
-15	14	1	21	111	231	3
-14	13	2	22	112	232	6
-13	12	3	23	113	233	9
-13	8	4	24	114	234	12
-12	11	5	25	115	235	15
-12	9	6	26	116	236	18
-11	10	7	27	117	237	21
-10	9	8	28	118	238	24
-10	7	9	29	119	239	27
-9	8	10	30	120	230	30
-7	6	11	31	121	241	33
-6	5	12	32	122	242	36
-6	3	13	33	123	243	39
-5	4	14	34	124	244	42
-4	3	15	35	125	245	45
-3	2	16	36	126	246	48
-2	1	17	37	127	247	51
-
-@end
Index: i_reader.cc
===================================================================
--- gui_reader.cc	(revision 177)
+++ 	(revision )
@@ -1,81 +1,0 @@
-/* -*- 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.
- *
- */
-
-#include "gui_reader.h"
-#include "xml.h"
-#include "mapstorage.h"
-#include <lemon/dim2.h>
-#include <vector>
-
-bool GuiReader::header(const std::string& line)
-{
-  std::istringstream ls(line);
-  std::string head;
-  ls >> head;
-  return head == "@gui";
-}
-
-void GuiReader::read(std::istream& is)
-{
-  XmlIo x(is);
-  std::map<int, XY > m;
-  x("arrow_pos", m);
-
-  if ((int)m.size() == countEdges(mapstorage->graph))
-    {
-      for (EdgeIt e(mapstorage->graph); e != INVALID; ++e)
-	{
-	  int edgeid = (int)(*mapstorage->edgemap_storage["label"])[e];
-	  mapstorage->arrow_pos.set(e, m[edgeid]);
-	}
-      mapstorage->ArrowPosReadOK();
-    }
-  
-  std::map<int, std::string> nm;
-  x("active_nodemaps", nm);
-
-  for(int i=0;i<NODE_PROPERTY_NUM;i++)
-    {
-      mapstorage->changeActiveMap(false, i, nm[i]);
-    }
-
-  std::map<int, std::string> em;
-  x("active_edgemaps", em);
-  for(int i=0;i<EDGE_PROPERTY_NUM;i++)
-    {
-      mapstorage->changeActiveMap(true, i, em[i]);
-    }
-
-  double attraction;
-  double propulsation;
-  int iteration;
-
-  x("redesign-attraction", attraction);
-  x("redesign-propulsation", propulsation);
-  x("redesign-iteration", iteration);
-
-  mapstorage->set_attraction(attraction);
-  mapstorage->set_propulsation(propulsation);
-  mapstorage->set_iteration(iteration);
-
-  mapstorage->redesign_data_changed();
-}
-
-GuiReader::GuiReader(LemonReader& reader, MapStorage* ms) : Parent(reader), mapstorage(ms)
-{
-}
Index: i_reader.h
===================================================================
--- gui_reader.h	(revision 174)
+++ 	(revision )
@@ -1,39 +1,0 @@
-/* -*- 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 GUI_READER_H
-#define GUI_READER_H
-
-#include "mapstorage.h"
-#include <lemon/lemon_reader.h>
-
-using lemon::LemonReader;
-
-class GuiReader : public LemonReader::SectionReader
-{
-  private:
-    MapStorage* mapstorage;
-  protected:
-    virtual bool header(const std::string&);
-    virtual void read(std::istream&);
-  public:
-    typedef LemonReader::SectionReader Parent;
-    GuiReader(LemonReader&, MapStorage*);
-};
-
-#endif
Index: i_writer.cc
===================================================================
--- gui_writer.cc	(revision 177)
+++ 	(revision )
@@ -1,68 +1,0 @@
-/* -*- 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.
- *
- */
-
-#include "gui_writer.h"
-#include "xml.h"
-#include "mapstorage.h"
-#include <lemon/dim2.h>
-#include <vector>
-
-std::string GuiWriter::header()
-{
-  return "@gui";
-}
-
-void GuiWriter::write(std::ostream& os)
-{
-  XmlIo x(os);
-  std::map<int, XY > m;
-  for (EdgeIt e(mapstorage->graph); e != INVALID; ++e)
-  {
-    int edgeid = (int)(*(mapstorage->edgemap_storage["label"]))[e];
-    m[edgeid] = mapstorage->arrow_pos[e];
-  }
-  x("arrow_pos", m);
-
-  std::map<int, std::string> nm;
-  for(int i=0;i<NODE_PROPERTY_NUM;i++)
-    {
-      nm[i]=mapstorage->active_nodemaps[i];
-    }
-  x("active_nodemaps", nm);
-
-  std::map<int, std::string> em;
-  for(int i=0;i<EDGE_PROPERTY_NUM;i++)
-    {
-      em[i]=mapstorage->active_edgemaps[i];
-    }
-  x("active_edgemaps", em);
-
-  double attraction;
-  double propulsation;
-  int iteration;
-
-  mapstorage->get_design_data(attraction, propulsation, iteration);
-
-  x("redesign-attraction", attraction);
-  x("redesign-propulsation", propulsation);
-  x("redesign-iteration", iteration);
-}
-
-GuiWriter::GuiWriter(LemonWriter& writer, MapStorage* ms) : Parent(writer), mapstorage(ms)
-{
-}
Index: i_writer.h
===================================================================
--- gui_writer.h	(revision 174)
+++ 	(revision )
@@ -1,39 +1,0 @@
-/* -*- 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 GUI_WRITER_H
-#define GUI_WRITER_H
-
-#include "mapstorage.h"
-#include <lemon/lemon_writer.h>
-
-using lemon::LemonWriter;
-
-class GuiWriter : public LemonWriter::SectionWriter
-{
-  private:
-    MapStorage* mapstorage;
-  protected:
-    virtual std::string header();
-    virtual void write(std::ostream&);
-  public:
-    typedef LemonWriter::SectionWriter Parent;
-    GuiWriter(LemonWriter&, MapStorage*);
-};
-
-#endif
Index: 8n.h
===================================================================
--- i18n.h	(revision 133)
+++ 	(revision )
@@ -1,7 +1,0 @@
-#ifndef I18N_H
-#define I18N_H
-
-#include "gettext.h"
-#define _(string) gettext (string)
-
-#endif
Index: uskalbox.cc
===================================================================
--- kruskalbox.cc	(revision 174)
+++ 	(revision )
@@ -1,79 +1,0 @@
-/* -*- 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.
- *
- */
-
-#include <kruskalbox.h>
-
-enum {INPUT, OUTPUT, MAP_NUM};
-
-KruskalBox::KruskalBox(std::vector<std::string> t):AlgoBox()
-{
-  init(t);
-}
-    
-void KruskalBox::run()
-{
-  if(
-     tabcbt.get_active_text()!="" &&
-     (edgemapcbts[INPUT])->get_active_text()!="" &&
-     (edgemapcbts[OUTPUT])->get_active_text()!=""
-     )
-    {
-
-      const Graph &g=mapstorage->graph;
-      Graph::EdgeMap<double> * inputmap=
-	((mapstorage->edgemap_storage)[(edgemapcbts[INPUT])->get_active_text()]);
-      Graph::EdgeMap<bool> outputmap(g);
-      double res=kruskal(g, *inputmap, outputmap);
-
-      for (EdgeIt i(g); i!=INVALID; ++i)
-	{
-	  if(outputmap[i])
-	    {
-	      (*((mapstorage->edgemap_storage)[(edgemapcbts[OUTPUT])->
-					       get_active_text()]))[i]=1;
-	    }
-	  else
-	    {
-	      (*((mapstorage->edgemap_storage)[(edgemapcbts[OUTPUT])->
-					       get_active_text()]))[i]=0;
-	    }
-	}
-
-      std::ostringstream o;
-      o << "Result: " << res;
-      resultlabel.set_text(o.str());
-
-      mapstorage->mapChanged(true, (edgemapcbts[OUTPUT])->get_active_text());
-      //   mapstorage->changeActiveMap(true, E_COLOR,
-      // 			      (edgemapcbts[OUTPUT])->get_active_text());
-      //   mapstorage->changeActiveMap(true, E_TEXT,
-      // 			      (edgemapcbts[INPUT])->get_active_text());
-  
-    }
-}
-    
-void KruskalBox::build_box()
-{
-  std::vector<std::string> empty_vector;
-
-  addMapSelector("Edgecosts: ", true);
-  addMapSelector("Edges of tree here: ", true);
-
-  resultlabel.set_text("Result: algorithm is not run yet.");
-  pack_start(resultlabel);
-}
Index: uskalbox.h
===================================================================
--- kruskalbox.h	(revision 174)
+++ 	(revision )
@@ -1,60 +1,0 @@
-/* -*- 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 KRUSKALBOX_H
-#define KRUSKALBOX_H
-
-class KruskalBox;
-
-#include <all_include.h>
-#include <algobox.h>
-#include <lemon/kruskal.h>
-#include <libgnomecanvasmm.h>
-#include <libgnomecanvasmm/polygon.h>
-
-///Graphical interface to run Kruskal algorithm.
-
-///Child of \ref AlgoBox,
-///therefore the only task to do at implementation was to
-///
-///-call init function with correct parameters from correctly parametrized constructor
-///
-///-implement \ref build_box function
-///
-///-implement \ref run function
-class KruskalBox : public AlgoBox
-{
-  ///Shows result of Kruskal algorithm
-  Gtk::Label resultlabel;
-
-public:
-  ///Calls \ref AlgoBox::init function to initialize class properly, automatically.
-  KruskalBox(std::vector<std::string> t);
-
-  ///Prepare, run and postprocess Kruskal algorithm.
-
-  ///\ref glemon works only with maps filled with double values
-  ///at the moment. While Kruskal nedds a bool map as output.
-  ///As postprocess this bool map should be transformed to
-  ///double map.
-  void run();
-
-  ///Builds the graphical design of the interface.
-  void build_box();
-};
-#endif //KRUSKALBOX_H
Index: Makefile.am
===================================================================
--- m4/Makefile.am	(revision 139)
+++ 	(revision )
@@ -1,30 +1,0 @@
-EXTRA_DIST = \
-	codeset.m4 \
-	gettext.m4 \
-	glibc21.m4 \
-	glibc2.m4 \
-	iconv.m4 \
-	intdiv0.m4 \
-	intmax.m4 \
-	inttypes_h.m4 \
-	inttypes.m4 \
-	inttypes-pri.m4 \
-	isc-posix.m4 \
-	lcmessage.m4 \
-	lib-ld.m4 \
-	lib-link.m4 \
-	lib-prefix.m4 \
-	longdouble.m4 \
-	longlong.m4 \
-	nls.m4 \
-	po.m4 \
-	printf-posix.m4 \
-	progtest.m4 \
-	signed.m4 \
-	size_max.m4 \
-	stdint_h.m4 \
-	uintmax_t.m4 \
-	ulonglong.m4 \
-	wchar_t.m4 \
-	wint_t.m4 \
-	xsize.m4
Index: in_win.cc
===================================================================
--- main_win.cc	(revision 184)
+++ 	(revision )
@@ -1,592 +1,0 @@
-/* -*- 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.
- *
- */
-
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#include "main_win.h"
-#include "guipixbufs.h"
-#include "background_chooser_dialog.h"
-
-#include "i18n.h"
-
-MainWin::MainWin()
-{
-  set_title ("no file");
-  set_default_size(WIN_WIDTH,WIN_HEIGHT);
-  //add(vbox);
-  add(table);
-
-  // custom icons for the toolbar
-  Glib::RefPtr<Gtk::IconFactory> p_icon_factory = Gtk::IconFactory::create();
- 
-  Glib::RefPtr<Gdk::Pixbuf> p_move_pixbuf = Gdk::Pixbuf::create_from_inline(
-      2328, gui_icons_move);
-  Glib::RefPtr<Gdk::Pixbuf> p_addnode_pixbuf = Gdk::Pixbuf::create_from_inline(
-      2328, gui_icons_addnode);
-  Glib::RefPtr<Gdk::Pixbuf> p_addlink_pixbuf = Gdk::Pixbuf::create_from_inline(
-      2328, gui_icons_addlink);
-  Glib::RefPtr<Gdk::Pixbuf> p_delete_pixbuf = Gdk::Pixbuf::create_from_inline(
-      2328, gui_icons_delete);
-  Glib::RefPtr<Gdk::Pixbuf> p_editlink_pixbuf = Gdk::Pixbuf::create_from_inline(
-      2328, gui_icons_editlink);
-  Glib::RefPtr<Gdk::Pixbuf> p_newmap_pixbuf = Gdk::Pixbuf::create_from_inline(
-      2328, gui_icons_newmap);
-
-  Gtk::IconSource move_icon_source;
-  move_icon_source.set_pixbuf(p_move_pixbuf);
-  Gtk::IconSet move_icon_set;
-  move_icon_set.add_source(move_icon_source);
-  p_icon_factory->add(Gtk::StockID("gd-move"), move_icon_set);
-
-  Gtk::IconSource addnode_icon_source;
-  addnode_icon_source.set_pixbuf(p_addnode_pixbuf);
-  Gtk::IconSet addnode_icon_set;
-  addnode_icon_set.add_source(addnode_icon_source);
-  p_icon_factory->add(Gtk::StockID("gd-addnode"), addnode_icon_set);
-
-  Gtk::IconSource addlink_icon_source;
-  addlink_icon_source.set_pixbuf(p_addlink_pixbuf);
-  Gtk::IconSet addlink_icon_set;
-  addlink_icon_set.add_source(addlink_icon_source);
-  p_icon_factory->add(Gtk::StockID("gd-addlink"), addlink_icon_set);
-
-  Gtk::IconSource delete_icon_source;
-  delete_icon_source.set_pixbuf(p_delete_pixbuf);
-  Gtk::IconSet delete_icon_set;
-  delete_icon_set.add_source(delete_icon_source);
-  p_icon_factory->add(Gtk::StockID("gd-delete"), delete_icon_set);
-
-  Gtk::IconSource editlink_icon_source;
-  editlink_icon_source.set_pixbuf(p_editlink_pixbuf);
-  Gtk::IconSet editlink_icon_set;
-  editlink_icon_set.add_source(editlink_icon_source);
-  p_icon_factory->add(Gtk::StockID("gd-editlink"), editlink_icon_set);
-
-  Gtk::IconSource newmap_icon_source;
-  newmap_icon_source.set_pixbuf(p_newmap_pixbuf);
-  Gtk::IconSet newmap_icon_set;
-  newmap_icon_set.add_source(newmap_icon_source);
-  p_icon_factory->add(Gtk::StockID("gd-newmap"), newmap_icon_set);
-
-  p_icon_factory->add_default();
-  
-  ag=Gtk::ActionGroup::create();
-
-  ag->add( Gtk::Action::create("FileMenu", _("_File")) );
-  ag->add( Gtk::Action::create("FileNew", Gtk::Stock::NEW),
-      sigc::mem_fun(*this, &MainWin::newTab));
-  ag->add( Gtk::Action::create("FileOpen", Gtk::Stock::OPEN),
-      sigc::mem_fun(*this, &MainWin::openFile));
-  ag->add( Gtk::Action::create("FileClearTab", _("Clear Tab")),
-      sigc::mem_fun(*this, &MainWin::newFile));
-  ag->add( Gtk::Action::create("FileSave", Gtk::Stock::SAVE),
-      sigc::mem_fun(*this, &MainWin::saveFile));
-  ag->add( Gtk::Action::create("FileSaveAs", Gtk::Stock::SAVE_AS),
-      sigc::mem_fun(*this, &MainWin::saveFileAs));
-  ag->add( Gtk::Action::create("Close", Gtk::Stock::CLOSE),
-      sigc::mem_fun(*this, &MainWin::closeTab));
-  ag->add( Gtk::Action::create("Quit", Gtk::Stock::QUIT),
-      sigc::mem_fun(*this, &MainWin::hide));
-
-  ag->add( Gtk::Action::create("ViewMenu", _("_View")) );
-  ag->add( Gtk::Action::create("ViewZoomIn", Gtk::Stock::ZOOM_IN),
-      sigc::mem_fun(*this, &MainWin::zoomIn));
-  ag->add( Gtk::Action::create("ViewZoomOut", Gtk::Stock::ZOOM_OUT),
-      sigc::mem_fun(*this, &MainWin::zoomOut));
-  ag->add( Gtk::Action::create("ViewZoomFit", Gtk::Stock::ZOOM_FIT),
-      sigc::mem_fun(*this, &MainWin::zoomFit));
-  ag->add( Gtk::Action::create("ViewZoom100", Gtk::Stock::ZOOM_100),
-      sigc::mem_fun(*this, &MainWin::zoom100));
-  ag->add( Gtk::Action::create("SetBackground", _("Set Background...")),
-	    sigc::mem_fun(*this, &MainWin::createBackgroundChooser));
-  
-  ag->add( Gtk::Action::create("ShowMenu", _("_Show")) );
-  ag->add( Gtk::Action::create("ShowMaps", _("_Maps")),
-	   sigc::mem_fun(*this, &MainWin::createMapWin));
-  ag->add( Gtk::Action::create("ShowDesign", _("_Design")),
-	   sigc::mem_fun(*this, &MainWin::createDesignWin));
-
-  ag->add( Gtk::Action::create("AlgoMenu", _("_Algorithms")) );
-  ag->add( Gtk::Action::create("AlgoGeneral", _("_General")),
-	   sigc::bind( sigc::mem_fun ( *this, &MainWin::createAlgoWin ), 0) );
-  ag->add( Gtk::Action::create("AlgoKruskal", _("_Kruskal")),
-	   sigc::bind( sigc::mem_fun ( *this, &MainWin::createAlgoWin ), 1) );
-  ag->add( Gtk::Action::create("AlgoDijkstra", _("_Dijkstra")),
-	   sigc::bind( sigc::mem_fun ( *this, &MainWin::createAlgoWin ), 2) );
-  ag->add( Gtk::Action::create("AlgoSuurballe", _("_Suurballe")),
-	   sigc::bind( sigc::mem_fun ( *this, &MainWin::createAlgoWin ), 3) );
-
-  Gtk::RadioAction::Group tool_group;
-  ag->add( Gtk::RadioAction::create(tool_group, "MoveItem", Gtk::StockID("gd-move"), _("Move")),
-      sigc::bind( sigc::mem_fun ( *this, &MainWin::changeEditorialTool ), 0) );
-  ag->add( Gtk::RadioAction::create(tool_group, "CreateNode", Gtk::StockID("gd-addnode"), _("Create node")),
-      sigc::bind( sigc::mem_fun ( *this, &MainWin::changeEditorialTool ), 1) );
-  ag->add( Gtk::RadioAction::create(tool_group, "CreateEdge", Gtk::StockID("gd-addlink"), _("Create edge")),
-      sigc::bind( sigc::mem_fun ( *this, &MainWin::changeEditorialTool ), 2) );
-  ag->add( Gtk::RadioAction::create(tool_group, "EraseItem", Gtk::StockID("gd-delete"), _("Delete")),
-      sigc::bind( sigc::mem_fun ( *this, &MainWin::changeEditorialTool ), 3) );
-
-  ag->add( Gtk::RadioAction::create(tool_group, "EditEdgeMap", Gtk::StockID("gd-editlink"), _("Edit edge map")),
-      sigc::bind( sigc::mem_fun ( *this, &MainWin::changeEditorialTool ), 4) );
-
-  ag->add( Gtk::Action::create("AddMap", Gtk::StockID("gd-newmap")),
-      sigc::mem_fun ( *this , &MainWin::createNewMapWin ) );
-
-  ag->add( Gtk::Action::create("DesignGraph", Gtk::Stock::REFRESH),
-      sigc::mem_fun ( *this , &MainWin::reDesignGraph ) );
-
-  uim=Gtk::UIManager::create();
-  uim->insert_action_group(ag);
-  add_accel_group(uim->get_accel_group());
-
-  try
-  {
-
-    Glib::ustring ui_info =
-      "<ui>"
-      "  <menubar name='MenuBar'>"
-      "    <menu action='FileMenu'>"
-      "      <menuitem action='FileNew'/>"
-      "      <menuitem action='FileOpen'/>"
-      "      <menuitem action='FileClearTab'/>"
-      "      <menuitem action='FileSave'/>"
-      "      <menuitem action='FileSaveAs'/>"
-      "      <menuitem action='Close'/>"
-      "      <menuitem action='Quit'/>"
-      "    </menu>"
-      "    <menu action='ViewMenu'>"
-      "      <menuitem action='ViewZoomIn' />"
-      "      <menuitem action='ViewZoomOut' />"
-      "      <menuitem action='ViewZoom100' />"
-      "      <menuitem action='ViewZoomFit' />"
-      "      <menuitem action='SetBackground' />"
-      "    </menu>"
-      "    <menu action='ShowMenu'>"
-      "      <menuitem action='ShowMaps'/>"
-      "      <menuitem action='ShowDesign'/>"
-      "    </menu>"
-      "    <menu action='AlgoMenu'>"
-      "      <menuitem action='AlgoGeneral'/>"
-      "      <menuitem action='AlgoKruskal'/>"
-      "      <menuitem action='AlgoDijkstra'/>"
-      "      <menuitem action='AlgoSuurballe'/>"
-      "    </menu>"
-      "  </menubar>"
-      "  <toolbar name='ToolBar'>"
-      "    <toolitem action='FileNew' />"
-      "    <toolitem action='FileOpen' />"
-      "    <toolitem action='FileSave' />"
-      "    <toolitem action='Close' />"
-      "    <separator />"
-      "    <toolitem action='ViewZoomIn' />"
-      "    <toolitem action='ViewZoomOut' />"
-      "    <toolitem action='ViewZoom100' />"
-      "    <toolitem action='ViewZoomFit' />"
-      "    <separator />"
-      "    <toolitem action='MoveItem' />"
-      "    <toolitem action='CreateNode' />"
-      "    <toolitem action='CreateEdge' />"
-      "    <toolitem action='EraseItem' />"
-      "    <toolitem action='EditEdgeMap' />"
-      "    <separator />"
-      "    <toolitem action='AddMap' />"
-      "    <toolitem action='DesignGraph' />"
-      "  </toolbar>"
-      "</ui>";
-
-    uim->add_ui_from_string(ui_info);
-
-  }
-  catch(const Glib::Error& ex)
-  {
-    std::cerr << "building menus failed: " <<  ex.what();
-  }
-
-  Gtk::Widget* menubar = uim->get_widget("/MenuBar");
-  if (menubar){
-    //vbox.pack_start(*menubar, Gtk::PACK_SHRINK);
-    table.attach(*menubar, 0, 1, 0, 1, Gtk::EXPAND|Gtk::FILL, Gtk::SHRINK);
-  }
-
-  Gtk::Widget* toolbar = uim->get_widget("/ToolBar");
-  if (toolbar)
-  {
-    static_cast<Gtk::Toolbar*>(toolbar)->set_toolbar_style(Gtk::TOOLBAR_ICONS);
-    //hbox.pack_start(*toolbar, Gtk::PACK_EXPAND_WIDGET);
-
-    table.attach(*toolbar, 0, 1, 1, 2, Gtk::EXPAND|Gtk::FILL, Gtk::SHRINK);
-
-  }
- 
-  table2.set_row_spacings(10);
-  table2.set_col_spacings(5);
-
-  auto_scale = new Gtk::CheckButton("Autoscale");
-  auto_scale->set_active(false);
-  auto_scale->signal_toggled().connect(sigc::mem_fun(*this, &MainWin::nodeViewChanged));
-  table2.attach(*auto_scale, 0,2,0,1);
-
-  Gtk::Label * width_label= new Gtk::Label("Edge Width:");
-  table2.attach(*width_label, 0,1,1,2);
-  
-  Gtk::Adjustment * adjustment_width=new Gtk::Adjustment(20, 1, 200, 5, 10);
-  
-  edge_width = new Gtk::SpinButton(*adjustment_width, 5,0);
-  edge_width->signal_value_changed().connect(sigc::mem_fun(*this, &MainWin::nodeViewChanged));
-  table2.attach(*edge_width, 1,2,1,2);
-
-  Gtk::Label * radius_label= new Gtk::Label("Node Radius:");
-  table2.attach(*radius_label, 2,3,1,2);
-  
-  Gtk::Adjustment * adjustment_radius=new Gtk::Adjustment(20, 0, 500, 5, 10);
-
-  radius_size = new Gtk::SpinButton(*adjustment_radius, 5,0);
-  radius_size->signal_value_changed().connect(sigc::mem_fun(*this, &MainWin::nodeViewChanged));
-  table2.attach(*radius_size, 3,4,1,2);
-
-  zoom_track = new Gtk::CheckButton("Zoom tracking");
-  zoom_track->set_active(false);
-  zoom_track->signal_toggled().connect(sigc::mem_fun(*this, &MainWin::nodeViewChanged));
-  table2.attach(*zoom_track, 2,4,0,1);
-
-
-  table.attach(table2, 1, 2, 0, 2, Gtk::SHRINK, Gtk::SHRINK);
-
-  tooltips.set_tip(*(uim->get_widget("/ToolBar/CreateNode")),"Create Node");
-  tooltips.enable();
-
-  active_tab=-1;
-  notebook.signal_switch_page().connect(sigc::mem_fun(*this, &MainWin::onChangeTab));
-
-  active_tool = MOVE;
-
-  table.attach(notebook,0,2,2,3, Gtk::EXPAND|Gtk::FILL, Gtk::EXPAND|Gtk::FILL);
-  
-  show_all_children();
-}
-
-void MainWin::set_tabtitle(std::string name)
-{
-  if(strinst.find(name)==strinst.end())
-    {
-      tabnames[active_tab]=name;
-      strinst[name]=1;
-    }
-  else
-    {
-      strinst[name]++;
-      std::ostringstream o;
-      o << strinst[name];
-      tabnames[active_tab]=name+" - "+o.str();
-    }
-  set_title(tabnames[active_tab] + " - " + prog_name);
-  notebook.set_tab_label_text((Widget&)*(tabs[active_tab]), tabnames[active_tab]);
-  updateAlgoWinTabs();
-}
-
-void MainWin::readFile(const std::string & filename)
-{
-  newTab();
-  tabs[active_tab]->readFile(filename);
-}
-
-void MainWin::newTab()
-{
-  int size=tabs.size();
-  tabs.resize(size+1);
-  tabnames.resize(size+1);
-  active_tab=size;
-  tabs[active_tab]=new NoteBookTab();
-  tabs[active_tab]->signal_title_ch().connect(sigc::mem_fun(*this, &MainWin::set_tabtitle));
-  tabs[active_tab]->signal_newmap_needed().connect(sigc::mem_fun(*this, &MainWin::createNewMapWinAfterSignal));
-  tabs[active_tab]->gd_canvas->changeEditorialTool(active_tool);
-  notebook.append_page((Gtk::Widget&)(*(tabs[active_tab])));
-  notebook.set_current_page(size);
-  set_tabtitle(_("unsaved file"));
-  updateAlgoWinTabs();
-}
-
-void MainWin::closeTab()
-{
-  if(active_tab!=-1)
-    {
-      if (tabs[active_tab]->mapstorage.modified)
-	{
-	  Gtk::MessageDialog mdialog(_("<b>Save changes before closing?</b>"), true, 
-				     Gtk::MESSAGE_WARNING, Gtk::BUTTONS_NONE);
-	  mdialog.add_button(_("Close file _without Saving"), Gtk::RESPONSE_REJECT);
-	  mdialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
-	  mdialog.add_button(Gtk::Stock::SAVE, Gtk::RESPONSE_ACCEPT);
-	  switch (mdialog.run())
-	    {
-	    case Gtk::RESPONSE_CANCEL:
-	      return;
-	    case Gtk::RESPONSE_REJECT:
-	      break;
-	    case Gtk::RESPONSE_ACCEPT:
-	      tabs[active_tab]->saveFile();
-	      break;
-	    }
-	}
-      //tabs vector will be decreased with the deleted value
-      int size=tabs.size();
-      if(size>1)
-	{
-	  for(int i=active_tab+1;i<size;i++)
-	    {
-	      tabnames[i-1]=tabnames[i];
-	      tabs[i-1]=tabs[i];
-	    }
-	}
-      //if size==1 resize will delete the only element
-      tabs.resize(size-1);
-      tabnames.resize(size-1);
-
-      int old_active_tab=active_tab;
-      notebook.remove_page(active_tab);
-
-      //If the first tab was active, upon delete notebook
-      //will first switch one tab upper and not lower like
-      //in the case, when not the first tab was active.
-      //But after deletion it will become the first tab,
-      //and this should be registrated in tabs vector,
-      //as well.
-      if((old_active_tab==0)&&(size!=1))
-	{
-	  onChangeTab(NULL,0);
-	}
-
-      //if this was the last page in notebook, there is
-      //no active_tab now
-      if(size==1)
-	{
-	  active_tab=-1;
-	}
-
-      updateAlgoWinTabs();
-    }
-}
-
-void MainWin::onChangeTab(GtkNotebookPage* page, guint page_num)
-{
-  page=page;
-  active_tab=page_num;
-  tabs[active_tab]->gd_canvas->changeEditorialTool(active_tool);
-  set_title(tabnames[active_tab]);
-  bool autoscale;
-  bool zoomtrack;
-  double width;
-  double radius;
-  tabs[active_tab]->getView(autoscale, zoomtrack, width, radius);
-  edge_width->set_value(width);
-  radius_size->set_value(radius);
-  zoom_track->set_active(zoomtrack);
-  auto_scale->set_active(autoscale);
-
-}
-
-void MainWin::newFile()
-{
-  if(active_tab!=-1)
-    {
-      tabs[active_tab]->newFile();
-    }
-}
- 
-void MainWin::openFile()
-{
-  if(active_tab==-1)
-    {
-      newTab();
-    }
-  tabs[active_tab]->openFile();
-}
- 
-void MainWin::saveFile()
-{
-  if(active_tab!=-1)
-    {
-      tabs[active_tab]->saveFile();
-    }
-}
- 
-void MainWin::saveFileAs()
-{
-  if(active_tab!=-1)
-    {
-      tabs[active_tab]->saveFileAs();
-    }
-}
- 
-void MainWin::close()
-{
-  if(active_tab!=-1)
-    {
-      tabs[active_tab]->close();
-    }
-}
-
-void MainWin::zoomIn()
-{
-  if(active_tab!=-1)
-    {
-      tabs[active_tab]->gd_canvas->zoomIn();
-    }
-}
-
-void MainWin::zoomOut()
-{
-  if(active_tab!=-1)
-    {
-      tabs[active_tab]->gd_canvas->zoomOut();
-    }
-}
-
-void MainWin::zoomFit()
-{
-  if(active_tab!=-1)
-    {
-      tabs[active_tab]->gd_canvas->zoomFit();
-    }
-}
-
-void MainWin::zoom100()
-{
-  if(active_tab!=-1)
-    {
-      tabs[active_tab]->gd_canvas->zoom100();
-    }
-}
-
-void MainWin::createMapWin()
-{
-  if(active_tab!=-1)
-    {
-      tabs[active_tab]->createMapWin(tabnames[active_tab]);
-    }
-}
-
-void MainWin::createDesignWin()
-{
-  if(active_tab!=-1)
-    {
-      tabs[active_tab]->createDesignWin(tabnames[active_tab]);
-    }
-}
-
-void MainWin::createAlgoWin(int algoid)
-{
-  AlgoWin * aw=new AlgoWin(algoid, tabnames);
-  aw->signal_closing().connect(sigc::mem_fun(*this, &MainWin::deRegisterAlgoWin));
-  aw->signal_maplist_needed().connect(sigc::mem_fun(*this, &MainWin::updateAlgoWinMaps));
-  aw->signal_newmapwin_needed().connect(sigc::mem_fun(*this, &MainWin::createNewMapWinTabString));
-  aws.insert(aw);
-  aw->show();
-}
-
-void MainWin::updateAlgoWinTabs()
-{
-  std::set< AlgoWin* >::iterator awsi=aws.begin();
-  for(;awsi!=aws.end();awsi++)
-    {
-      (*awsi)->update_tablist(tabnames);
-    }
-}
-
-void MainWin::updateAlgoWinMaps(AlgoWin * awp, std::string tabname)
-{
-  int i=0;
-  for(;(i<(int)tabnames.size())&&(tabnames[i]!=tabname);i++)
-    {
-    }
-  awp->update_maplist(&(tabs[i]->mapstorage));
-}
-
-void MainWin::deRegisterAlgoWin(AlgoWin * awp)
-{
-  aws.erase(awp);
-}
-
-void MainWin::changeEditorialTool(int tool)
-{
-  active_tool=tool;
-  if(active_tab!=-1)
-    {
-      tabs[active_tab]->gd_canvas->changeEditorialTool(tool);
-    }
-}
-
-void MainWin::createNewMapWin()
-{
-  if(active_tab!=-1)
-    {
-      NewMapWin * nmw=new NewMapWin(_("Create New Map - ")+tabnames[active_tab], *(tabs[active_tab]));
-      nmw->show();
-    }
-}
-
-void MainWin::createNewMapWinTabString(std::string tabname, bool itisedge)
-{
-  int i=0;
-  for(;((i<(int)tabnames.size())&&(tabnames[i]!=tabname));i++)
-    {
-    }
-  createNewMapWinAfterSignal(tabs[i], itisedge);
-}
-
-void MainWin::createNewMapWinAfterSignal(NoteBookTab * nbt, bool itisedge)
-{
-  std::vector<NoteBookTab*>::iterator nbti=tabs.begin();
-  int i=0;
-  for(;nbti!=tabs.end();nbti++)
-    {
-      if(*nbti!=nbt)
-	{
-	  i++;
-	}
-      else
-	{
-	  continue;
-	}
-    }
-  NewMapWin * nmw=new NewMapWin(_("Create New Map - ")+tabnames[i], *nbt, itisedge, false);
-  nmw->run();
-}
-
-
-void MainWin::nodeViewChanged()
-{
-  double width=edge_width->get_value();
-  double radius=radius_size->get_value();
-  bool zoomtrack=zoom_track->get_active();
-  bool autoscale=auto_scale->get_active();
-  tabs[active_tab]->setView(autoscale, zoomtrack, width, radius);
-}
-
-void MainWin::reDesignGraph()
-{
-  tabs[active_tab]->reDesignGraph();
-}
-
-void MainWin::createBackgroundChooser()
-{
-  BackgroundChooserDialog dialog(&(tabs[active_tab]->mapstorage));
-  dialog.run();
-}
Index: in_win.h
===================================================================
--- main_win.h	(revision 184)
+++ 	(revision )
@@ -1,268 +1,0 @@
-/* -*- 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 "algowin.h"
-#include "map_win.h"
-#include "new_map_win.h"
-#include "nbtab.h"
-#include <libgnomecanvasmm.h>
-#include <libgnomecanvasmm/polygon.h>
-
-
-///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 graphs 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, * edge_width;
-
-  ///The notebook that has tabs (\ref NoteBookTab) with different graphs.
-  Gtk::Notebook notebook;
-
-  ///The tool selected to manipulate graph.
-
-  ///It has to be stored, because in case of tabswitching
-  ///the correct tool has to be set for the actual graph.
-  int active_tool;
-
-  ///The number of active tab in the notebook.
-  int active_tab;
-
-  ///Vector of existing tabs in the notebook.
-  std::vector<NoteBookTab *> 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<std::string> 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<std::string, int> 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 graphs are drawn.
-  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<Gtk::ActionGroup> ag;
-
-  ///UIManager for menu
-  Glib::RefPtr<Gtk::UIManager> 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 GraphDisplayerCanvas
-  virtual void zoomIn();
-  ///Callback for 'zoomOut' action.
-
-  ///It calls the appropriate function in
-  ///\ref GraphDisplayerCanvas
-  virtual void zoomOut();
-  ///Callback for 'zoomFit' action.
-
-  ///It calls the appropriate function in
-  ///\ref GraphDisplayerCanvas
-  virtual void zoomFit();
-  ///Callback for 'zoom100' action.
-
-  ///It calls the appropriate function in
-  ///\ref GraphDisplayerCanvas
-  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 graph 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 graph-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 graph-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 edgemap 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 itisedge true if edgemap has to be created, false if nodemap
-  virtual void createNewMapWinAfterSignal(NoteBookTab * nbt, bool itisedge);
-
-  ///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 edgemap or a nodemap.
-  ///\ref tabname the tab in which the new map has to be placed
-  ///\ref itisedge true if the new map will be edge map, false if it will be nodemap
-  virtual void createNewMapWinTabString(std::string tabname, bool itisedge);
-
-  ///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 edge 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 reDesignGraph();
-
-  void createBackgroundChooser();
-};
-
-#endif //MAIN_WIN_H
Index: p_win.cc
===================================================================
--- map_win.cc	(revision 174)
+++ 	(revision )
@@ -1,157 +1,0 @@
-/* -*- 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.
- *
- */
-
-#include "map_win.h"
-#include <set>
-
-bool MapWin::closeIfEscapeIsPressed(GdkEventKey* e)
-{
-  if(e->keyval==GDK_Escape)
-  {
-    mytab.closeMapWin();
-    //    hide();
-  }
-  return true;
-}
-
-MapWin::MapWin(const std::string& title, std::vector<std::string> eml, std::vector<std::string> nml, NoteBookTab & mw):mytab(mw)
-{
-  set_title(title);
-  set_default_size(200, 50);
-
-  set_resizable(false);
-
-  signal_key_press_event().connect(sigc::mem_fun(*this, &MapWin::closeIfEscapeIsPressed));
-
-  mytab.signal_title_ch().connect(sigc::mem_fun(*this, &MapWin::set_title));
-
-  e_combo_array=new MapSelector * [EDGE_PROPERTY_NUM];
-
-  table=new Gtk::Table(EDGE_PROPERTY_NUM, 1, false);
-
-  for(int i=0;i<EDGE_PROPERTY_NUM;i++)
-  {
-    e_combo_array[i]=new MapSelector(eml, mytab.getActiveEdgeMap(i), edge_property_strings[i], true);
-
-    (*table).attach((*(e_combo_array[i])),0,1,i,i+1,Gtk::SHRINK,Gtk::SHRINK,10,3);
-
-    e_combo_array[i]->signal_cbt_ch().connect(sigc::bind(sigc::mem_fun(*this, &MapWin::edgeMapChanged), i));
-    e_combo_array[i]->signal_newmapwin_needed().connect(sigc::mem_fun(*this, &MapWin::newMapWinNeeded));
-  }
-
-  vbox.pack_start(*(new Gtk::Label("Edge properties")));
-
-  vbox.pack_start(*table);
-
-  vbox.pack_start(*(new Gtk::HSeparator));
-
-  n_combo_array=new MapSelector * [NODE_PROPERTY_NUM];
-
-  table=new Gtk::Table(NODE_PROPERTY_NUM, 1, false);
-
-  for(int i=0;i<NODE_PROPERTY_NUM;i++)
-  {
-    n_combo_array[i]=new MapSelector(nml, mytab.getActiveNodeMap(i), node_property_strings[i], false);
-
-    (*table).attach((*(n_combo_array[i])),0,1,i,i+1,Gtk::SHRINK,Gtk::SHRINK,10,3);
-
-    n_combo_array[i]->signal_cbt_ch().connect(sigc::bind(sigc::mem_fun(*this, &MapWin::nodeMapChanged), i));
-    n_combo_array[i]->signal_newmapwin_needed().connect(sigc::mem_fun(*this, &MapWin::newMapWinNeeded));
-  }
-
-  add(vbox);
-
-  vbox.pack_start(*(new Gtk::Label("Node properties")));
-
-  vbox.pack_start(*table);
-
-  show_all_children();
-
-}
-
-void MapWin::nodeMapChanged(std::string mapname, int prop)
-{
-  mytab.propertyChange(false, prop, mapname);
-}
-
-void MapWin::edgeMapChanged(std::string mapname, int prop)
-{
-  mytab.propertyChange(true, prop, mapname);
-}
-
-void MapWin::newMapWinNeeded(bool itisedge)
-{
-  mytab.popupNewMapWin(itisedge);
-}
-
-void MapWin::update(std::vector<std::string> eml, std::vector<std::string> nml)
-{
-  for(int i=0;i<EDGE_PROPERTY_NUM;i++)
-  {
-    e_combo_array[i]->update_list(eml);
-  }
-
-  for(int i=0;i<NODE_PROPERTY_NUM;i++)
-  {
-    n_combo_array[i]->update_list(nml);
-  }
-
-  mytab.active_maps_needed();
-}
-
-void MapWin::registerNewEdgeMap(std::string newmapname)
-{
-  for(int i=0;i<EDGE_PROPERTY_NUM;i++)
-  {
-    //filling in combo box with choices
-    e_combo_array[i]->append_text((Glib::ustring)newmapname);
-  }
-}
-
-void MapWin::registerNewNodeMap(std::string newmapname)
-{
-  for(int i=0;i<NODE_PROPERTY_NUM;i++)
-  {
-    //filling in combo box with choices
-    n_combo_array[i]->append_text((Glib::ustring)newmapname);
-  }
-}
-
-bool MapWin::on_delete_event(GdkEventAny * event)
-{
-  event=event;
-  mytab.closeMapWin();
-  return true;
-}
-
-void MapWin::changeEntry(bool isitedge, int prop, std::string mapname)
-{
-  if(isitedge)
-    {
-      e_combo_array[prop]->set_active_text(mapname);
-    }
-  else
-    {
-      n_combo_array[prop]->set_active_text(mapname);
-    }
-}
-
-void MapWin::set_title(std::string tabname)
-{
-  Gtk::Window::set_title("Map Setup - "+tabname);
-}
Index: p_win.h
===================================================================
--- map_win.h	(revision 174)
+++ 	(revision )
@@ -1,137 +1,0 @@
-/* -*- 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 MAP_WIN_H
-#define MAP_WIN_H
-
-class MapWin;
-
-#include <all_include.h>
-#include <nbtab.h>
-#include <mapselector.h>
-#include <libgnomecanvasmm.h>
-#include <libgnomecanvasmm/polygon.h>
-
-///Graph visualization setup window.
-
-///This class is responsible for creating a window,
-///on which the visualization attributes can be
-///assigned to maps.
-class MapWin : public Gtk::Window
-{
-protected:
-  ///\ref NoteBookTab to that the \ref MapWin belongs to.
-  NoteBookTab & mytab;
-
-  ///Designing element
-  Gtk::Table * table;
-  
-  ///\ref MapSelectors for each property
-
-  ///Each property has an own \ref MapSelector through which
-  ///the map to visualize by the property van be set.
-  MapSelector ** e_combo_array;
-
-  ///\ref MapSelectors for each property
-
-  ///Each property has an own \ref MapSelector through which
-  ///the map to visualize by the property van be set.
-  MapSelector ** n_combo_array;
-
-  ///Information holder
-  Gtk::Label * label;
-
-  ///Container in which elements are organized.
-  Gtk::VBox vbox;
-
-public:
-  ///Constructor
-
-  ///It creates the widgets shown in \ref MapWin and
-  ///binds the needed signal to the correct place.
-  ///\param title title of window
-  ///\param eml edgemap list
-  ///\param nml nodemap list
-  ///\param mw the owner \ref NoteBookTab (\ref mytab)
-  MapWin(const std::string& title, std::vector<std::string> eml, std::vector<std::string> nml, NoteBookTab & mw);
-
-  ///Deregistrates \ref MapWin in its \ref NoteBookTab (\ref mytab)
-  virtual bool on_delete_event(GdkEventAny *);
-
-  ///Handles changement in nodemap selection
-
-  ///If \ref MapSelector emits a signal that indicates
-  ///changement in nodemap selection this function will
-  ///be called. It calls the appropriate handler function,
-  ///\ref NoteBookTab::propertyChange with parameters describing the changement.
-  ///\param mapname the recently selected map
-  ///\param prop the changed property
-  void nodeMapChanged(std::string mapname, int prop);
-
-  ///Handles changement in edgemap selection
-
-  ///If \ref MapSelector emits a signal that indicates
-  ///changement in edgemap selection this function will
-  ///be called. It calls the appropriate handler function,
-  ///\ref NoteBookTab::propertyChange with parameters describing the changement.
-  ///\param mapname the recently selected map
-  ///\param prop the changed property
-  void edgeMapChanged(std::string mapname, int prop);
-
-  ///Indicates to the owner \ref NoteBookTab that a \ref NewMapWin should be opened.
-
-  ///This function is bound to the
-  ///signal emitted by the \ref MapSelector in case of
-  ///the user wants to create a new map. It only pass the
-  ///information further to the tab owning this \ref MapWin that is needed to open the
-  ///\ref NewMapWin. (\ref NoteBookTab::popupNewMapWin)
-  ///\param itisedge should the new map will be an edgemap? (or nodemap)
-  void newMapWinNeeded(bool itisedge);
-
-  ///This function inserts name of the new edgemap in the name list in \ref MapSelector s
-
-  ///\param new_name
-  ///name of new map
-  void registerNewEdgeMap(std::string new_name);
-
-  ///This function inserts name of the new nodemap in the name list in \ref MapSelector s
-
-  ///\param new_name
-  ///name of new map
-  void registerNewNodeMap(std::string new_name);
-
-  ///Close window if Esc key pressed.
-  virtual bool closeIfEscapeIsPressed(GdkEventKey*);
-
-  ///Updates list of maps in all \ref MapSelector
-
-  ///This function is called by \ref NoteBookTab, when the file
-  ///showed in it has changed, therefore the contained maps
-  ///have changed as well. \ref NoteBookTab knows, whether it
-  ///has to call this function or not from the \ref NoteBookTab::mapwinexists
-  ///variable.
-  ///\param eml edge map list
-  ///\param nml node map list
-  void update(std::vector<std::string> eml, std::vector<std::string> nml);
-
-  void changeEntry(bool, int, std::string);
-
-  void set_title(std::string);
-};
-
-#endif //MAP_WIN_H
Index: pselector.cc
===================================================================
--- mapselector.cc	(revision 174)
+++ 	(revision )
@@ -1,170 +1,0 @@
-/* -*- 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.
- *
- */
-
-#include "mapselector.h"
-
-MapSelector::MapSelector(std::vector<std::string> ml, std::string act, std::string labeltext, bool edge, bool d):def(d),itisedge(edge),set_new_map(false)
-{
-  update_list(ml);
-
-  if(act=="")
-    {
-      cbt.set_active(0);
-      default_state=true;
-    }
-  else
-    {
-      cbt.set_active_text((Glib::ustring)act);
-      default_state=false;
-    }
-
-  //binding signal to the actual entry
-  cbt.signal_changed().connect
-    (
-     sigc::mem_fun((*this), &MapSelector::comboChanged),
-     false
-     );
-  
-  label=new Gtk::Label(labeltext);
-
-  label->set_width_chars(longest_property_string_length);
-
-  defbut=NULL;
-  if(def)
-    {
-      defbut=new Gtk::Button();
-      defbut->set_label("Reset");
-      
-      defbut->signal_pressed().connect
-	(
-	 sigc::mem_fun(*this, &MapSelector::reset)
-	 );
-    }
-
-  newbut=new Gtk::Button(Gtk::Stock::NEW);
-
-  newbut->signal_pressed().connect
-    (
-     sigc::mem_fun(*this, &MapSelector::new_but_pressed)
-     );
-
-  add(*label);
-
-  add(cbt);
-
-  if(def)
-    {
-      add(*defbut);
-    }
-
-  add(*newbut);
-}
-
-void MapSelector::new_but_pressed()
-{
-  set_new_map=true;
-  signal_newmapwin.emit(itisedge);
-}
-
-void MapSelector::update_list( std::vector< std::string > ml )
-{
-  int prev_act=cbt.get_active_row_number();
-  cbt.clear();
-  cbt_content.clear();
-  std::vector< std::string >::iterator emsi=ml.begin();
-  for(;emsi!=ml.end();emsi++)
-    {
-      cbt.append_text(*emsi);
-      cbt_content.push_back(*emsi);
-    }
-  if(def)
-    {
-      cbt.prepend_text("Default values");
-      cbt_content.push_back("Default values");
-    }
-  if(prev_act!=-1)
-    {
-      cbt.set_active(prev_act);
-    }
-}
-
-void MapSelector::comboChanged()
-{
-  if(cbt.get_active_row_number()!=0 || !def)
-    {
-      default_state=false;
-      Glib::ustring mapname = cbt.get_active_text();
-      if(!(mapname.empty())) //We seem to get 2 signals, one when the text is empty.
-	{
-	  signal_cbt.emit(mapname);
-	}
-    }
-  else if((!default_state)&&(cbt.get_active_row_number()==0))
-    {
-      reset();
-    }
-}
-
-void MapSelector::reset()
-{
-  default_state=true;
-
-  cbt.set_active(0);
-
-  signal_cbt.emit("");
-}
-
-
-Glib::ustring MapSelector::get_active_text()
-{
-  return cbt.get_active_text();
-}
-
-void MapSelector::set_active_text(Glib::ustring text)
-{
-  if(text.compare(""))
-    {
-      cbt.set_active_text(text);
-    }
-  else
-    { 
-      cbt.set_active_text("Default values");
-    }
-}
-
-void MapSelector::append_text(Glib::ustring text)
-{
-  cbt.append_text(text);
-  cbt_content.push_back(text);
-
-  if(set_new_map)
-    {
-      set_active_text(text);
-      set_new_map=false;
-    }
-}
-
-sigc::signal<void, std::string> MapSelector::signal_cbt_ch()
-{
-  return signal_cbt;
-}
-
-sigc::signal<void, bool> MapSelector::signal_newmapwin_needed()
-{
-  return signal_newmapwin;
-}
Index: pselector.h
===================================================================
--- mapselector.h	(revision 174)
+++ 	(revision )
@@ -1,176 +1,0 @@
-/* -*- 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 MAPSELECTOR_H
-#define MAPSELECTOR_H
-
-class MapSelector;
-
-#include <all_include.h>
-#include <map_win.h>
-#include <libgnomecanvasmm.h>
-#include <libgnomecanvasmm/polygon.h>
-
-///A widget by which node and edgemaps can be selected, deselected and created.
-
-///During the usage of \ref glemon we have to select
-///maps several times. We also need some aid-function
-///like new map creation and deselecting previously
-///selected map. Instead of writing a the mapselection
-///at all occurences we can use this widget by connecting
-///its signals to the correct place.
-class MapSelector : public Gtk::HBox
-{
- protected:
-  ///This signal indicates that the selection has been changed by user.
-  sigc::signal<void, std::string> signal_cbt;
-
-  ///Signal that indicates that user wants to create a new map.
-  sigc::signal<void, bool> signal_newmapwin;
-
-  ///If this is true, beyond the mapnames a 'Default' selection is available as well.
-
-  ///For example \ref MapWin needs 'Default' option as well. In this case no map
-  ///will be visualized by the appropriate property.
-  ///But \ref AlgoWin do not need 'Default' option, because if no map is selected,
-  ///no algorithm can be run.
-  ///Its value is got and set in contructor.
-  bool def;
-
-  ///Are the names of edgemaps or nodemaps stored here.
-  bool itisedge;
-
-  ///Shows whether 'Default' option is selected or not.
-  bool default_state;
-
-  ///It is true when the new button had been pressed but the new map has not been registrated yet.
-
-  ///Before signal of \ref NewMapWin request is emitted by the \ref MapSelector
-  ///this variable is set to true. When the new map
-  ///is done, it will be registrated in all existing \ref MapSelector 
-  ///by \ref append_text function. That function checks
-  ///whether this variable is true. If it is true that means
-  ///that this \ref MapSelector has requested \ref NewMapWin.
-  ///Therefore it set itself to the recently created map.
-  ///After that \ref set_new_map is set again false, not to
-  ///set maps active if \ref MapSelector piece is not the requester.
-  bool set_new_map;
-
-  ///The widget that holds the names of maps.
-
-  ///It can be rolled down
-  ///Names in it are selectable.
-  Gtk::ComboBoxText cbt;
-
-  std::vector<std::string> cbt_content;
-
-  ///New button.
-
-  ///By pressing it
-  ///\ref NewMapWin wilol pop-up
-  Gtk::Button * newbut;
-
-  ///Reset button.
-
-  ///If pressed \ref cbt will
-  ///set to 'Default' option.
-  ///
-  ///It is visible only if \ref def is true.
-  Gtk::Button * defbut;
-
-  ///Container in which GUI elements are packed.
-  Gtk::HBox hbox;
-
-  ///Shows purpose of \ref MapSelector piece.
-  Gtk::Label * label;
-
- public:
-
-  ///Constructor of \ref MapSelector
-
-  ///Creates the layout and binds signal to the correct place.
-  ///\param optionlist list of names to place in \ref cbt
-  ///\param act preselected option
-  ///\param purpose text of label indicating purpose of \ref MapStorage
-  ///\param itisedge do \ref MapSelector contains edgemap names or nodemapnames.
-  ///\param def do we need 'Default' option. See \ref def.
-  MapSelector(std::vector<std::string> optionlist, std::string act, std::string purpose, bool itisedge, bool def=true);
-
-  ///Returns signal emitted if the user has changed the selection. (\ref signal_cbt)
-  sigc::signal<void, std::string> signal_cbt_ch();
-
-  ///Returns signal emitted if the user has pressed New button (\ref newbut) (\ref signal_newmapwin)
-  sigc::signal<void, bool> signal_newmapwin_needed();
-
-  ///Maintain \ref cbt.
-
-  ///Fills in \ref cbt with names, taking
-  ///into account that the previously selected option
-  ///has to be set back after the operation.
-  void update_list( std::vector<std::string> );
-
-  ///Handles changement in \ref cbt.
-
-  ///In default case it emits a signal with the selected option.
-  ///But if 'Default' option is selected, it resets the \ref MapSelector
-  virtual void comboChanged();
-
-  ///Requests a \ref NewMapWin
-
-  ///See \ref set_new_map.
-  ///First it sets \ref set_new_map true to be identified
-  ///at registration of new map that
-  ///it has sent the \ref signal_newmapwin, therefore it
-  ///has to set \ref cbt to that option.
-  virtual void new_but_pressed();
-
-  ///If called, 'Default' option is selected, that means unselection of any maps.
-
-  ///Practically this means that if this is called,
-  ///properties of graph will set to default state.
-  ///The function achieves this by emitting appropriately
-  ///parametrized signal_cbt.
-  virtual void reset();
-
-  ///Returns the currently selected option.
-  Glib::ustring get_active_text();
-
-  ///Sets the parameter active in \ref cbt.
-
-  ///\param new_value the
-  ///new value to be set in \ref cbt.
-  void set_active_text(Glib::ustring new_value);
-
-  ///Sets the parameter active in \ref cbt.
-  ///\param index the
-  ///index of row to be set in \ref cbt.
-  void set_active(int index){cbt.set_active(index);};
-
-  ///Clear all options from \ref cbt.
-  void clear(){cbt.clear();};
-
-  ///Appends a new option to the existing ones in \ref cbt.
-
-  ///If \ref set_new_map is true, the
-  ///\ref MapSelector has requested the opened \ref NewMapWin,
-  ///from that the option to append is coming. In this case
-  ///this function  will set \ref cbt to the new option.
-  ///\param new_option new option to append
-  void append_text(Glib::ustring new_option);
-};
-#endif //MAPSELECTOR_H
Index: pstorage.cc
===================================================================
--- mapstorage.cc	(revision 184)
+++ 	(revision )
@@ -1,591 +1,0 @@
-/* -*- 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.
- *
- */
-
-#include "mapstorage.h"
-#include "nbtab.h"
-#include "gui_writer.h"
-#include "gui_reader.h"
-#include <limits>
-#include <cmath>
-#include <gtkmm.h>
-
-const double i_d=20;
-const double a_d=0.05;
-const double p_d=40000;
-
-MapStorage::MapStorage(NoteBookTab& tab) : mytab(tab), modified(false), file_name(""), arrow_pos_read_ok(false), iterations(i_d), attraction(a_d), propulsation(p_d), background_set(false)
-{
-  nodemap_storage["coordinates_x"] = new Graph::NodeMap<double>(graph);
-  coords.setXMap(*nodemap_storage["coordinates_x"]);
-  nodemap_storage["coordinates_y"] = new Graph::NodeMap<double>(graph);
-  coords.setYMap(*nodemap_storage["coordinates_y"]);
-
-  edgemap_storage["arrow_pos_x"] = new Graph::EdgeMap<double>(graph);
-  arrow_pos.setXMap(*edgemap_storage["arrow_pos_x"]);
-  edgemap_storage["arrow_pos_y"] = new Graph::EdgeMap<double>(graph);
-  arrow_pos.setYMap(*edgemap_storage["arrow_pos_y"]);
-
-  nodemap_storage["label"] = new Graph::NodeMap<double>(graph);
-  edgemap_storage["label"] = new Graph::EdgeMap<double>(graph);
-
-  nodemap_default["label"] = 1.0;
-  edgemap_default["label"] = 1.0;
-
-  active_nodemaps.resize(NODE_PROPERTY_NUM);
-  for(int i=0;i<NODE_PROPERTY_NUM;i++)
-    {
-      active_nodemaps[i]="";
-    }
-
-  active_edgemaps.resize(EDGE_PROPERTY_NUM);
-  for(int i=0;i<EDGE_PROPERTY_NUM;i++)
-    {
-      active_edgemaps[i]="";
-    }
-}
-
-MapStorage::~MapStorage()
-{
-  for (std::map<std::string, Graph::NodeMap<double>*>::const_iterator it =
-      nodemap_storage.begin(); it != nodemap_storage.end(); ++it)
-  {
-    delete it->second;
-  }
-  for (std::map<std::string, Graph::EdgeMap<double>*>::const_iterator it =
-      edgemap_storage.begin(); it != edgemap_storage.end(); ++it)
-  {
-    delete it->second;
-  }
-}
-
-int MapStorage::addNodeMap(const std::string & name, Graph::NodeMap<double> *nodemap, double default_value)
-{
-  if( nodemap_storage.find(name) == nodemap_storage.end() )
-    {
-      nodemap_storage[name]=nodemap;
-      // set the maps default value
-      nodemap_default[name] = default_value;
-
-      //announce changement in maps
-      signal_node_map.emit(name);
-      return 0;
-    }
-  return 1;
-}
-
-void MapStorage::changeActiveMap(bool itisedge, int prop, std::string mapname)
-{
-  if(itisedge)
-    {
-      active_edgemaps[prop]=mapname;
-    }
-  else
-    {
-      active_nodemaps[prop]=mapname;
-    }
-  signal_prop.emit(itisedge, prop);
-}
-
-void MapStorage::broadcastActiveMaps()
-{
-  for(int i=0;i<NODE_PROPERTY_NUM;i++)
-    {
-      signal_map_win.emit(false, i, active_nodemaps[i]);
-    }
-  
-  for(int i=0;i<EDGE_PROPERTY_NUM;i++)
-    {
-      signal_map_win.emit(true, i, active_edgemaps[i]);
-    }
-}
-
-
-std::string MapStorage::getActiveEdgeMap(int prop)
-{
-  return active_edgemaps[prop];
-}
-
-std::string MapStorage::getActiveNodeMap(int prop)
-{
-  return active_nodemaps[prop];
-}
-
-std::vector<std::string> MapStorage::getEdgeMapList()
-{
-  std::vector<std::string> eml;
-  eml.resize(edgemap_storage.size());
-  int i=0;
-  std::map< std::string,Graph::EdgeMap<double> * >::iterator emsi=beginOfEdgeMaps();
-  for(;emsi!=endOfEdgeMaps();emsi++)
-    {
-      eml[i]=(emsi->first);
-      i++;
-    }
-  return eml;
-}
-
-std::vector<std::string> MapStorage::getNodeMapList()
-{
-  std::vector<std::string> nml;
-  nml.resize(nodemap_storage.size());
-  int i=0;
-  std::map< std::string,Graph::NodeMap<double> * >::iterator nmsi=beginOfNodeMaps();
-  for(;nmsi!=endOfNodeMaps();nmsi++)
-    {
-      nml[i]=(nmsi->first);
-      i++;
-    }
-  return nml;
-}
-
-sigc::signal<void, bool, int> MapStorage::signal_prop_ch()
-{
-  return signal_prop;
-}
-
-int MapStorage::addEdgeMap(const std::string & name, Graph::EdgeMap<double> *edgemap, double default_value)
-{
-  if( edgemap_storage.find(name) == edgemap_storage.end() )
-    {
-      edgemap_storage[name]=edgemap;
-      // set the maps default value
-      edgemap_default[name] = default_value;
-
-      //announce changement in maps
-      signal_edge_map.emit(name);
-      return 0;
-    }
-  return 1;
-}
-
-double MapStorage::maxOfNodeMap(const std::string & name)
-{
-  double max=0;
-  for (NodeIt j(graph); j!=INVALID; ++j)
-  {
-    if( (*nodemap_storage[name])[j]>max )
-    {
-      max=(*nodemap_storage[name])[j];
-    }
-  }
-  return max;
-}
-
-double MapStorage::maxOfEdgeMap(const std::string & name)
-{
-  double max=0;
-  for (EdgeIt j(graph); j!=INVALID; ++j)
-  {
-    if( (*edgemap_storage[name])[j]>max )
-    {
-      max=(*edgemap_storage[name])[j];
-    }
-  }
-  return max;
-}
-
-double MapStorage::minOfNodeMap(const std::string & name)
-{
-  NodeIt j(graph);
-  double min;
-  if(j!=INVALID)
-    {
-      min=(*nodemap_storage[name])[j];
-    }
-  else
-    {
-      min=0;
-    }
-  for (; j!=INVALID; ++j)
-  {
-    if( (*nodemap_storage[name])[j]<min )
-    {
-      min=(*nodemap_storage[name])[j];
-    }
-  }
-  return min;
-}
-
-double MapStorage::minOfEdgeMap(const std::string & name)
-{
-  EdgeIt j(graph);
-  double min;
-  if(j!=INVALID)
-    {
-      min=(*edgemap_storage[name])[j];
-    }
-  else
-    {
-      min=0;
-    }
-  for (EdgeIt j(graph); j!=INVALID; ++j)
-  {
-    if( (*edgemap_storage[name])[j]<min )
-    {
-      min=(*edgemap_storage[name])[j];
-    }
-  }
-  return min;
-}
-
-int MapStorage::readFromFile(const std::string &filename)
-{
-  bool read_x = false;
-  bool read_y = false;
-  bool read_edge_id = false;
-
-  try {
-    LemonReader lreader(filename);
-    ContentReader content(lreader);
-    lreader.run();
-
-    if (content.nodeSetNum() < 1)
-    {
-      Gtk::MessageDialog mdialog("No nodeset found in file.");
-      mdialog.run();
-      clear();
-      return 1;
-    }
-
-    if (content.edgeSetNum() < 1)
-    {
-      Gtk::MessageDialog mdialog("No edgeset found in file.");
-      mdialog.run();
-      clear();
-      return 1;
-    }
-
-    const std::vector<std::string>& nodeMapNames = content.nodeSetMaps(0);
-    const std::vector<std::string>& edgeMapNames = content.edgeSetMaps(0);
-
-    GraphReader<Graph> greader(filename, graph);
-    for (std::vector<std::string>::const_iterator it = nodeMapNames.begin();
-        it != nodeMapNames.end(); ++it)
-    {
-      if (*it == "coordinates_x")
-      {
-        read_x = true;
-        //std::cout << "read X nodemap" << std::endl;
-      }
-      else if (*it == "coordinates_y")
-      {
-        read_y = true;
-        //std::cout << "read Y nodemap" << std::endl;
-      }
-      else if (*it == "label")
-      {
-        //std::cout << "read id nodemap" << std::endl;
-      }
-      else
-      {
-        nodemap_storage[*it] = new Graph::NodeMap<double>(graph);
-        //std::cout << "read " << *it << " nodemap" << std::endl;
-      }
-      greader.readNodeMap(*it, *nodemap_storage[*it]);
-    }
-    for (std::vector<std::string>::const_iterator it = edgeMapNames.begin();
-        it != edgeMapNames.end(); ++it)
-    {
-      if (*it == "label")
-      {
-        //std::cout << "read id edgemap" << std::endl;
-        read_edge_id = true;
-      }
-      else
-      {
-        edgemap_storage[*it] = new Graph::EdgeMap<double>(graph);
-        //std::cout << "read " << *it << " edgemap" << std::endl;
-      }
-      greader.readEdgeMap(*it, *edgemap_storage[*it]);
-    }
-    GuiReader gui_reader(greader, this);
-    greader.run();
-  } catch (Exception& error) {
-    Gtk::MessageDialog mdialog(error.what());
-    mdialog.run();
-    clear();
-    return 1;
-  }
-
-  if (!read_edge_id)
-  {
-    edgemap_storage["label"] = new Graph::EdgeMap<double>(graph);
-    int i = 1;
-    for (EdgeIt e(graph); e != INVALID; ++e)
-    {
-      (*edgemap_storage["label"])[e] = i++;
-    }
-  }
-
-  if (!read_x || !read_y)
-  {
-    int node_num = 0;
-    for (NodeIt n(graph); n != INVALID; ++n)
-    {
-      node_num++;
-    }
-    const double pi = 3.142;
-    double step = 2 * pi / (double) node_num;
-    int i = 0;
-    for (NodeIt n(graph); n != INVALID; ++n)
-    {
-      nodemap_storage["coordinates_x"]->set(n, 250.0 * std::cos(i * step));
-      nodemap_storage["coordinates_y"]->set(n, 250.0 * std::sin(i * step));
-      i++;
-    }
-  }
-
-  if (!arrow_pos_read_ok)
-  {
-    arrow_pos_read_ok = false;
-    for (EdgeIt e(graph); e != INVALID; ++e)
-    {
-      if (graph.source(e) == graph.target(e))
-      {
-        arrow_pos.set(e, coords[graph.source(e)] + XY(0.0, 80.0));
-      }
-      else
-      {
-        arrow_pos.set(e, (coords[graph.source(e)] + coords[graph.target(e)]) / 2.0);
-      }
-    }
-  }
-
-  // fill in the default values for the maps
-  for (std::map<std::string, Graph::NodeMap<double>*>::const_iterator it =
-      nodemap_storage.begin(); it != nodemap_storage.end(); ++it)
-  {
-    if ((it->first != "label") &&
-        (it->first != "coordiantes_x") &&
-        (it->first != "coordinates_y"))
-    {
-      nodemap_default[it->first] = 0.0;
-    }
-    else if (it->first == "label")
-    {
-      NodeIt n(graph);
-      double max = (*nodemap_storage["label"])[n];
-      for (; n != INVALID; ++n)
-      {
-        if ((*nodemap_storage["label"])[n] > max)
-          max = (*nodemap_storage["label"])[n];
-      }
-      nodemap_default["label"] = max + 1.0;
-    }
-  }
-  for (std::map<std::string, Graph::EdgeMap<double>*>::const_iterator it =
-      edgemap_storage.begin(); it != edgemap_storage.end(); ++it)
-  {
-    if (it->first != "label")
-    {
-      edgemap_default[it->first] = 0.0;
-    }
-    else
-    {
-      double max = std::numeric_limits<double>::min();
-      for (EdgeIt e(graph); e != INVALID; ++e)
-      {
-        if ((*edgemap_storage["label"])[e] > max)
-          max = (*edgemap_storage["label"])[e];
-      }
-      if (max > std::numeric_limits<double>::min())
-        edgemap_default["label"] = max + 1.0;
-      else
-        edgemap_default["label"] = 1.0;
-    }
-  }
-
-  return 0;
-}
-
-void MapStorage::writeToFile(const std::string &filename)
-{
-  GraphWriter<Graph> gwriter(filename, graph);
-
-  for (std::map<std::string, Graph::NodeMap<double>*>::const_iterator it =
-      nodemap_storage.begin(); it != nodemap_storage.end(); ++it)
-  {
-    gwriter.writeNodeMap(it->first, *(it->second));
-  }
-  for (std::map<std::string, Graph::EdgeMap<double>*>::const_iterator it =
-      edgemap_storage.begin(); it != edgemap_storage.end(); ++it)
-  {
-    if ((it->first != "arrow_pos_x") &&
-        (it->first != "arrow_pos_y"))
-    {
-      gwriter.writeEdgeMap(it->first, *(it->second));
-    }
-  }
-
-  GuiWriter gui_writer(gwriter, this);
-
-  gwriter.run();
-}
-
-void MapStorage::clear()
-{
-  for (std::map<std::string, Graph::NodeMap<double>*>::iterator it =
-      nodemap_storage.begin(); it != nodemap_storage.end(); ++it)
-  {
-    if ((it->first != "coordinates_x") &&
-        (it->first != "coordinates_y") &&
-        (it->first != "label"))
-    {
-      delete it->second;
-      nodemap_storage.erase(it);
-    }
-  }
-  for (std::map<std::string, Graph::EdgeMap<double>*>::iterator it =
-      edgemap_storage.begin(); it != edgemap_storage.end(); ++it)
-  {
-    if ((it->first != "label") &&
-        (it->first != "arrow_pos_x") &&
-        (it->first != "arrow_pos_y"))
-    {
-      delete it->second;
-      edgemap_storage.erase(it);
-    }
-  }
-  for (std::map<std::string, double>::iterator it =
-      nodemap_default.begin(); it != nodemap_default.end(); ++it)
-  {
-    if (it->first != "label")
-      nodemap_default.erase(it);
-  }
-  for (std::map<std::string, double>::iterator it =
-      edgemap_default.begin(); it != edgemap_default.end(); ++it)
-  {
-    if (it->first != "label")
-      edgemap_default.erase(it);
-  }
-  graph.clear();
-  file_name = "";
-  modified = false;
-
-  arrow_pos_read_ok = false;
-  
-  for(int i=0;i<NODE_PROPERTY_NUM;i++)
-    {
-      changeActiveMap(false, i, "");
-      signal_map_win.emit(false, i, "");
-    }
-  
-  for(int i=0;i<EDGE_PROPERTY_NUM;i++)
-    {
-      changeActiveMap(true, i, "");
-      signal_map_win.emit(true, i, "");
-    }
-
-  attraction=a_d;
-  propulsation=p_d;
-  iterations=i_d;
-
-  signal_design_win.emit(attraction, propulsation, iterations);
-}
-
-void MapStorage::ArrowPosReadOK()
-{
-  arrow_pos_read_ok = true;
-}
-
-void MapStorage::mapChanged(bool itisedge, std::string mapname)
-{
-  if(itisedge)
-    {
-      for(int i=0;i<EDGE_PROPERTY_NUM;i++)
-	{
-	  if(active_edgemaps[i]==mapname)
-	    {
-	      signal_prop.emit(itisedge, i);
-	    }
-	}
-    }
-  else
-    {
-      for(int i=0;i<NODE_PROPERTY_NUM;i++)
-	{
-	  if(active_nodemaps[i]==mapname)
-	    {
-	      signal_prop.emit(itisedge, i);
-	    }
-	}
-    }
-}
-
-void MapStorage::get_design_data(double & attraction_p, double & propulsation_p, int & iterations_p)
-{
-  attraction_p=attraction;
-  propulsation_p=propulsation;
-  iterations_p=iterations;
-}
-
-void MapStorage::set_attraction(double attraction_p)
-{
-  attraction=attraction_p;
-}
-
-void MapStorage::set_propulsation(double propulsation_p)
-{
-  propulsation=propulsation_p;
-}
-
-void MapStorage::set_iteration(int iterations_p)
-{
-  iterations=iterations_p;
-}
-
-void MapStorage::redesign_data_changed()
-{
-  signal_design_win.emit(attraction, propulsation, iterations);
-}
-
-void MapStorage::setBackground(const std::string& file_name)
-{
-  if (file_name == background_file_name) return;
-  if (file_name == "")
-  {
-    background_file_name = "";
-    background_set = false;
-  }
-  else
-  {
-    background_file_name = file_name;
-    background_set = true;
-  }
-  mytab.gd_canvas->setBackground();
-}
-
-const std::string& MapStorage::getBackgroundFilename()
-{
-  return background_file_name;
-}
-
-bool MapStorage::isBackgroundSet()
-{
-  return background_set;
-}
-
-double MapStorage::getBackgroundScaling()
-{
-  return background_scaling;
-}
-
-void MapStorage::setBackgroundScaling(double scaling)
-{
-  background_scaling = scaling;
-}
Index: pstorage.h
===================================================================
--- mapstorage.h	(revision 184)
+++ 	(revision )
@@ -1,296 +1,0 @@
-/* -*- 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 MAPSTORAGE_H
-#define MAPSTORAGE_H
-
-class Mapstorage;
-
-#include "all_include.h"
-#include "xymap.h"
-#include <libgnomecanvasmm.h>
-
-class NoteBookTab;
-
-///class MapStorage handles NodeMaps and EdgeMaps.
-
-///Class MapStorage is responsible for storing
-///NodeMaps and EdgeMaps that can be shown later
-///on GUI. Therefore maps can be added to it,
-///and datas over the added maps can be queried.
-///The maps will be stored in an std::map,
-///referenced with their names. Unfortunately at
-///the moment it works only with double type maps
-///
-///\todo too many things are public!!
-class MapStorage
-{
-private:
-  std::string background_file_name;
-  bool background_set;
-  double background_scaling;
-  NoteBookTab& mytab;
-public:
-  void setBackground(const std::string& file_name);
-  const std::string& getBackgroundFilename();
-  bool isBackgroundSet();
-  double getBackgroundScaling();
-  void setBackgroundScaling(double scaling);
-  ///The graph for which the datas are stored.
-  Graph graph;
-  /// the coordinates of the nodes
-  XYMap<Graph::NodeMap<double> > coords;
-  /// the coordinates of the arrows on the edges
-  XYMap<Graph::EdgeMap<double> > arrow_pos;
-
-  ///The content of the object has changed, update is needed.
-  bool modified;
-
-  ///Name of file loaded in object.
-  std::string file_name;
-
-  ///Stores double type NodeMaps
-  std::map< std::string,Graph::NodeMap<double> * > nodemap_storage;
-
-  ///Stores double type EdgeMaps
-  std::map< std::string,Graph::EdgeMap<double> * > edgemap_storage;
-
-  ///Stores the default values for the different visualization node attributes
-  std::vector<Graph::NodeMap<double> > default_nodemaps;
-
-  ///Stores the default values for the different visualization edge attributes
-  std::vector<Graph::EdgeMap<double> > default_edgemaps;
-
-  ///Stores the active maps for the different visualization node attributes
-  std::vector< std::string > active_nodemaps;
-
-  /// Stores the active maps for the different visualization edge attributes
-  std::vector< std::string > active_edgemaps;
-
-  /// Default values for the maps
-  std::map< std::string, double > nodemap_default;
-
-  /// Default values for the maps
-  std::map< std::string, double > edgemap_default;
-
-  bool arrow_pos_read_ok;
-
-protected:
-
-  /// Signal emitted on any change made on map values
-
-  /// Signal emitted if the visualization of the maps might have to be updated.
-  /// bool shows us whether the changed map is edge or nodemap.
-  /// int tells us the refreshed property
-  sigc::signal<void, bool, int> signal_prop;
-
-  /// Signal emitted in the case of nodemap addition
-
-  /// std::string is the
-  ///name of the new map
-  sigc::signal<void, std::string> signal_node_map;
-
-  /// Signal emitted in the case of edgemap addition
-
-  /// std::string is the
-  ///name of the new map
-  sigc::signal<void, std::string> signal_edge_map;
-
-  /// Signal emitted, when entry in \ref MapWin should be changed.
-  sigc::signal<void, bool, int, std::string> signal_map_win;
-
-  /// Signal emitted, when entry in \ref DesignWin should be changed.
-  sigc::signal<void, double, double, int> signal_design_win;
-
-  ///Iteration number during graph design
-  int iterations;
-
-  ///Attraction factor during graph design
-  double attraction;
-
-  ///Propulsation factor during graph design
-  double propulsation;
-
-public:
-  ///Constructor of MapStorage.
-
-  ///Its all activity is initializing default values
-  ///for different visualization attributes.
-  MapStorage(NoteBookTab& tab);
-
-  ///Destructor of MapStorage
-
-  ///Maps stored here are created with new. Destructor
-  ///deletes them to free up the reserved memory.
-  ~MapStorage();
-
-  /// Registrates if the shown map by any attribute has changed to another.
-
-  ///It handles the \ref active_edgemaps and
-  ///\ref active_nodemaps vectors. It also emits \ref signal_prop signal to let
-  ///know the interested objects that the visible map of a certain
-  ///attribute has changed.
-  ///\param itisedge edgemap or nodemap has changed
-  ///\param prop the property of which the map is changed
-  ///\param mapname the visible map
-  void changeActiveMap(bool itisedge , int prop , std::string mapname);
-
-  ///Emits signals that let change the active maps in \ref MapWin.
-  void broadcastActiveMaps();
-
-  /// Returns the active edgemap shown by a visualization property.
-
-  /// \param prop is the property
-  ///that shows the requested map.
-  std::string getActiveEdgeMap(int prop);
-
-  /// Returns the active nodemap shown by a visualization property.
-
-  /// \param prop is the property
-  ///that shows the requested map.
-  std::string getActiveNodeMap(int prop);
-
-  /// Returns the names of the edgemaps stored here.
-  std::vector<std::string> getEdgeMapList();
-
-  /// Returns the names of the nodemaps stored here.
-  std::vector<std::string> getNodeMapList();
-
-  ///returns \ref signal_prop to be able to connect functions to it
-  sigc::signal<void, bool, int> signal_prop_ch();
-
-  ///returns \ref signal_node_map to be able to connect functions to it
-  sigc::signal<void, std::string> signal_node_map_ch(){return signal_node_map;};
-
-  ///returns \ref signal_edge_map to be able to connect functions to it
-  sigc::signal<void, std::string> signal_edge_map_ch(){return signal_edge_map;};
-
-  ///returns \ref signal_map_win to be able to connect functions to it
-  sigc::signal<void, bool, int, std::string> signal_map_win_ch(){return signal_map_win;};
-
-  ///returns \ref signal_design_win to be able to connect functions to it
-  sigc::signal<void, double, double, int> signal_design_win_ch(){return signal_design_win;};
-
-  ///Adds given map to storage.
-
-  ///A name and the map itself has to be provided.
-  ///\param mapname is the name of map
-  ///\param nodemap is the pointer of the given nodemap
-  ///\param def the default value of the map. If not given, it will be 0.
-  ///If new edge is added to graph the value of it in the map will be this.
-  ///\todo map should be given by reference!
-  ///\todo why is default value stored?
-  int addNodeMap(const std::string & mapname,Graph::NodeMap<double> * nodemap, double def=0.0);
-
-  ///Adds given map to storage. A name and the map itself has to be provided.
-
-  ///A name and the map itself has to be provided.
-  ///\param mapname is the name of map
-  ///\param edgemap is the pointer of the given edgemap
-  ///\param def the default value of the map. If not given, it will be 0.
-  ///If new edge is added to graph the value of it in the map will be this.
-  ///\todo map should be given by reference!
-  int addEdgeMap(const std::string & mapname,Graph::EdgeMap<double> * edgemap, double def=0.0);
-
-  ///Returns how much nodemaps is stored in \ref MapStorage
-  int numOfNodeMaps() {return nodemap_storage.size();};
-
-  ///Returns how much edgemaps is stored in \ref MapStorage
-  int numOfEdgeMaps() {return edgemap_storage.size();};
-
-  ///Returns the maximum value of the given NodeMap.
-
-  ///NodeMap has to be given by its name.
-  ///\param name the name of map of which maximum is searched
-  double maxOfNodeMap(const std::string & name);
-
-  ///Returns the maximum value of the given EdgeMap.
-
-  ///EdgeMap has to be given by its name.
-  ///\param name the name of map of which maximum is searched
-  double maxOfEdgeMap(const std::string & name);
-
-  ///Returns the minimum value of the given NodeMap.
-
-  ///NodeMap has to be given by its name.
-  ///\param name the name of map of which minimum is searched
-  double minOfNodeMap(const std::string & name);
-
-  ///Returns the minimum value of the given EdgeMap.
-
-  ///EdgeMap has to be given by its name.
-  ///\param name the name of map of which minimum is searched
-  double minOfEdgeMap(const std::string & name);
-
-  ///Returns iterator pointing to the first NodeMap in storage.
-
-  ///To be able to iterate through each maps this function
-  ///returns an iterator pointing to the first nodemap in
-  ///the storage.
-  std::map< std::string,Graph::NodeMap<double> * >::iterator beginOfNodeMaps(){return nodemap_storage.begin();};
-
-  ///Returns iterator pointing to the first EdgeMap in storage.
-
-  ///To be able to iterate through each maps this function
-  ///returns an iterator pointing to the first edgemap in
-  ///the storage.
-  std::map< std::string,Graph::EdgeMap<double> * >::iterator beginOfEdgeMaps(){return edgemap_storage.begin();};
-
-  ///Returns iterator pointing after the last NodeMap in storage.
-
-  ///To be able to iterate through each maps this function
-  ///returns an iterator pointing to the last nodemap in the storage.
-  std::map< std::string,Graph::NodeMap<double> * >::iterator endOfNodeMaps(){return nodemap_storage.end();};
-
-  ///Returns iterator pointing after the last EdgeMap in storage.
-
-  ///To be able to iterate through each maps this function
-  ///returns an iterator pointing to the last edgemap in the storage.
-  std::map< std::string,Graph::EdgeMap<double> * >::iterator endOfEdgeMaps(){return edgemap_storage.end();};
-
-  ///Emits \ref signal_prop if mapvalues have changed, and MapStorage gets to know it.
-
-  ///If values in a map have changed, this function checks, whether it is displayed.
-  ///This check means searching the given mapname between active maps
-  ///(\ref active_nodemaps, \ref active_edgemaps). If it is there at a certain property,
-  ///it emits a signal with the property, where the gotten mapname was found. One signal
-  ///is emitted for each property displaying the given map.
-  ///\param itisedge whether the map an edgemap or nodemap
-  ///\param mapname name of map to visualize
-  void mapChanged(bool itisedge, std::string mapname);
-
-  ///Read datas from the given filename.
-  int readFromFile(const std::string &);
-
-  ///Save datas to the given filename.
-  void writeToFile(const std::string &);
-
-  ///Deletes all datastructures stored here.
-  void clear();
-
-  void ArrowPosReadOK();
-
-  void get_design_data(double &, double &, int &);
-  void set_attraction(double);
-  void set_propulsation(double);
-  void set_iteration(int);
-
-  void redesign_data_changed();
-};
-
-#endif //MAPSTORAGE_H
Index: tab.cc
===================================================================
--- nbtab.cc	(revision 186)
+++ 	(revision )
@@ -1,292 +1,0 @@
-/* -*- 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.
- *
- */
-
-#include <nbtab.h>
-
-NoteBookTab::NoteBookTab():mapwinexists(false), designwinexists(false), mapstorage(*this)
-{
-  Gtk::ScrolledWindow *pScrolledWindow = manage(new Gtk::ScrolledWindow);
-  gd_canvas=new GraphDisplayerCanvas(*this);
-  pScrolledWindow->add(*gd_canvas);
-  add(*pScrolledWindow);
-
-  //connecting signals - controller character
-  mapstorage.signal_prop_ch().connect(sigc::mem_fun(*gd_canvas, &GraphDisplayerCanvas::propertyChange));
-  mapstorage.signal_node_map_ch().connect(sigc::mem_fun(*this, &NoteBookTab::registerNewNodeMap));
-  mapstorage.signal_edge_map_ch().connect(sigc::mem_fun(*this, &NoteBookTab::registerNewEdgeMap));
-  show_all_children();
-  show();
-}
-
-void NoteBookTab::readFile(const std::string &file)
-{
-  mapstorage.readFromFile(file);
-  mapstorage.file_name = file;
-  mapstorage.modified = false;
-  gd_canvas->drawGraph();
-  if(mapwinexists)
-    {
-      mapwin->update(mapstorage.getEdgeMapList(), mapstorage.getNodeMapList());
-    }
-  signal_title.emit(Glib::filename_display_basename(file));
-}
-
-void NoteBookTab::newFile()
-{
-  if (mapstorage.modified)
-  {
-    Gtk::MessageDialog mdialog("<b>Save changes before closing?</b>", true,
-        Gtk::MESSAGE_WARNING, Gtk::BUTTONS_NONE);
-    mdialog.add_button("Close file _without Saving", Gtk::RESPONSE_REJECT);
-    mdialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
-    mdialog.add_button(Gtk::Stock::SAVE, Gtk::RESPONSE_ACCEPT);
-    switch (mdialog.run())
-    {
-      case Gtk::RESPONSE_CANCEL:
-        return;
-      case Gtk::RESPONSE_REJECT:
-        break;
-      case Gtk::RESPONSE_ACCEPT:
-        saveFile();
-        break;
-    }
-  }
-  gd_canvas->clear();
-  mapstorage.clear();
-  if(mapwinexists)
-    {
-      mapwin->update(mapstorage.getEdgeMapList(), mapstorage.getNodeMapList());
-    }
-  signal_title.emit("unsaved file");
-}
-
-void NoteBookTab::openFile()
-{
-  if (mapstorage.modified)
-  {
-    Gtk::MessageDialog mdialog("<b>Save changes before closing?</b>", true, 
-        Gtk::MESSAGE_WARNING, Gtk::BUTTONS_NONE);
-    mdialog.add_button("Close file _without Saving", Gtk::RESPONSE_REJECT);
-    mdialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
-    mdialog.add_button(Gtk::Stock::SAVE, Gtk::RESPONSE_ACCEPT);
-    switch (mdialog.run())
-    {
-      case Gtk::RESPONSE_CANCEL:
-        return;
-      case Gtk::RESPONSE_REJECT:
-        break;
-      case Gtk::RESPONSE_ACCEPT:
-        saveFile();
-        break;
-    }
-  }
-  Gtk::FileChooserDialog fcdialog("Open File");
-  fcdialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
-  fcdialog.add_button(Gtk::Stock::OPEN, Gtk::RESPONSE_ACCEPT);
-  if (fcdialog.run() == Gtk::RESPONSE_ACCEPT)
-  {
-    gd_canvas->clear();
-    mapstorage.clear();
-    Glib::ustring filename = fcdialog.get_filename();
-    if (!mapstorage.readFromFile(filename))
-    {
-      mapstorage.file_name = filename;
-      mapstorage.modified = false;
-      gd_canvas->drawGraph();
-      if(mapwinexists)
-	{
-	  mapwin->update(mapstorage.getEdgeMapList(), mapstorage.getNodeMapList());
-	}
-      signal_title.emit(Glib::filename_display_basename(filename));
-    }
-  }
-}
-
-void NoteBookTab::saveFile()
-{
-  if (mapstorage.file_name == "") {
-    saveFileAs();
-  }
-  else
-  {
-    mapstorage.writeToFile(mapstorage.file_name);
-    mapstorage.modified = false;
-    signal_title.emit(Glib::filename_display_basename(mapstorage.file_name));
-  }
-}
-
-void NoteBookTab::saveFileAs()
-{
-  Gtk::FileChooserDialog fcdialog("Save File", Gtk::FILE_CHOOSER_ACTION_SAVE);
-  fcdialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
-  fcdialog.add_button(Gtk::Stock::SAVE, Gtk::RESPONSE_ACCEPT);
-  if (fcdialog.run() == Gtk::RESPONSE_ACCEPT)
-  {
-    Glib::ustring filename = fcdialog.get_filename();
-    mapstorage.file_name = filename;
-    mapstorage.writeToFile(filename);
-    mapstorage.modified = false;
-    signal_title.emit(Glib::filename_display_basename(filename));
-  }
-}
-
-void NoteBookTab::close()
-{
-  if (mapstorage.modified)
-  {
-    Gtk::MessageDialog mdialog("<b>Save changes before closing?</b>", true,
-        Gtk::MESSAGE_WARNING, Gtk::BUTTONS_NONE);
-    mdialog.add_button("Close _without Saving", Gtk::RESPONSE_REJECT);
-    mdialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
-    mdialog.add_button(Gtk::Stock::SAVE, Gtk::RESPONSE_ACCEPT);
-    switch (mdialog.run())
-    {
-      case Gtk::RESPONSE_CANCEL:
-        return;
-      case Gtk::RESPONSE_REJECT:
-        break;
-      case Gtk::RESPONSE_ACCEPT:
-        saveFile();
-        break;
-    }
-  }
-  gd_canvas->clear();
-  mapstorage.clear();
-  if(mapwinexists)
-    {
-      mapwin->update(mapstorage.getEdgeMapList(), mapstorage.getNodeMapList());
-    }
-  signal_title.emit("unsaved file");
-}
-
-void NoteBookTab::propertyChange(bool itisedge, int prop, std::string mapname)
-{
-  mapstorage.changeActiveMap(itisedge, prop, mapname);
-}
-
-sigc::signal<void, NoteBookTab *, bool> NoteBookTab::signal_newmap_needed()
-{
-  return signal_newmap;
-}
-
-void NoteBookTab::popupNewMapWin(bool itisedge)
-{
-  signal_newmap.emit(this, itisedge);
-}
-
-std::string NoteBookTab::getActiveEdgeMap(int prop)
-{
-  return mapstorage.getActiveEdgeMap(prop);
-}
-
-std::string NoteBookTab::getActiveNodeMap(int prop)
-{
-  return mapstorage.getActiveNodeMap(prop);
-}
-
-void NoteBookTab::registerNewEdgeMap(std::string mapname)
-{
-  if(mapwinexists)
-    {
-      mapwin->registerNewEdgeMap(mapname);
-    }
-}
-
-void NoteBookTab::registerNewNodeMap(std::string mapname)
-{
-  if(mapwinexists)
-    {
-      mapwin->registerNewNodeMap(mapname);
-    }
-}
-
-void NoteBookTab::createMapWin(std::string name)
-{
-  if(!mapwinexists)
-    {
-      mapwin=new MapWin("Map Setup - "+name, mapstorage.getEdgeMapList(), mapstorage.getNodeMapList(), *this);
-      mapst2mapwin=mapstorage.signal_map_win_ch().connect(sigc::mem_fun(*mapwin, &MapWin::changeEntry));
-      mapwin->show();
-      mapwinexists=true;
-    }
-}
-
-void NoteBookTab::createDesignWin(std::string name)
-{
-  if(!designwinexists)
-    {
-      double attraction, propulsation;
-      int iterations;
-      mapstorage.get_design_data(attraction, propulsation, iterations);
-      designwin=new DesignWin("Design Setup - "+name, attraction, propulsation, iterations, *this);
-
-      designwin->signal_attraction().connect(sigc::mem_fun(mapstorage, &MapStorage::set_attraction));
-      designwin->signal_propulsation().connect(sigc::mem_fun(mapstorage, &MapStorage::set_propulsation));
-      designwin->signal_iteration().connect(sigc::mem_fun(mapstorage, &MapStorage::set_iteration));
-      designwin->close_run().connect(sigc::mem_fun(*gd_canvas, &GraphDisplayerCanvas::reDesignGraph));
-
-      designwin->signal_delete_event().connect(sigc::mem_fun(*this, &NoteBookTab::closeDesignWin));
-
-      mapst2designwin=mapstorage.signal_design_win_ch().connect(sigc::mem_fun(*designwin, &DesignWin::set_data));
-
-      designwin->show();
-      designwinexists=true;
-    }
-}
-
-void NoteBookTab::closeMapWin()
-{
-  mapst2mapwin.disconnect();
-  mapwinexists=false;
-  delete mapwin;
-}
-
-bool NoteBookTab::closeDesignWin(GdkEventAny * e)
-{
-  if(e->type==GDK_DELETE)
-    {
-      designwinexists=false;
-      mapst2designwin.disconnect();
-      delete designwin;
-    }
-}
-
-sigc::signal<void, std::string> NoteBookTab::signal_title_ch()
-{
-  return signal_title;
-}
-
-void NoteBookTab::setView(bool autoscale, bool zoomtrack, double width, double radius)
-{
-  gd_canvas->setView(autoscale, zoomtrack, width, radius);
-}
-
-void NoteBookTab::getView(bool & autoscale, bool & zoomtrack, double& width, double& radius)
-{
-  gd_canvas->getView(autoscale, zoomtrack, width, radius);
-}
-
-void NoteBookTab::reDesignGraph()
-{
-  gd_canvas->reDesignGraph();
-}
-
-void NoteBookTab::active_maps_needed()
-{
-  mapstorage.broadcastActiveMaps();
-}
Index: tab.h
===================================================================
--- nbtab.h	(revision 177)
+++ 	(revision )
@@ -1,222 +1,0 @@
-/* -*- 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 NoteBookTab;
-
-#include "mapstorage.h"
-#include "map_win.h"
-#include "design_win.h"
-#include "graph_displayer_canvas.h"
-#include <libgnomecanvasmm.h>
-#include <libgnomecanvasmm/polygon.h>
-
-///One tab in the Notebook that is placed in the main window (\ref MainWin).
-
-///One graph 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 graph: view can be
-///set by visualized maps, therefore \ref NoteBookTab must provide an interface to set the
-///view of graph. This is \ref Mapwin window.
-///
-///\ref NoteBookTab is also
-///responsible for modify the graph if it is
-///requested. Therefore it is responsible for translating user events to modifications to
-///do on graph, like node/edge 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 GraphDisplayerCanvas, on which the graph will be drawn
-  ///Signals of \ref MapStorage will be bound to the appropriate callback functions here.
-  NoteBookTab();
-  
-  ///Maps assigned to the graph displayed in this \ref NoteBookTab of notebook.
-  MapStorage mapstorage;
-    
-  ///Title changement indicator.
-
-  ///If graph 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 edgemap 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 GraphDisplayerCanvas will be requested to display the graph.
-  ///\ref GraphDisplayer will get datas from the recently set \ref MapStorage.
-  void readFile(const std::string &);
-    
-  ///The graph will be drawn on this \ref GraphDisplayerCanvas
-  GraphDisplayerCanvas * 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;
-
-  ///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;
-
-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 graph.
-
-  ///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 GraphDisplayerCanvas to update the
-  ///appropriate parts of graph.
-  ///\param itiesedge whether the changed property is edge property or node property
-  ///\param prop id of property, see all_include.h
-  ///\param mapname name of the recently selected map
-  void propertyChange(bool itisedge, 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 itisedge whether the new map should be an edgemap or a nodemap.
-  void popupNewMapWin(bool itisedge);
-
-  ///Returns the actually selected edgemap 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 getActiveEdgeMap(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 edgemap 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 registerNewEdgeMap(std::string mapname);
-
-  ///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);
-
-  ///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);
-
-  ///Closes and deregistrates the \ref MapWin of \ref NoteBookTab.
-  
-  ///See also
-  ///\ref mapwin.
-  void closeMapWin();
-
-  bool closeDesignWin(GdkEventAny *);
-
-  ///Sets node representation settings
-  void setView(bool, bool, double, double);
-
-  ///Gets node representation settings
-  void getView(bool &, bool &, double&, double&);
-
-  ///Let the graph redesign, based on gravity and edge elasticity.
-  void reDesignGraph();
-
-  ///\ref MapWin calls this function when it updates the maplist in comboboxes.
-  void active_maps_needed();
-
-private:
-  ///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
Index: w_map_win.cc
===================================================================
--- new_map_win.cc	(revision 174)
+++ 	(revision )
@@ -1,517 +1,0 @@
-/* -*- 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.
- *
- */
-
-#include <new_map_win.h>
-
-bool NewMapWin::closeIfEscapeIsPressed(GdkEventKey* e)
-{
-  if(e->keyval==GDK_Escape)
-  {
-    hide();
-  }
-  return true;
-}
-
-NewMapWin::NewMapWin(const std::string& title, NoteBookTab & mw, bool itisedge, bool edgenode):Gtk::Dialog(title, true, true),mytab(mw),node("Create NodeMap"),edge("Create EdgeMap")
-{
-  set_default_size(200, 50);
-
-  signal_key_press_event().connect(sigc::mem_fun(*this, &NewMapWin::closeIfEscapeIsPressed));
-
-  Gtk::VBox * vbox=get_vbox();
-
-  //entries
-  table=new Gtk::Table(3, 2, false);
-
-  label=new Gtk::Label;
-  label->set_text("Name of new map:");
-  name.set_text("");
-
-  (*table).attach(*label,0,1,0,1,Gtk::SHRINK,Gtk::SHRINK,10,3);
-  (*table).attach(name,1,2,0,1,Gtk::SHRINK,Gtk::SHRINK,10,3);
-
-  label=new Gtk::Label;
-  label->set_text("Default value in the map:");
-  default_value.set_text("0");
-
-  (*table).attach(*label,0,1,1,2,Gtk::SHRINK,Gtk::SHRINK,10,3);
-  (*table).attach(default_value,1,2,1,2,Gtk::SHRINK,Gtk::SHRINK,10,3);
-
-  //node vs. edge map selector
-  Gtk::RadioButton::Group group = node.get_group();
-  edge.set_group(group);
-  
-  if(edgenode)
-    {
-      (*table).attach(node,0,1,2,3,Gtk::SHRINK,Gtk::SHRINK,10,3);
-      (*table).attach(edge,1,2,2,3,Gtk::SHRINK,Gtk::SHRINK,10,3);
-    }
-  else
-    {
-      if(itisedge)
-	{
-	  edge.set_active();
-	}
-      else
-	{
-	  node.set_active();
-	}
-    }
-
-  vbox->pack_start(*table);
-
-  //OK button
-  add_button(Gtk::Stock::OK, Gtk::RESPONSE_OK);
-
-  show_all_children();
-
-}
-
-void NewMapWin::on_response(int response_id)
-{
-  if(response_id==Gtk::RESPONSE_OK)
-    {
-      double def_val=0;
-
-      //get and formulate text
-      std::string def_val_str=default_value.get_text();
-
-      bool only_nums=true;
-      for(int i=0;i<(int)def_val_str.size() && only_nums;i++)
-	{
-	  if( def_val_str[i]<'0' || def_val_str[i]>'9' )
-	    {
-	      only_nums=false;
-	    }
-	}
-      std::string polishform;
-
-      if(only_nums)
-	{
-	  def_val=atof(def_val_str.c_str());
-	}
-      else
-	{
-	  polishform=string2Polishform(def_val_str,edge.get_active());
-	}
-
-      //get name of text
-      std::string mapname=name.get_text();
-      
-      if(!mapname.empty()&&(!polishform.empty()||only_nums))
-	{
-	  int abortion=0;
-	  if(edge.get_active())
-	    {
-	      //create the new map
-	      Graph::EdgeMap<double> * emptr=new Graph::EdgeMap<double> (mytab.mapstorage.graph, def_val);
-	      
-	      if(!only_nums)
-		{
-		  std::stack<double> polishstack;
-		  
-		  for(EdgeIt k(mytab.mapstorage.graph); k!=INVALID; ++k)
-		    {
-		      for(int i=0;i<(int)polishform.size();i++)
-			{
-			  double op1=0, op2=0;
-			  bool operation=true;
-			  switch(polishform[i])
-			    {
-			    case '+':
-			    case '-':
-			    case '/':
-			    case '*':
-			      op1=polishstack.top();
-			      polishstack.pop();
-			      op2=polishstack.top();
-			      polishstack.pop();
-			      break;
-			    default:
-			      //substitute variable
-			      std::map< std::string,Graph::EdgeMap<double> * > ems=mytab.mapstorage.edgemap_storage;
-			      bool itisvar=(ems.find(ch2var[ polishform[i] ])!=ems.end());
-			      if(itisvar)
-				{
-				  polishstack.push( (*(mytab.mapstorage.edgemap_storage[ ch2var[ polishform[i] ] ]))[k]);
-				}
-			      else
-				{
-				  polishstack.push(atof(ch2var[ polishform[i] ].c_str()));
-				}
-			      operation=false;
-			      break;
-			    }
-			  if(operation)
-			    {
-			      double res;
-			      switch(polishform[i])
-				{
-				case '+':
-				  res=op1+op2;
-				  break;
-				case '-':
-				  res=op2-op1;
-				  break;
-				case '/':
-				  res=op2/op1;
-				  break;
-				case '*':
-				  res=op1*op2;
-				  break;
-				default:
-				  std::cout << "How could we get here?" << std::endl;
-				  break;
-				}
-			      polishstack.push(res);
-			    }
-			}//foreach letter in polishform
-		      (*emptr)[k]=polishstack.top(); 
-		    }//foreach edge
-		}//!only_nums
-
-	      //if addition was not successful addEdgeMap returns one.
-	      //cause can be that there is already a map named like the new one
-	      if(mytab.mapstorage.addEdgeMap(mapname, emptr, def_val))
-		{
-		  abortion=1;
-		}
-
-	      //add it to the list of the displayable maps
-	      //furthermore it is done by signals
-	      //mytab.registerNewEdgeMap(mapname);
-
-	      //display it
-	      //gdc.changeEdgeText(mapname);
-	    }
-	  else //!edge.get_active()
-	    {
-	      //create the new map
-	      Graph::NodeMap<double> * emptr=new Graph::NodeMap<double> (mytab.mapstorage.graph, def_val);
-
-	      if(!only_nums)
-		{
-		  std::stack<double> polishstack;
-  
-		  for(NodeIt k(mytab.mapstorage.graph); k!=INVALID; ++k)
-		    {
-		      for(int i=0;i<(int)polishform.size();i++)
-			{
-			  double op1=0, op2=0;
-			  bool operation=true;
-			  switch(polishform[i])
-			    {
-			    case '+':
-			    case '-':
-			    case '/':
-			    case '*':
-			      op1=polishstack.top();
-			      polishstack.pop();
-			      op2=polishstack.top();
-			      polishstack.pop();
-			      break;
-			    default:
-			      std::map< std::string,Graph::NodeMap<double> * > nms=mytab.mapstorage.nodemap_storage;
-			      bool itisvar=(nms.find(ch2var[ polishform[i] ])!=nms.end());
-			      if(itisvar)
-				{
-				  polishstack.push( (*(mytab.mapstorage.nodemap_storage[ ch2var[ polishform[i] ] ]))[k]);
-				}
-			      else
-				{
-				  polishstack.push(atof(ch2var[ polishform[i] ].c_str()));
-				}
-			      operation=false;
-			      break;
-			    }
-			  if(operation)
-			    {
-			      double res;
-			      switch(polishform[i])
-				{
-				case '+':
-				  res=op1+op2;
-				  break;
-				case '-':
-				  res=op2-op1;
-				  break;
-				case '/':
-				  res=op2/op1;
-				  break;
-				case '*':
-				  res=op1*op2;
-				  break;
-				default:
-				  std::cout << "How could we get here?" << std::endl;
-				  break;
-				}
-			      polishstack.push(res);
-			    }
-			}
-		      (*emptr)[k]=polishstack.top(); 
-		    }
-		}
-	      //if addition was not successful addNodeMap returns one.
-	      //cause can be that there is already a map named like the new one
-	      if(mytab.mapstorage.addNodeMap(mapname,emptr, def_val))
-		{
-		  abortion=1;
-		}
-
-	      //add it to the list of the displayable maps
-	      //furthermore it is done by signals
-	      //mytab.registerNewNodeMap(mapname);
-
-	      //display it
-	      //gdc.changeNodeText(mapname);
-	    }
-	  if(!abortion)
-	    {
-	      name.set_text("");
-	      default_value.set_text("0");
-	      edge.show();
-	      node.show();
-	      hide();
-	    }
-	}
-    }
-}
-
-
-std::string NewMapWin::string2Polishform(std::string rawcommand, bool itisedge)
-{
-  bool valid_entry=true;
-
-  std::map<std::string, int> str2i;
-
-  std::string command;
-
-  std::string variable;
-
-  char index='a';
-
-  for(int i=0;(valid_entry&&(i<(int)rawcommand.size()));i++)
-    {
-      switch(rawcommand[i])
-	{
-	case '+':
-	case '-':
-	case '*':
-	case '/':
-	case ')':
-	case '(':
- 	  if(!variable.empty())
-	    {
-	      valid_entry=validVariable(variable, itisedge);
-	      ch2var[index]=variable;
-	      command+=index;
-	      index++;
-	      variable.erase(0,variable.size());	  
-	    }
-	  command+=rawcommand[i];
-	  break;
-	default:
-	  variable+=rawcommand[i];
-	  break;
-	}
-    }
-
-  if(!variable.empty()&&valid_entry)
-    {
-      valid_entry=validVariable(variable, itisedge);
-      ch2var[index]=variable;
-      command+=index;
-      index++;
-      variable.erase(0,variable.size());	  
-    }
-
-  if(valid_entry)
-    {
-      unsigned int pr=10000;
-      bool prevmult=false;
-      unsigned int prev_change=pr;
-      unsigned int prev_br=pr;
-      int counter=0;
-      std::string comm_nobr="";
-      std::vector<unsigned int> p;
-      p.resize(counter+1);
-      
-      //limits
-      //6 brackets embedded
-      //100 operation in a row from the same priority
-      
-      for(int i=0;i<(int)command.size();i++)
-	{
-	  bool put_in_string=true;
-	  switch(command[i])
-	    {
-	    case '(':
-	      pr=prev_br+10000;
-	      prev_br=pr;
-	      prevmult=false;
-	      put_in_string=false;
-	      break;
-	    case ')':
-	      pr=prev_br-10000;
-	      prev_br=pr;
-	      prevmult=false;
-	      put_in_string=false;
-	      break;
-	    case '+':
-	    case '-':
-	      if(prevmult)
-		{
-		  pr=prev_change;
-		}
-	      p[counter]=pr;
-	      pr-=100;
-
-	      prevmult=false;
-	      break;
-	    case '/':
-	    case '*':
-	      if(!prevmult)
-		{
-		  prev_change=pr;
-		  pr+=200;
-		  pr-=1;
-		}
-	      p[counter]=pr;
-	      pr-=1;
-	      prevmult=true;
-	      break;
-	    default:
-	      p[counter]=65000;
-	      break;
-	    }
-	  if(put_in_string)
-	    {
-	      counter++;
-	      p.resize(counter+1);
-	      comm_nobr=comm_nobr+command[i];
-	    }
-	}
-
-      tree_node * root=weightedString2Tree(comm_nobr, p, 0);
-
-      std::string polishform=postOrder(root);
-
-      deleteTree(root);
-
-      return polishform;
-    }
-  return "";
-}
-
-void NewMapWin::deleteTree(NewMapWin::tree_node * node)
-{
-  if(node->left_child!=NULL)
-    {
-      deleteTree(node->left_child);
-    }
-  if(node->right_child!=NULL)
-    {
-      deleteTree(node->right_child);
-    }
-  delete node;
-}
-
-NewMapWin::tree_node * NewMapWin::weightedString2Tree(std::string to_tree, std::vector<unsigned int> & p, int offset)
-{
-  unsigned int min=p[offset];
-  int minplace=0;
-  for(int i=0;i<(int)to_tree.size();i++)
-    {
-      if(min>p[offset+i])
-	{
-	  min=p[offset+i];
-	  minplace=i;
-	}
-    }
-  tree_node * act_node=new tree_node;
-  act_node->ch=to_tree[minplace];
-  if(to_tree.size()>=3)
-    {
-      act_node->left_child=weightedString2Tree(to_tree.substr(0,minplace), p, offset);
-      act_node->right_child=weightedString2Tree(to_tree.substr(minplace+1,to_tree.size()-minplace-1), p, offset+minplace+1);
-    }
-  else
-    {
-      act_node->left_child=NULL;
-      act_node->right_child=NULL;
-    }
-  return act_node;
-}
-
-std::string NewMapWin::postOrder(tree_node * subtree)
-{
-  std::string subtree_to_string;
-  if(subtree->left_child)
-    {
-      subtree_to_string=postOrder(subtree->left_child);
-    }
-  if(subtree->right_child)
-    {
-      subtree_to_string=subtree_to_string+postOrder(subtree->right_child);
-    }
-  subtree_to_string=subtree_to_string+subtree->ch;
-  return subtree_to_string;
-}
-
-bool NewMapWin::validVariable(std::string variable, bool itisedge)
-{
-  bool cancel;
-  //is it mapname?
-  if(itisedge)
-    {
-      cancel=(mytab.mapstorage.edgemap_storage.find(variable)==mytab.mapstorage.edgemap_storage.end());
-    }
-  else
-    {
-      cancel=(mytab.mapstorage.nodemap_storage.find(variable)==mytab.mapstorage.nodemap_storage.end());
-    }
-  //maybe it is number
-  int point_num=0;
-  if(cancel)
-    {
-      cancel=false;
-      for(int j=0;(!cancel)&&(j<(int)variable.size());j++)
-	{
-	  if(((variable[j]<'0')||(variable[j]>'9'))&&(variable[j]!='.'))
-	    {
-	      cancel=true;
-	    }
-	  else
-	    {
-	      if(variable[j]=='.')
-		{
-		  point_num++;
-		  if(point_num>1)
-		    {
-		      cancel=true;
-		    }
-		}
-	    }
-	}
-    }
-  if(cancel)
-    {
-      return false;
-    }
-  return true;
-}
Index: w_map_win.h
===================================================================
--- new_map_win.h	(revision 174)
+++ 	(revision )
@@ -1,152 +1,0 @@
-/* -*- 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 NEWMAPWIN_H
-#define NEWMAPWIN_H
-
-class NewMapWin;
-
-#include <all_include.h>
-#include <nbtab.h>
-#include <libgnomecanvasmm.h>
-#include <libgnomecanvasmm/polygon.h>
-#include <stack>
-
-///Graphical interface for node/edge map creation.
-
-///This class is responsible for creating a window,
-///on which the parameters of a new map can be set.
-class NewMapWin : public Gtk::Dialog
-{
-  ///The \ref NoteBookTab in which the new map has to be placed.
-  NoteBookTab & mytab;
-
-public:
-
-  ///Struct to be able to evaluate expressions.
-
-  ///Initial values of map elements can be given
-  ///by numbers or by expressions. From expressions
-  ///we build first a tree according to the priorities
-  ///of operations in the expression. This is the data
-  ///structure
-  ///that can store one tree element.
-  struct tree_node
-  {
-    ///Character stored in this tree element
-    char ch;
-    ///Left child of tree element.
-    tree_node * left_child;
-    ///Right child of tree element.
-    tree_node * right_child;
-  };
-  
-  ///Constructor of NewMapWin.
-
-  ///It creates the widgets shown in
-  ///NewMapWin.
-  NewMapWin(const std::string& title, NoteBookTab &, bool itisedge=true, bool edgenode=true);
-
-  ///Callback function for OK button. It creates the map.
-  
-  ///This function determines whether the input is correct:
-  ///the name of new map must not be already used, the expression
-  ///that gives tha initial values of map elements has to be valid.
-  ///If input is correct it creates and registrates the new map
-  ///to the correct place. (\ref mytab)
-  virtual void on_response(int response_id);
-
-  ///Close window if Esc key pressed.
-  virtual bool closeIfEscapeIsPressed(GdkEventKey*);
-
-  ///Function that creates a tree from an appropriately manipulated string.
-
-  ///Tree is builded according to priorities of operations in expression given by string.
-  ///Priorities are indicated in a vector that contains weights for each operation.
-  ///\param to_tree string to build tree from
-  ///\param weights weights (priorities)
-  ///\param offset this function call is recursive. This parameter tells us,
-  ///with which part of the string do we have to deal with.
-  tree_node * weightedString2Tree(std::string to_tree, std::vector<unsigned int> & weights, int offset);
-
-  ///Function that creates a string from a tree by postorder reading.
-
-  ///This is the last step of creating polishform
-  ///from a given expression string.
-  ///\param root the root of the tree to read through
-  std::string postOrder(tree_node * root);
-
-  ///From the given expression it creates expression given in polish form.
-
-  ///First it substitutes variables and numbers in the given expression.
-  ///The substitutions will be one character long local variables.
-  ///The substituted-substitution pair is registrated in \ref ch2var.
-  ///After that it gives weights fo each character in substituted expression.
-  ///Weights are calculated according to the priority of operations in expression.
-  ///Then it creates tree (\ref tree_node) from the weighted string. (\ref weightedString2Tree)
-  ///\param to_polish the string to turn into polish_form
-  ///\param itisedge do we have to create an edgemap or a nodemap.
-  ///It is important, because variables are maps and if expression
-  ///citates a map that does not exists the expression is not valid.
-  ///But to determine, whether the map exists we have to know where
-  ///to search for it. And of course for a new edgemap only edgemaps can be serve with values. 
-  std::string string2Polishform(std::string to_polish, bool itisedge);
-
-  ///Returns whether a string can be used as value in an expression.
-
-  ///The given string has to be either a mapname or a number. If it is a mapname
-  ///we have to know whether it is an edgemap or a nodemap.
-  ///\param variable the string about the function has to determine whether it is usable in expressions
-  ///\param itisedge should the mapname be between edgemaps, or nodemaps
-  bool validVariable(std::string variable, bool itisedge);
-
-  ///Deletes the whole tree created for translating string to polishform.
- 
-  ///\param root
-  ///root of the tree
-  void deleteTree(tree_node * root);
-
-  ///Dictionary of substitutions in expression.
-
-  ///Variables and numbers are substituted with one character long variables in expressions.
-  ///This is the dictionary.
-  std::map<char, std::string> ch2var;
-
-  ///Entry which gives us the name of new map.
-  Gtk::Entry name;
-
-  ///Entry which gives us the initial values of elements of new map.
-
-  ///Initial value can be a number or an expression after that the
-  ///initial value for each map element can be calculated.
-  Gtk::Entry default_value;
-
-  ///GTK Designing object.
-  Gtk::Table * table;
-
-  ///Information holder in window.
-  Gtk::Label * label;
-
-  ///If selected, nodemap will be created.
-  Gtk::RadioButton node;
-
-  ///If selected, edgemap will be created.
-  Gtk::RadioButton edge;
-};
-
-#endif //NEWMAPWIN_H
Index: LINGUAS
===================================================================
--- po/LINGUAS	(revision 130)
+++ 	(revision )
@@ -1,1 +1,0 @@
-hu
Index: Makevars
===================================================================
--- po/Makevars	(revision 130)
+++ 	(revision )
@@ -1,41 +1,0 @@
-# Makefile variables for PO directory in any package using GNU gettext.
-
-# Usually the message domain is the same as the package name.
-DOMAIN = $(PACKAGE)
-
-# These two variables depend on the location of this directory.
-subdir = po
-top_builddir = ..
-
-# These options get passed to xgettext.
-XGETTEXT_OPTIONS = --keyword=_ --keyword=N_
-
-# This is the copyright holder that gets inserted into the header of the
-# $(DOMAIN).pot file.  Set this to the copyright holder of the surrounding
-# package.  (Note that the msgstr strings, extracted from the package's
-# sources, belong to the copyright holder of the package.)  Translators are
-# expected to transfer the copyright for their translations to this person
-# or entity, or to disclaim their copyright.  The empty string stands for
-# the public domain; in this case the translators are expected to disclaim
-# their copyright.
-COPYRIGHT_HOLDER = Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
-
-# This is the email address or URL to which the translators shall report
-# bugs in the untranslated strings:
-# - Strings which are not entire sentences, see the maintainer guidelines
-#   in the GNU gettext documentation, section 'Preparing Strings'.
-# - Strings which use unclear terms or require additional context to be
-#   understood.
-# - Strings which make invalid assumptions about notation of date, time or
-#   money.
-# - Pluralisation problems.
-# - Incorrect English spelling.
-# - Incorrect formatting.
-# It can be your email address, or a mailing list address where translators
-# can write to without being subscribed, or the URL of a web page through
-# which the translators can contact you.
-MSGID_BUGS_ADDRESS = $(PACKAGE_BUGREPORT)
-
-# This is the list of locale categories, beyond LC_MESSAGES, for which the
-# message catalogs shall be used.  It is usually empty.
-EXTRA_LOCALE_CATEGORIES =
Index: POTFILES.in
===================================================================
--- po/POTFILES.in	(revision 139)
+++ 	(revision )
@@ -1,35 +1,0 @@
-# List of source files which contain translatable strings.
-algobox.cc
-algobox.h
-algowin.cc
-algowin.h
-all_include.h
-gdc-broken_edge.cc
-gettext.h
-graph_displayer_canvas.cc
-graph_displayer_canvas-edge.cc
-graph_displayer_canvas-event.cc
-graph_displayer_canvas.h
-graph_displayer_canvas-node.cc
-graph_displayer_canvas-zoom.cc
-graph-displayer.cc
-gui_reader.cc
-gui_reader.h
-gui_writer.cc
-gui_writer.h
-kruskalbox.cc
-kruskalbox.h
-main_win.cc
-main_win.h
-mapselector.cc
-mapselector.h
-mapstorage.cc
-mapstorage.h
-map_win.cc
-map_win.h
-nbtab.cc
-nbtab.h
-new_map_win.cc
-new_map_win.h
-xml.h
-xymap.h
Index: glemon.pot
===================================================================
--- po/glemon.pot	(revision 139)
+++ 	(revision )
@@ -1,89 +1,0 @@
-# SOME DESCRIPTIVE TITLE.
-# Copyright (C) YEAR Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
-# This file is distributed under the same license as the PACKAGE package.
-# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
-#
-#, fuzzy
-msgid ""
-msgstr ""
-"Project-Id-Version: PACKAGE VERSION\n"
-"Report-Msgid-Bugs-To: etik-ol@cs.elte.hu\n"
-"POT-Creation-Date: 2006-04-14 20:37+0200\n"
-"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
-"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
-"Language-Team: LANGUAGE <LL@li.org>\n"
-"MIME-Version: 1.0\n"
-"Content-Type: text/plain; charset=CHARSET\n"
-"Content-Transfer-Encoding: 8bit\n"
-
-#: main_win.cc:80
-msgid "_File"
-msgstr ""
-
-#: main_win.cc:85
-msgid "Clear Tab"
-msgstr ""
-
-#: main_win.cc:96
-msgid "_View"
-msgstr ""
-
-#: main_win.cc:106
-msgid "_Show"
-msgstr ""
-
-#: main_win.cc:107
-msgid "_Maps"
-msgstr ""
-
-#: main_win.cc:110
-msgid "_Algorithms"
-msgstr ""
-
-#: main_win.cc:111
-msgid "_General"
-msgstr ""
-
-#: main_win.cc:113
-msgid "_Kruskal"
-msgstr ""
-
-#: main_win.cc:117
-msgid "Move"
-msgstr ""
-
-#: main_win.cc:119
-msgid "Create node"
-msgstr ""
-
-#: main_win.cc:121
-msgid "Create edge"
-msgstr ""
-
-#: main_win.cc:123
-msgid "Delete"
-msgstr ""
-
-#: main_win.cc:126
-msgid "Edit edge map"
-msgstr ""
-
-#: main_win.cc:128
-msgid "Edit node map"
-msgstr ""
-
-#: main_win.cc:259
-msgid "unsaved file"
-msgstr ""
-
-#: main_win.cc:269
-msgid "<b>Save changes before closing?</b>"
-msgstr ""
-
-#: main_win.cc:271
-msgid "Close file _without Saving"
-msgstr ""
-
-#: main_win.cc:458 main_win.cc:487
-msgid "Create New Map - "
-msgstr ""
Index: hu.po
===================================================================
--- po/hu.po	(revision 139)
+++ 	(revision )
@@ -1,89 +1,0 @@
-# Hungarian translations for LEMON package.
-# Copyright (C) 2006 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
-# This file is distributed under the same license as the LEMON package.
-# Ladanyi Akos <ladanyi@tmit.bme.hu>, 2006.
-#
-msgid ""
-msgstr ""
-"Project-Id-Version: gLEMON svn-head\n"
-"Report-Msgid-Bugs-To: etik-ol@cs.elte.hu\n"
-"POT-Creation-Date: 2006-04-14 20:37+0200\n"
-"PO-Revision-Date: 2006-03-22 15:55+0100\n"
-"Last-Translator: Ladanyi Akos <ladanyi@tmit.bme.hu>\n"
-"Language-Team: Hungarian <translation-team-hu@lists.sourceforge.net>\n"
-"MIME-Version: 1.0\n"
-"Content-Type: text/plain; charset=UTF-8\n"
-"Content-Transfer-Encoding: 8bit\n"
-"Plural-Forms: nplurals=1; plural=0;\n"
-
-#: main_win.cc:80
-msgid "_File"
-msgstr "_FÃ¡jl"
-
-#: main_win.cc:85
-msgid "Clear Tab"
-msgstr "Lap tÃ¶rlÃ©se"
-
-#: main_win.cc:96
-msgid "_View"
-msgstr "_NÃ©zet"
-
-#: main_win.cc:106
-msgid "_Show"
-msgstr "_Mutat"
-
-#: main_win.cc:107
-msgid "_Maps"
-msgstr "_Mapek"
-
-#: main_win.cc:110
-msgid "_Algorithms"
-msgstr "_Algoritmusok"
-
-#: main_win.cc:111
-msgid "_General"
-msgstr "_ÃltalÃ¡nos"
-
-#: main_win.cc:113
-msgid "_Kruskal"
-msgstr "_Kruskal"
-
-#: main_win.cc:117
-msgid "Move"
-msgstr "Mozgat"
-
-#: main_win.cc:119
-msgid "Create node"
-msgstr "CsÃºcs lÃ©trehozÃ¡sa"
-
-#: main_win.cc:121
-msgid "Create edge"
-msgstr "Ãl lÃ©trehozÃ¡sa"
-
-#: main_win.cc:123
-msgid "Delete"
-msgstr "TÃ¶rlÃ©s"
-
-#: main_win.cc:126
-msgid "Edit edge map"
-msgstr "Ãl map szerkesztÃ©se"
-
-#: main_win.cc:128
-msgid "Edit node map"
-msgstr "CsÃºcs map szerkesztÃ©se"
-
-#: main_win.cc:259
-msgid "unsaved file"
-msgstr "nem mentett fÃ¡jl"
-
-#: main_win.cc:269
-msgid "<b>Save changes before closing?</b>"
-msgstr "Menti a vÃ¡ltozÃ¡sokat mielÅtt bezÃ¡rja?"
-
-#: main_win.cc:271
-msgid "Close file _without Saving"
-msgstr "BezÃ¡rÃ¡s mentÃ©s _nÃ©kÃŒl"
-
-#: main_win.cc:458 main_win.cc:487
-msgid "Create New Map - "
-msgstr "Ãj map lÃ©trehozÃ¡sa - "
Index: src/Makefile.am
===================================================================
--- src/Makefile.am	(revision 0)
+++ src/Makefile.am	(revision 0)
@@ -0,0 +1,6 @@
+AM_CPPFLAGS = -I$(top_srcdir)/src
+LDADD = $(top_builddir)/src/lemon/libemon.la
+
+bin_PROGRAMS = gui
+
+gui_SOURCES = main.cc
Index: src/main.cc
===================================================================
--- src/main.cc	(revision 0)
+++ src/main.cc	(revision 0)
@@ -0,0 +1,10 @@
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <iostream>
+
+int main()
+{
+  std::cout << "Hello World!" << std::endl;
+}
Index: l.h
===================================================================
--- xml.h	(revision 174)
+++ 	(revision )
@@ -1,444 +1,0 @@
-/* -*- 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.
- *
- */
-
-#include <iostream>
-#include <string>
-#include <vector>
-#include <list>
-#include <map>
-#include <lemon/error.h>
-#include <lemon/dim2.h>
-
-namespace lemon {
-
-  class XmlIo 
-  {
-    bool _writeMode;
-  public:
-    ///Check if XmlIo is in write mode.
-    bool write() { return _writeMode;}
-    ///Check if XmlIo is in read mode.
-    bool read() { return !_writeMode;}
-
-    std::ostream& os;
-    int level;
-    
-  protected:
-    void indent(int level) {
-      os << std::endl;
-      for(int i=0;i<level;i++) os << ' ';
-    }
-    void tag(const std::string &_tag) {
-      os << '<' << _tag << '>';
-    }
-    void etag(const std::string &_tag) {
-      os << "</" << _tag << '>';
-    }
-    void itag(const std::string &_tag) { indent();tag(_tag); }
-    void ietag(const std::string &_tag) { indent();etag(_tag); }
-
-    void beginTag(const std::string &_tag) {
-      itag(_tag);
-      level++;
-    }
-    void endTag(const std::string &_tag) {
-      level--;
-      ietag(_tag);
-    }
-
-  public:
-    ///Indent the line according to its level.
-
-    ///\warning It can only be used in write mode.
-    ///
-    void indent()
-    {
-      if(write())
-	if(level>=0) indent(level);
-	else level=0;
-      else throw LogicError();	
-    }
-  
-    ///Read/write a tag
-  
-    ///Read/write a tag.
-    ///In write mode it does not start a new line.
-    class ContTag
-    {
-      XmlIo &ix;
-      const std::string _tag;
-    public:
-      ///\e
-  
-      ///\e
-      ///
-      ContTag(XmlIo &_ix,const std::string &_t) :
-	ix(_ix), _tag(_t)
-      {
-	if(ix.write()) ix.tag(_tag);
-	else ix.useTag(_tag);
-      }
-      ~ContTag() { 
-	if(ix.write()) ix.etag(_tag);
-	else if(!std::uncaught_exception()) ix.useTag('/'+_tag);      
-      }
-    };
-
-    ///Read/write a tag
-  
-    ///Read/write a tag.
-    ///The whole \<foo\> ... \</foo\> will be placed in a single line.
-    class LineTag
-    {
-      XmlIo &ix;
-      const std::string _tag;
-    public:
-      ///\e
-    
-      ///\e
-      ///
-      LineTag(XmlIo &_ix,const std::string &_t) :
-	ix(_ix), _tag(_t)
-      {
-	if(ix.write()) ix.itag(_tag);
-	else ix.useTag(_tag);
-      }
-      ~LineTag() { 
-	if(ix.write()) ix.etag(_tag);
-	else if(!std::uncaught_exception()) ix.useTag('/'+_tag);
-      }
-    };
-
-    ///Read/write a tag
-  
-    ///Read/write a tag.
-    ///
-    class Tag
-    {
-      XmlIo &ix;
-      const std::string _tag;
-    public:
-      ///\e
-  
-      ///\e
-      ///
-      Tag(XmlIo &_ix,const std::string &_t) :
-	ix(_ix), _tag(_t)
-      {
-	if(ix.write()) ix.beginTag(_tag);
-	else ix.useTag(_tag);
-      }
-      ~Tag() {
-	if(ix.write()) ix.endTag(_tag);
-	else if(!std::uncaught_exception()) ix.useTag('/'+_tag);
-      }
-    };
-
-  private:
-    std::istream& is;
-    std::string next_tag;
-    int line_number;
-
-    void skipWhiteSpaces()
-    {
-      if(write()) throw LogicError();
-      {
-	char c;
-	while (is.get(c) && std::isspace(c,is.getloc()))
-	  if(c=='\n') line_number++;
-	is.unget();
-      }
-    }
-  protected:
-    /// Use the next tag.
-
-    ///\e
-    ///
-    void useTag() {next_tag.clear();}
-  
-    ///Use the next tag and check if it is equal with \c _tag
-  
-    ///\e
-    ///
-    void useTag(const std::string &_tag) {
-      if(nextTag()==_tag) useTag();
-      else throw DataFormatError("",line_number,"Unexpected token name");
-    }
-  public:
-    ///Return the next tag (if a tag follows on the stream).
-  
-    ///\warning It can only be used in read mode.
-    ///
-    const std::string &nextTag() 
-    {
-      if(write()) throw LogicError();
-      else if(next_tag.empty()) {
-	char c;
-	skipWhiteSpaces();
-	if(!is.get(c) || c!='<')
-	  throw DataFormatError("",line_number,"Bad format");
-	next_tag.clear();
-	while (is.get(c) && c!='>') next_tag.push_back(c);
-	if(c!='>')
-	  throw DataFormatError("",line_number,"Bad format");
-      }
-      return next_tag;
-    }
-
-    /**********************************************************************/
-
-
-    ///\e
-  
-    ///\e
-    ///
-    XmlIo(std::ostream& _os) : _writeMode(true), os(_os),
-			       level(-1),
-			       is(std::cin) {}
-    ///\e
-    ///
-    XmlIo(std::istream& _is) : _writeMode(false),
-			       os(std::cout), is(_is),
-			       line_number(1) {}
-
-    ~XmlIo() { if(write()) os<< std::endl; }
-  
-
-
-    XmlIo &operator()(const int &v) 
-    { 
-      if(write()) os << v;
-      else {
-	skipWhiteSpaces();
-	if(!(is >> const_cast<int &>(v))) 
-	  throw DataFormatError("",line_number,"Not an 'int'");
-      }
-      return *this;
-    }
-    XmlIo &operator()(const double &v) 
-    {
-      if(write()) os << v;
-      else {
-	skipWhiteSpaces();
-	if(!(is >> const_cast<double &>(v))) 
-	  throw DataFormatError("",line_number,"Not an 'double'");
-      }
-      return *this;
-    }
-    XmlIo &operator()(const std::string &v)
-    {
-      if(write())
-	for(std::string::const_iterator i=v.begin();i!=v.end();++i)
-	  switch(*i) {
-	  case '\\':
-	    os << "\\\\";
-	    break;
-	  case '<':
-	    os << "\\<";
-	    break;
-	  case '&':
-	    os << "\\&";
-	    break;
-	  case '\n':
-	    os << "\\n";
-	    break;
-	  default:
-	    os<<*i;
-	    break;
-	  }
-      else {
-	std::string &w = const_cast<std::string &>(v);
-	w.clear();
-	char c;
-	while (is.get(c) && c!='<')
-	  if(c=='\\')
-	    if(!is.get(c))
-	      throw DataFormatError("",line_number,"Bad string");
-	    else switch(c) {
-	    case 'n':
-	      w.push_back('\n');
-	      break;
-	    default:
-	      w.push_back(c);
-	      break;
-	    }
-	  else {
-	    if(c=='\n') line_number++;
-	    w.push_back(c);
-	  }
-	if(c!='<')
-	  throw DataFormatError("",line_number,"Unexpected eof");
-	is.unget();
-      }
-      return *this;
-    }
-
-
-    XmlIo &operator()(const std::string &_tag,const int &v) 
-    { 
-      LineTag t(*this,_tag);
-      (*this)(v);
-      return *this;
-    }
-    XmlIo &operator()(const std::string &_tag,const double &v) 
-    {
-      LineTag t(*this,_tag);
-      (*this)(v);
-      return *this;
-    }
-    XmlIo &operator()(const std::string &_tag,const std::string &v)
-    {
-      LineTag t(*this,_tag);
-      (*this)(v);
-      return *this;
-    }
-    ///\e
-  
-    ///\e
-    ///
-    template<class V>
-    XmlIo &operator()(const std::string &_tag,const V &v)
-    {
-      Tag t(*this,_tag);
-      xml(*this,const_cast<V &>(v));
-      return *this;
-    }
-    ///\e
-  
-    ///\e
-    ///
-    template<class V>
-    XmlIo &operator()(const V &v)
-    {
-      xml(*this,const_cast<V &>(v));
-      return *this;
-    }
-    };
-
-  //////////////////////////////////////////////////////////////////////
-  //////////////////////////////////////////////////////////////////////
-
-  ///\e
-  
-  ///\relates XmlIo
-  ///
-  template<class A>
-  void xml(XmlIo &x,std::auto_ptr<A> &v)
-  {
-    if(x.write()) v=new A;
-    x(*v);
-  }
-  
-  ///\e
-  
-  ///\relates XmlIo
-  ///
-  template<class A,class B>
-  void xml(XmlIo &x,std::pair<A,B> &v)
-  {
-    x("first",v.first);
-    x("second",v.second);
-  }
-
-  ///\e
-  
-  ///\relates XmlIo
-  ///
-  template<class T>
-  void xml(XmlIo &x,std::list<T> &v)
-  {
-    if(x.write())
-      for(typename std::list<T>::const_iterator it=v.begin();
-	  it!=v.end();++it) x("item",*it);
-    else while(x.nextTag()=="item")
-      {
-	v.push_back(T());
-	x("item",v.back());
-      }
-  }
-  ///\e
-  
-  ///\relates XmlIo
-  ///
-  template<class T>
-  void xml(XmlIo &x,std::vector<T> &v)
-  {
-    if(x.write())
-      for(typename std::vector<T>::const_iterator it=v.begin();
-	  it!=v.end();++it) x("item",*it);
-    else while(x.nextTag()=="item")
-      {
-	v.push_back(T());
-	x("item",v.back());      
-      }
-  }
-
-  ///\e
-  
-  ///\relates XmlIo
-  ///
-  template<class K,class V>
-  void xml(XmlIo &x,std::map<K,V> &v)
-  {
-    if(x.write()) 
-      for(typename std::map<K,V>::const_iterator it=v.begin();
-	  it!=v.end();++it) x("item",*it);
-    else while(x.nextTag()=="item")
-      {
-	typename std::map<K,V>::value_type it;
-	x("item",it);
-	v.insert(it);
-      }
-  }
-
-  ///\e
-  
-  ///\relates XmlIo
-  ///
-  template<class T>
-  void xml(XmlIo &x,lemon::dim2::Point<T> &v)
-  {
-    { XmlIo::LineTag t(x,"x"); x(v.x); }
-    { XmlIo::ContTag t(x,"y"); x(v.y); }
-  }
-
-  ///\e
-  
-  ///\relates XmlIo
-  ///
-  template<class T>
-  void xml(XmlIo &x,lemon::dim2::BoundingBox<T> &v)
-  {
-    if(x.write()) {
-      if(!v.empty()) {
-	x("point",v.bottomLeft());
-	if(v.bottomLeft()!=v.topRight()) x("point",v.topRight());
-      }
-    }
-    else {
-      v.clear();
-      while(x.nextTag()=="point") {
-	lemon::dim2::Point<T> co;
-	x("point",co);
-	v.add(co);
-      }
-    }
-  }
-  
-}
-
Index: map.h
===================================================================
--- xymap.h	(revision 174)
+++ 	(revision )
@@ -1,50 +1,0 @@
-/* -*- 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 XYMAP_H
-#define XYMAP_H
-
-#include <lemon/list_graph.h>
-#include <lemon/dim2.h>
-
-template<class M>
-class XYMap
-{
-  private:
-    M *xmap, *ymap;
-
-  public:
-    typedef typename M::Key Key;
-    typedef lemon::dim2::Point<typename M::Value> Value;
-    XYMap() {}
-    XYMap(M &_xmap, M &_ymap) : xmap(&_xmap), ymap(&_ymap) {}
-    void setXMap(M &_xmap) { xmap = &_xmap; }
-    void setYMap(M &_ymap) { ymap = &_ymap; }
-    Value operator[](Key k) const
-    {
-      Value v(xmap->operator[](k), ymap->operator[](k));
-      return v;
-    }
-    void set(Key k, Value v)
-    {
-      xmap->set(k, v.x);
-      ymap->set(k, v.y);
-    }
-};
-
-#endif
