diff -r b8d778d4d100 -r e8bf8bbcf75a algowin.h
--- a/algowin.h	Sat Jan 14 08:17:00 2006 +0000
+++ b/algowin.h	Sat Jan 14 13:42:37 2006 +0000
@@ -13,35 +13,122 @@
 
 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:
-  sigc::signal<void, AlgoWin *> signal_closed;  
-  sigc::signal<void, AlgoWin *, std::string> signal_maplist_need;  
-  sigc::signal<void, std::string, bool> signal_newmapwin_need;  
+  ///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();
-  sigc::signal<void, std::string, bool> signal_newmapwin_needed(){return signal_newmapwin_need;};  
 
+  ///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);};
 
-  AlgoWin(int, std::vector<std::string>);
+  ///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