// This example was started by Guillaume Laurent.

// It has become a place to dump code that tests parts of the

// gnomemm canvas code. Little thought has been given to the

// actual on-screen output.

#include <libgnomecanvasmm.h>

#include <libgnomecanvasmm/polygon.h>

#include <fstream>

#include <iostream>

#include <lemon/list_graph.h>

#include <lemon/graph_reader.h>

#include <lemon/graph_utils.h>

#include <lemon/maps.h>

#include <lemon/error.h>

#include <lemon/xy.h>

using namespace lemon;

typedef xy<double> Coordinates;

typedef ListGraph Graph;

typedef Graph::NodeMap<Coordinates> CoordinatesMap;

typedef Graph::Node Node;

typedef Graph::EdgeIt EdgeIt;

typedef Graph::NodeIt NodeIt;

class GraphDisplayerCanvas : public Gnome::Canvas::CanvasAA

{

  typedef Gnome::Canvas::CanvasAA Parent;

public:

  GraphDisplayerCanvas(Graph &, CoordinatesMap &);

  virtual ~GraphDisplayerCanvas();

private:

  ///Event handler function that handles dragging nodes of displayed_graph

  bool event_handler(GdkEvent* e, int b);

  ///Event handler function that handles dragging displayed_graph

  bool tri_mover(GdkEvent* e);

  ///Coordinates of Weight Point of tirangle

  Gnome::Art::Point * wp;

  ///Array of nodes of planefigure

  Gnome::Canvas::Ellipse ** nodes;

  ///Sides of planefigure

  Gnome::Canvas::Polygon * sides;

  ///Group of graphical elements of displayed_graph

  Gnome::Canvas::Group displayed_graph;

  ///Indicates whether the button of mouse is pressed or not

  bool isbutton;

  ///Number Of Elements - the number of nodes

  int noe;

  ///Array of coordinates

  double * coordinates;

  ///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, because

  ///1. we cannot query the item at he cursor as fast as it could not cause a Segmentation Fault

  ///2. we would like to handle only ony item per movement, therefore quering it is not a working solution

  Gnome::Canvas::Item * active_item;

};

///When we click on the weight point we can drag the whole planefigure. This function resolves it.

bool GraphDisplayerCanvas::tri_mover(GdkEvent* e)

{

  switch(e->type)

  {

    case GDK_BUTTON_PRESS:

      clicked_x=e->button.x;

      clicked_y=e->button.y;

      isbutton=true;

      break;

    case GDK_BUTTON_RELEASE:

      isbutton=false;

      active_item=NULL;

      break;

    case GDK_MOTION_NOTIFY:

      if(isbutton)

      {

        double dx=e->motion.x-clicked_x;

        double dy=e->motion.y-clicked_y;

        Gnome::Canvas::Points coos;

        for(int i=0;i<=noe;i++)

        {

          nodes[i]->move(dx,dy);

          double x=(coordinates[2*i]+=dx);

          double y=(coordinates[2*i+1]+=dy);

          if(i!=noe)coos.push_back(Gnome::Art::Point(x,y));

        }

        clicked_x=e->motion.x;

        clicked_y=e->motion.y;

        sides->property_points().set_value(coos);

      }

    default: break;

  }

  return true;

}

///This function moves only one node of displayed_graph,

///but recalculate the location of weight point,

///and also redraw the sides of the planefigure.

bool GraphDisplayerCanvas::event_handler(GdkEvent* e, int b)

{

  switch(e->type)

  {

    case GDK_BUTTON_PRESS:

      clicked_x=e->button.x;

      clicked_y=e->button.y;

      active_item=(get_item_at(e->button.x, e->button.y));

      isbutton=true;

      break;

    case GDK_BUTTON_RELEASE:

      isbutton=false;

      active_item=NULL;

      break;

    case GDK_MOTION_NOTIFY:

      if(isbutton)

      {

        //double x1, y1, x2, y2;

        //(get_item_at(e->motion.x, e->motion.y))->get_bounds(x1, y1, x2, y2);

        //printf("Item coos: %d %d %d %d\n", (int)x1, (int)y1, (int)x2, (int)y2);

        //printf("Mouse is moved! %d %d\n",(int)e->motion.x,(int)e->motion.y);

        double dx=e->motion.x-clicked_x;

        double dy=e->motion.y-clicked_y;

        active_item->move(dx, dy);

        coordinates[2*b]+=dx;

        coordinates[2*b+1]+=dy;

        Gnome::Canvas::Points coos;

        double x_wp=0;

        double y_wp=0;

        for(int i=0;i<noe;i++)

        {

          coos.push_back(Gnome::Art::Point(coordinates[2*i], coordinates[2*i+1]));

          x_wp+=coordinates[2*i];

          y_wp+=coordinates[2*i+1];

        }

        sides->property_points().set_value(coos);

        x_wp/=noe;

        y_wp/=noe;

        dx=x_wp-coordinates[noe*2];

        dy=y_wp-coordinates[noe*2+1];

        nodes[noe]->move(dx, dy);

        coordinates[noe*2]+=dx;

        coordinates[noe*2+1]+=dy;

        clicked_x=e->motion.x;

        clicked_y=e->motion.y;

      }

    default: break;

  }

  return true;

}

GraphDisplayerCanvas::GraphDisplayerCanvas(Graph & g, CoordinatesMap & cm):displayed_graph(*(root()), 0, 0),isbutton(false),active_item(NULL)

{

    nodes=new Gnome::Canvas::Ellipse* [countNodes(g)];

    int sorszam=0;

    for (NodeIt i(g); i!=INVALID; ++i)

    {

	nodes[sorszam]= new Gnome::Canvas::Ellipse(displayed_graph, cm[i].x-20, cm[i].y-20, cm[i].x+20, cm[i].y+20);

	*(nodes[sorszam]) << Gnome::Canvas::Properties::fill_color("blue");

	*(nodes[sorszam]) << Gnome::Canvas::Properties::outline_color("black");

	(nodes[sorszam])->signal_event().connect(sigc::bind(sigc::mem_fun(*this, &GraphDisplayerCanvas::event_handler),sorszam));

	sorszam++;

    }

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

    {

    }

}

GraphDisplayerCanvas::~GraphDisplayerCanvas()

{

}

//MainWin:

class MainWin : public Gtk::Window

{

public:

  MainWin(const std::string& title, Graph &, CoordinatesMap &);

protected:

  //Member widgets:

  GraphDisplayerCanvas gd_canvas;

};

MainWin::MainWin(const std::string& title, Graph & graph, CoordinatesMap & cm):gd_canvas(graph, cm)

{

  set_title (title);

  add(gd_canvas);

  set_default_size(900,600);

  show_all();

}

///This class is responsible for being able

///to read xy datastructure from file. It is

///based on BaseMap. The set method sets the

///appropriate value in the final xy NodeMap

///that was given to the constructor.

class CoordReaderMap: public MapBase <Node, double>

{

    CoordinatesMap & cm;

    char xoy;

public:

    CoordReaderMap(char xory, CoordinatesMap & coordmap);

    void set(Node node, double coord);

};

///The constructor expects for an xy NodeMap,

///and we have to tell it, for which  value

///of the xy vector is responsible the actual

///copy.

CoordReaderMap::CoordReaderMap(char xory, CoordinatesMap & coordmap): cm(coordmap)

{

    switch(xory)

    {

	case 'x':

	case 'y':

	    xoy=xory;

	    break;

	default:

	    throw UninitializedParameter() ;

    }

}

///set method sets the appropriate value in the

///xy type NodeMap that is under construction

void CoordReaderMap::set(Node node, double coord)

{

    switch(xoy)

    {

	case 'x':

	    cm[node].x=coord;

	    break;

	case 'y':

	    cm[node].y=coord;

	    break;

	default:

	    throw UninitializedParameter() ;

    }

}

//main():

int main(int argc, char *argv[])

{

  if(argc<2)

  {

      std::cerr << "USAGE: gd <input filename.lgf>" << endl;

      return 0;

  }

  Coordinates coosvector;

  Graph g;

  CoordinatesMap cm(g);

  //we create one object to read x coordinates

  //and one to read y coordinate of nodes and write them to cm NodeMap.

  CoordReaderMap xreader('x',cm);

  CoordReaderMap yreader('y',cm);

  std::ifstream is(argv[1]);

  GraphReader<Graph> reader(is, g);

  reader.addNodeMap("coordinates_x", xreader);

  reader.addNodeMap("coordinates_y", yreader);

  reader.run();

  for (NodeIt i(g); i!=INVALID; ++i)

      std::cout << " " << g.id(i) << " " << cm[i];

  std::cout << std::endl;

  Gnome::Canvas::init();

  Gtk::Main app(argc, argv);

  MainWin mainwin("Displayed Graph", g, cm);

  app.run(mainwin);

  return 0;

}