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-edge.cc
author athos
Thu, 30 Jun 2005 16:13:30 +0000
changeset 1526 8c14aa8f27a2
parent 1512 e54392395480
child 1579 ed7da82bbecf
permissions -rwxr-xr-x
Mainly doc review. 
     1 #include <graph_displayer_canvas.h>

     2 #include <broken_edge.h>

     3 #include <math.h>

     4 

     5 

     6 int GraphDisplayerCanvas::changeEdgeWidth (std::string mapname, Graph::Edge edge)

     7 {

     8   Graph::EdgeMap<double> * actual_map;

     9   if(mapname=="Default")

    10     {

    11       actual_map=new Graph::EdgeMap<double>(g,edge_property_defaults[E_WIDTH]);

    12     }

    13   else

    14     {

    15       actual_map=(mapstorage.edgemap_storage)[mapname];

    16     }

    17 

    18   if(edge==INVALID)

    19     {

    20       for (EdgeIt i(g); i!=INVALID; ++i)

    21 	{

    22 	  int w=(int)(*actual_map)[i];

    23 	  if(w>=0)

    24 	    {

    25 	      edgesmap[i]->property_width_pixels().set_value(w);

    26 	    }

    27 	}

    28     }

    29   else

    30     {

    31       int w=(int)(*actual_map)[edge];

    32       if(w>=0)

    33 	{

    34 	  edgesmap[edge]->property_width_pixels().set_value(w);

    35 	}

    36     }

    37   return 0;

    38 };

    39 

    40 int GraphDisplayerCanvas::changeEdgeColor (std::string mapname, Graph::Edge edge)

    41 {  

    42 

    43   //function maps the range of the maximum and

    44   //the minimum of the nodemap to the range of

    45   //green in RGB

    46   Graph::EdgeMap<double> * actual_map;

    47   if(mapname=="Default")

    48     {

    49       actual_map=new Graph::EdgeMap<double>(g,edge_property_defaults[E_COLOR]);

    50     }

    51   else

    52     {

    53       actual_map=(mapstorage.edgemap_storage)[mapname];

    54     }

    55 

    56   double max, min;

    57 

    58   if(mapname!="Default")

    59     {

    60       max=mapstorage.maxOfEdgeMap(mapname);

    61       min=mapstorage.minOfEdgeMap(mapname);

    62     }

    63   else

    64     {

    65       max=edge_property_defaults[E_COLOR];

    66       min=edge_property_defaults[E_COLOR];

    67     }

    68 

    69   if(edge==INVALID)

    70     {

    71       for (EdgeIt i(g); i!=INVALID; ++i)

    72 	{

    73 	  double w=(*actual_map)[i];

    74 

    75 	  Gdk::Color color;

    76 	  if(max!=min)

    77 	    {

    78 	      color.set_rgb_p (0, 100*(w-min)/(max-min), 0);

    79 	    }

    80 	  else

    81 	    {

    82 	      color.set_rgb_p (0, 100, 0);

    83 	    }

    84 	  edgesmap[i]->property_fill_color_gdk().set_value(color);

    85 	}

    86     }

    87   else

    88     {

    89       Gdk::Color color;

    90 

    91       double w=(*actual_map)[edge];

    92 

    93       if(max!=min)

    94 	{

    95 	  color.set_rgb_p (0, 100*(w-min)/(max-min), 0);

    96 	}

    97       else

    98 	{

    99 	  color.set_rgb_p (0, 100, 0);

   100 	}

   101 

   102       edgesmap[edge]->property_fill_color_gdk().set_value(color);

   103     }

   104   return 0;

   105 };

   106 

   107 int GraphDisplayerCanvas::changeEdgeText (std::string mapname, Graph::Edge edge)

   108 {

   109 

   110   //the number in the map will be written on the edge

   111   //EXCEPT when the name of the map is Text, because

   112   //in that case empty string will be written, because

   113   //that is the deleter map

   114 

   115   if(edge==INVALID)

   116     {

   117       for (EdgeIt i(g); i!=INVALID; ++i)

   118 	{

   119 	  if(mapname!="Default")

   120 	    {

   121 	      double number=(*(mapstorage.edgemap_storage)[mapname])[i];

   122 	      int length=1;

   123 	      //if number is smaller than one, length would be negative, or invalid

   124 	      if(number>=1)

   125 		{

   126 		  length=(int)(floor(log(number)/log(10)))+1;

   127 		}

   128 	      int maxpos=(int)(pow(10,length-1));

   129 	      int strl=length+1+RANGE;

   130 	      char * str=new char[strl];

   131 	      str[length]='.';

   132 	      str[strl]='\0';

   133       

   134 	      for(int j=0;j<strl;j++)

   135 		{

   136 		  if(j!=length)

   137 		    {

   138 		      int digit=(int)(number/maxpos);

   139 		      str[j]=(digit+'0');

   140 		      number-=digit*maxpos;

   141 		      number*=10;

   142 		    }

   143 		}

   144       

   145 	      edgetextmap[i]->property_text().set_value(str);

   146 	    }

   147 	  else

   148 	    {

   149 	      edgetextmap[i]->property_text().set_value("");

   150 	    }

   151 	}

   152 

   153     }

   154   else

   155     {

   156       if(mapname!="Default")

   157 	{

   158 	  double number=(*(mapstorage.edgemap_storage)[mapname])[edge];

   159 	  int length=1;

   160 	  //if number is smaller than one, length would be negative, or invalid

   161 	  if(number>=1)

   162 	    {

   163 	      length=(int)(floor(log(number)/log(10)))+1;

   164 	    }

   165 	  int maxpos=(int)(pow(10,length-1));

   166 	  int strl=length+1+RANGE;

   167 	  char * str=new char[strl];

   168 	  str[length]='.';

   169 	  str[strl]='\0';

   170       

   171 	  for(int j=0;j<strl;j++)

   172 	    {

   173 	      if(j!=length)

   174 		{

   175 		  int digit=(int)(number/maxpos);

   176 		  str[j]=(digit+'0');

   177 		  number-=digit*maxpos;

   178 		  number*=10;

   179 		}

   180 	    }

   181       

   182 	  edgetextmap[edge]->property_text().set_value(str);

   183 	}

   184       else

   185 	{

   186 	  edgetextmap[edge]->property_text().set_value("");

   187 	}

   188 	  

   189     }

   190 

   191   return 0;

   192 

   193 };
lemon-0.x