Mercuriallemon-0.x / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
gui/graph_displayer_canvas.cc
author deba
Wed, 01 Mar 2006 10:17:25 +0000
changeset 1990 15fb7a4ea6be
parent 1860 27a9a75b957b
permissions -rwxr-xr-x
Some classes assumed that the GraphMaps should be inherited
from an ObserverBase. These classes parents replaced with
DefaultMap which cause that the graph maps should not be
inherited from the ObserverBase. 
     1 #include "graph_displayer_canvas.h"

     2 #include <cmath>

     3 

     4 GraphDisplayerCanvas::GraphDisplayerCanvas(NoteBookTab & mainw) :

     5   nodesmap(mainw.mapstorage.graph), edgesmap(mainw.mapstorage.graph), edgetextmap(mainw.mapstorage.graph),

     6   nodetextmap(mainw.mapstorage.graph), displayed_graph(*(root()), 0, 0),

     7   isbutton(0), active_item(NULL), target_item(NULL), nodemap_to_edit(""),

     8   edgemap_to_edit(""), mytab(mainw)

     9 {

    10   //base event handler is move tool

    11   actual_handler=signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::moveEventHandler), false);

    12   actual_tool=MOVE;

    13 

    14   active_node=INVALID;

    15   active_edge=INVALID;

    16   forming_edge=INVALID;

    17 }

    18 

    19 GraphDisplayerCanvas::~GraphDisplayerCanvas()

    20 {

    21   for (NodeIt n((mytab.mapstorage).graph); n != INVALID; ++n)

    22     {

    23       delete nodesmap[n];

    24       delete nodetextmap[n];

    25     }

    26   

    27   for (EdgeIt e((mytab.mapstorage).graph); e != INVALID; ++e)

    28     {

    29       delete edgesmap[e];

    30       delete edgetextmap[e];

    31     }

    32 }

    33 

    34 void GraphDisplayerCanvas::propertyChange(bool itisedge, int prop)

    35 {

    36   if(itisedge)

    37     {

    38       propertyUpdate(Edge(INVALID), prop);

    39     }

    40   else

    41     {

    42       propertyUpdate(Node(INVALID), prop);

    43     }

    44 }

    45 

    46 void GraphDisplayerCanvas::propertyUpdate(Edge edge)

    47 {

    48   for(int i=0;i<EDGE_PROPERTY_NUM;i++)

    49     {

    50       propertyUpdate(edge, i);

    51     }

    52 }

    53 

    54 void GraphDisplayerCanvas::propertyUpdate(Node node)

    55 {

    56   for(int i=0;i<NODE_PROPERTY_NUM;i++)

    57     {

    58       propertyUpdate(node, i);

    59     }

    60 }

    61 

    62 void GraphDisplayerCanvas::propertyUpdate(Node node, int prop)

    63 {

    64   //dummy=dummy;

    65 

    66   std::string mapname=mytab.getActiveNodeMap(prop);

    67 

    68   if(mapname!="")

    69     {

    70       if( ( ((mytab.mapstorage).nodemap_storage).find(mapname) != ((mytab.mapstorage).nodemap_storage).end() ) )

    71 	{

    72 	  switch(prop)

    73 	    {

    74 	    case N_RADIUS:

    75 	      changeNodeRadius(mapname, node);

    76 	      break;

    77 	    case N_COLOR:

    78 	      changeNodeColor(mapname, node);

    79 	      break;

    80 	    case N_TEXT:

    81 	      changeNodeText(mapname, node);

    82 	      break;

    83 	    default:

    84 	      std::cerr<<"Error\n";

    85 	    }

    86 	}

    87     }

    88   else //mapname==""

    89     {

    90       Node node=INVALID;	

    91       switch(prop)

    92 	{

    93 	case N_RADIUS:

    94 	  resetNodeRadius(node);

    95 	  break;

    96 	case N_COLOR:

    97 	  resetNodeColor(node);

    98 	  break;

    99 	case N_TEXT:

   100 	  resetNodeText(node);

   101 	  break;

   102 	default:

   103 	  std::cerr<<"Error\n";

   104 	}

   105     }

   106 

   107 }

   108 

   109 void GraphDisplayerCanvas::propertyUpdate(Edge edge, int prop)

   110 {

   111   //dummy=dummy;

   112 

   113   std::string mapname=mytab.getActiveEdgeMap(prop);

   114 

   115   if(mapname!="")

   116     {

   117       if( ( ((mytab.mapstorage).edgemap_storage).find(mapname) != ((mytab.mapstorage).edgemap_storage).end() ) )

   118 	{

   119 	  switch(prop)

   120 	    {

   121 	    case E_WIDTH:

   122 	      changeEdgeWidth(mapname, edge);

   123 	      break;

   124 	    case E_COLOR:

   125 	      changeEdgeColor(mapname, edge);

   126 	      break;

   127 	    case E_TEXT:

   128 	      changeEdgeText(mapname, edge);

   129 	      break;

   130 	    default:

   131 	      std::cerr<<"Error\n";

   132 	    }

   133 	}

   134     }

   135   else //mapname==""

   136     {

   137       switch(prop)

   138 	{

   139 	case E_WIDTH:

   140 	  resetEdgeWidth(edge);

   141 	  break;

   142 	case E_COLOR:

   143 	  resetEdgeColor(edge);

   144 	  break;

   145 	case E_TEXT:

   146 	  resetEdgeText(edge);

   147 	  break;

   148 	default:

   149 	  std::cerr<<"Error\n";

   150 	}

   151     }

   152 }

   153 

   154 void GraphDisplayerCanvas::drawGraph()

   155 {

   156   //first edges are drawn, to hide joining with nodes later

   157 

   158   for (EdgeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)

   159   {

   160 

   161     //drawing green lines, coordinates are from mapstorage.coords

   162 

   163     Gnome::Canvas::Points coos;

   164     coos.push_back(Gnome::Art::Point(

   165           (mytab.mapstorage).coords[(mytab.mapstorage).graph.source(i)].x,

   166           (mytab.mapstorage).coords[(mytab.mapstorage).graph.source(i)].y));

   167     coos.push_back(Gnome::Art::Point(

   168           (mytab.mapstorage).coords[(mytab.mapstorage).graph.target(i)].x,

   169           (mytab.mapstorage).coords[(mytab.mapstorage).graph.target(i)].y));

   170     

   171     edgesmap[i]=new BrokenEdge(displayed_graph, i, *this);

   172     *(edgesmap[i]) << Gnome::Canvas::Properties::fill_color("green");

   173     edgesmap[i]->property_width_units().set_value(10);    

   174     edgesmap[i]->lower_to_bottom();

   175     

   176     //initializing edge-text as well, to empty string

   177 

   178     XY text_pos=mytab.mapstorage.arrow_pos[i];

   179     text_pos+=(XY(10,10));

   180 

   181     edgetextmap[i]=new Gnome::Canvas::Text(displayed_graph, text_pos.x, text_pos.y, "");

   182     edgetextmap[i]->property_fill_color().set_value("darkgreen");

   183     edgetextmap[i]->signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::edgeMapEditEventHandler), false);

   184     edgetextmap[i]->raise_to_top();

   185   }

   186 

   187   //afterwards nodes come to be drawn

   188 

   189   for (NodeIt i((mytab.mapstorage).graph); i!=INVALID; ++i)

   190   {

   191     //drawing bule nodes, with black line around them

   192 

   193     nodesmap[i]=new Gnome::Canvas::Ellipse(

   194         displayed_graph,

   195         (mytab.mapstorage).coords[i].x-20,

   196         (mytab.mapstorage).coords[i].y-20,

   197         (mytab.mapstorage).coords[i].x+20,

   198         (mytab.mapstorage).coords[i].y+20);

   199     *(nodesmap[i]) << Gnome::Canvas::Properties::fill_color("blue");

   200     *(nodesmap[i]) << Gnome::Canvas::Properties::outline_color("black");

   201     nodesmap[i]->raise_to_top();

   202 

   203     //initializing edge-text as well, to empty string

   204 

   205     xy<double> text_pos(

   206         ((mytab.mapstorage).coords[i].x+node_property_defaults[N_RADIUS]+5),

   207         ((mytab.mapstorage).coords[i].y+node_property_defaults[N_RADIUS]+5));

   208 

   209     nodetextmap[i]=new Gnome::Canvas::Text(displayed_graph,

   210         text_pos.x, text_pos.y, "");

   211     nodetextmap[i]->property_fill_color().set_value("darkblue");

   212     nodetextmap[i]->signal_event().connect(sigc::mem_fun(*this, &GraphDisplayerCanvas::nodeMapEditEventHandler), false);

   213     nodetextmap[i]->raise_to_top();

   214   }

   215 

   216   updateScrollRegion();

   217 }

   218 

   219 void GraphDisplayerCanvas::clear()

   220 {

   221   active_node=INVALID;

   222   active_edge=INVALID;

   223   forming_edge=INVALID;

   224 

   225   for (NodeIt n((mytab.mapstorage).graph); n != INVALID; ++n)

   226   {

   227     delete nodesmap[n];

   228     delete nodetextmap[n];

   229   }

   230 

   231   for (EdgeIt e((mytab.mapstorage).graph); e != INVALID; ++e)

   232   {

   233     delete edgesmap[e];

   234     delete edgetextmap[e];

   235   }

   236 }
lemon-0.x