#include "xcddraw.h"
#include <Xm/LabelG.h>
#include <Xm/SelectioB.h>
#include <Xm/ToggleBG.h>
#include <Xm/DialogS.h>
#include <Xm/ArrowBG.h>

void deleteIt(Widget w, int *d,XmAnyCallbackStruct *cbs)
{
  *d = 1;
  dialog_done = 1;
}

void cancelDeleteIt(Widget w, int *d,XmAnyCallbackStruct *cbs)
{
  *d = 0;
  dialog_done = 1;
}

void create_prompt(char *m,int *doit)
{
   Widget dialog;
   int n;
   XmString t = XmStringCreateSimple(m);

   n = 0;
   XtSetArg(wargs[n], XmNautoUnmanage, False); n++;
   XtSetArg(wargs[n], XmNdialogStyle, XmDIALOG_APPLICATION_MODAL); n++;
   dialog = XmCreateMessageDialog(draw_area, "Confirm", wargs, n);

   XtVaSetValues(dialog, XmNmessageString, t, NULL);
   XmStringFree(t);

   XtAddCallback(dialog, XmNokCallback,
              (XtCallbackProc)deleteIt,(XtPointer)doit);
   XtAddCallback(dialog, XmNcancelCallback,
              (XtCallbackProc)cancelDeleteIt,(XtPointer)doit);

   XtManageChild(dialog);
   XtPopup(XtParent(dialog), XtGrabExclusive);

   dialog_done = 0;
   while ( dialog_done == 0 || XtAppPending(app))
        XtAppProcessEvent(app, XtIMAll);
   XtDestroyWidget(dialog);
}


void GraphicsObject::deleteObject(int &done)
{

}


void GraphicsObject::deleteAssignments(GraphicsObject*)
{

}

void EdgeObject::deleteObject(int &done)
{
   if (this->get_selected_flag() == SELECT_EDGE_INNER_POINT)
   {
     int doit = 0;

     create_prompt("Delete the point?",&doit);

     if (doit)
     {
       selected_object->drawSelected(selected_object->get_selected_flag());
       selected_object->set_selected_flag(NOT_SELECTED);
       points->deleteInnerPoint();
       selected_object = NULL;
     }
     return;
   }

   if ((this->get_selected_flag() == SELECT_EDGE) ||
       (this->get_selected_flag() == SELECT_EDGE_END_POINT) || 
       (this->get_selected_flag() == SELECT_EDGE_START_POINT) || 
       (this->get_selected_flag() == SELECT_EDGE_LABEL))

   {
     switch (this->get_kind())
     {
	 case ALT_EDGE:
         {
             int doit = 0;

             create_prompt("Delete the alternation edge?",&doit);

             if (doit)
             {
               done = 1;
               selected_object->drawSelected(selected_object->get_selected_flag());
               this->get_to_vertex()->
                        get_incoming_altedge_store()->deleteElm((GraphicsObject*)this);
	       this->get_from_vertex()->
                     get_outgoing_altedge_store()->deleteElm((GraphicsObject*)this);
                     altedge_store->deleteElm((GraphicsObject*)this);
	     }
             break;
	   }
	  case REQ_C_EDGE:
	  case OPT_C_EDGE:
	     {
             int doit = 0;

             create_prompt("Delete the construction edge?",&doit);

             if (doit)
             {
               done = 1;
               selected_object->drawSelected(selected_object->get_selected_flag());
               this->get_to_vertex()->
                    get_incoming_consedge_store()->deleteElm((GraphicsObject*)this);
	       this->get_from_vertex()->
                    get_outgoing_consedge_store()->deleteElm((GraphicsObject*)this);
               this->get_from_vertex()->get_subhome()->
                     get_outgoing_consedge_store()->deleteElm((GraphicsObject*)this);
               consedge_store->deleteElm((GraphicsObject*)this);
	     }
             break;
	   }
	  case REQ_R_EDGE:
	  case OPT_R_EDGE:
	    {
             int doit = 0;

             create_prompt("Delete the repetition edge?",&doit);

             if (doit)
             {
               done = 1;
               selected_object->drawSelected(selected_object->get_selected_flag());
               this->get_to_vertex()->
                        get_incoming_repedge_store()->deleteElm((GraphicsObject*)this);
	       this->get_from_vertex()->
                     get_outgoing_repedge_store()->deleteElm((GraphicsObject*)this);
               repedge_store->deleteElm((GraphicsObject*)this);
	     }
             break;
	   }
	  case INH_EDGE:
	     {
             int doit = 0;

             create_prompt("Delete the inheritance edge?",&doit);

             if (doit)
             {
               done = 1;
               selected_object->drawSelected(selected_object->get_selected_flag());
               this->get_to_vertex()->
                        get_incoming_inhedge_store()->deleteElm((GraphicsObject*)this);
	       this->get_from_vertex()->
                     get_outgoing_inhedge_store()->deleteElm((GraphicsObject*)this);
               inhedge_store->deleteElm((GraphicsObject*)this);
	     }
             break;
	   }
	  case PAR_EDGE:
	     {
               if (this->get_from_vertex()->vertexInUse())
	       {
                 sprintf(message,
                   "Delete: You cannot the template which is being used.\n");
                 xm_print_message(message);
                 XBell(XtDisplay(draw_area),0);
                 return;
	       }
               if (!this->get_from_vertex()->get_incoming_parinstedge_store()->empty())
	       {
                 sprintf(message,
                   "Delete: PLease delete incoming template instantiation edges first.\n");
                 xm_print_message(message);
                 XBell(XtDisplay(draw_area),0);
                 return;
	       }
             int doit = 0;

             create_prompt("Delete the parameter edge?",&doit);

             if (doit)
             {
               done = 1;
               selected_object->drawSelected(selected_object->get_selected_flag());
               this->get_to_vertex()->
                  get_incoming_paredge_store()->deleteElm((GraphicsObject*)this);
	       this->get_from_vertex()->
                  get_outgoing_paredge_store()->deleteElm((GraphicsObject*)this);

               /* delete elements from assignement stores */
               this->get_from_vertex()->deleteAssignments((GraphicsObject*)this);

               paredge_store->deleteElm((GraphicsObject*)this);
	     }
               break;
	     }
	  case PAR_INST_EDGE:
	     {
               if (this->get_from_vertex()->vertexInUse() ||
                   !this->get_from_vertex()->get_incoming_parinstedge_store()->empty())
	       {
                 sprintf(message,
                   "Delete: You cannot the template instance which is being used.\n");
                 xm_print_message(message);
                 XBell(XtDisplay(draw_area),0);
                 return;
	       }
             int doit = 0;

             create_prompt("Delete the template instance edge?",&doit);

             if (doit)
             {
               done = 1;
               selected_object->drawSelected(selected_object->get_selected_flag());
               this->get_to_vertex()->
                  get_incoming_parinstedge_store()->deleteElm((GraphicsObject*)this);
	       this->get_from_vertex()->
                  get_outgoing_parinstedge_store()->deleteElm((GraphicsObject*)this);
               this->get_from_vertex()->set_template_name(NULL);
               delete this->get_from_vertex()->get_parassignstore()->get_assignments();
               this->get_from_vertex()->get_parassignstore()->set_assignments(NULL);
               parinstedge_store->deleteElm((GraphicsObject*)this);

               this->get_from_vertex()->get_home()
                       ->deleteGO(this->get_from_vertex());
               
               vertex_store->append(this->get_from_vertex());


	     }
             break;
	     }
	  default:
              sprintf(message,
                "Delete: Unknow edge kind.\n");
              xm_print_message(message);
              XBell(XtDisplay(draw_area),0);
              return;
     }
   }
}


void VertexObject::deleteAssignments(GraphicsObject* obj)
{
  this->get_parassignstore()->deleteAssignments(obj);
  this->get_incoming_parinstedge_store()->deleteAssignments(obj);
}

void ParameterAssignmentStore::deleteAssignments(GraphicsObject* obj)
{
   if (assignments)
   {
      if (((GraphicsObject*)assignments->get_elm()->get_formaledge()) == obj)
      {
         ParameterAssignmentList *t = assignments;
         assignments = assignments->get_next();
         if (assignments)
	 {
           assignments->get_prev()->set_next(NULL);
           assignments->set_prev(NULL);
	 }
         delete t;
      }
      else
        assignments->deleteAssignments(obj);
   }
}


void ParameterAssignmentList::deleteAssignments(GraphicsObject* obj)
{
   if (next)
   {
      if (((GraphicsObject*)next->get_elm()->get_formaledge()) == obj)
      {
         ParameterAssignmentList *t = next;
         next = next->get_next();
         if (next)
	 {
           next->get_prev()->set_next(NULL);
           next->set_prev(this);
	 }
         delete t;
      }
      else
        next->deleteAssignments(obj);
   }
}

void ObjectStore::deleteAssignments(GraphicsObject* obj)
{
   if (objects)
      objects->deleteAssignments(obj);
}

void ParameterInstEdge::deleteAssignments(GraphicsObject* obj)
{
    this->get_from_vertex()->deleteAssignments(obj);
}

void GraphicsObjectList::deleteAssignments(GraphicsObject* obj)
{
    elm->deleteAssignments(obj);
    if (next)
       next->deleteAssignments(obj);
}

void VertexStore::deleteElm(int &done, VertexObject* obj)
{
    int unbound = 0;

    if (!obj->get_is_template() && obj->get_template_name() == NULL)
      unbound = 1;

    if (unbound)
    {
       int doit = 0;

       create_prompt("Delete the unbound template instance?",&doit);

       if (doit)
       {
          done = 1;
          ubvstore->remove_from_unbound(obj);
	}
        return;
    }

    switch (obj->get_kind())
    {
      case CONS_VERTEX:
      {
         if (!obj->get_incoming_consedge_store()->empty() ||
             !obj->get_incoming_repedge_store()->empty()  ||
             !obj->get_incoming_altedge_store()->empty()  ||
             !obj->get_incoming_inhedge_store()->empty()  ||
             !obj->get_incoming_paredge_store()->empty()  ||
             !obj->get_incoming_parinstedge_store()->empty())
	 {
              sprintf(message,
                 "Delete: Please delete or reroute incoming edges first.\n");
              xm_print_message(message);
              XBell(XtDisplay(draw_area),0);
              return;
	 }

         if (!obj->get_outgoing_consedge_store()->empty() ||
             !obj->get_outgoing_repedge_store()->empty()  ||
             !obj->get_outgoing_altedge_store()->empty()  ||
             !obj->get_outgoing_inhedge_store()->empty()  ||
             !obj->get_outgoing_paredge_store()->empty()  ||
             !obj->get_outgoing_parinstedge_store()->empty())
	 {
              sprintf(message,
                 "Delete: Please delete or reroute outgoing edges first.\n");
              xm_print_message(message);
              XBell(XtDisplay(draw_area),0);
              return;
	 }

         if (obj->get_primary_flag() == PRIMARY_OF)
	 {
              sprintf(message,
                 "Delete: Please make one of its secondary vertices primary first.\n");
              xm_print_message(message);
              XBell(XtDisplay(draw_area),0);
              return;
	 }
         int doit = 0;
   
         create_prompt("Delete the construction vertex?",&doit);

         if (doit)
         {
              done = 1;
              consvstore->get_tempstore()->remove(obj);
	 }
         break;
       }
       case ALT_VERTEX:
       {
         if (!obj->get_incoming_consedge_store()->empty() ||
             !obj->get_incoming_repedge_store()->empty()  ||
             !obj->get_incoming_altedge_store()->empty()  ||
             !obj->get_incoming_inhedge_store()->empty()  ||
             !obj->get_incoming_paredge_store()->empty()  ||
             !obj->get_incoming_parinstedge_store()->empty())
	 {
              sprintf(message,
                 "Delete: Please delete or reroute incoming edges first.\n");
              xm_print_message(message);
              XBell(XtDisplay(draw_area),0);
              return;
	 }
         if (!obj->get_outgoing_consedge_store()->empty() ||
             !obj->get_outgoing_repedge_store()->empty()  ||
             !obj->get_outgoing_altedge_store()->empty()  ||
             !obj->get_outgoing_inhedge_store()->empty()  ||
             !obj->get_outgoing_paredge_store()->empty()  ||
             !obj->get_outgoing_parinstedge_store()->empty())
	 {
              sprintf(message,
                 "Delete: Please delete or reroute outgoing edges first.\n");
              xm_print_message(message);
              XBell(XtDisplay(draw_area),0);
              return;
	 }

         if (obj->get_primary_flag() == PRIMARY_OF)
	 {
              sprintf(message,
                 "Delete: Please make one of its secondary vertices primary first.\n");
              xm_print_message(message);
              XBell(XtDisplay(draw_area),0);
              return;
	 }

         int doit = 0;
   
         create_prompt("Delete the alternation vertex?",&doit);

         if (doit)
         {
              done = 1;
              altvstore->get_tempstore()->remove(obj);
	 }
         break;
       }
       case REP_VERTEX:
       {
         if (!obj->get_incoming_consedge_store()->empty() ||
             !obj->get_incoming_repedge_store()->empty()  ||
             !obj->get_incoming_altedge_store()->empty()  ||
             !obj->get_incoming_inhedge_store()->empty()  ||
             !obj->get_incoming_paredge_store()->empty()  ||
             !obj->get_incoming_parinstedge_store()->empty())
	 {
              sprintf(message,
                 "Delete: Please delete or reroute incoming edges first.\n");
              xm_print_message(message);
              XBell(XtDisplay(draw_area),0);
              return;
	 }
         if (!obj->get_outgoing_consedge_store()->empty() ||
             !obj->get_outgoing_repedge_store()->empty()  ||
             !obj->get_outgoing_altedge_store()->empty()  ||
             !obj->get_outgoing_inhedge_store()->empty()  ||
             !obj->get_outgoing_paredge_store()->empty()  ||
             !obj->get_outgoing_parinstedge_store()->empty())
	 {
              sprintf(message,
                 "Delete: Please delete or reroute outgoing edges first.\n");
              xm_print_message(message);
              XBell(XtDisplay(draw_area),0);
              return;
	 }

         if (obj->get_primary_flag() == PRIMARY_OF)
	 {
              sprintf(message,
                 "Delete: Please make one of its secondary vertices primary first.\n");
              xm_print_message(message);
              XBell(XtDisplay(draw_area),0);
              return;
	 }
         int doit = 0;
   
         create_prompt("Delete the repetition vertex?",&doit);

         if (doit)
         {
              done = 1;
              repvstore->get_tempstore()->remove(obj);
	 }
         break;
       }
       case TERM_VERTEX:
         {
           if ( !obj->get_incoming_consedge_store()->empty() ||
                !obj->get_incoming_repedge_store()->empty())
	   {
              sprintf(message,
                 "Delete: Please delete incoming edges first.\n");
              xm_print_message(message);
              XBell(XtDisplay(draw_area),0);
              return;
	   }
           int doit = 0;
   
           create_prompt("Delete the terminal vertex?",&doit);

           if (doit)
           {
              done = 1;
              termvstore->get_vstore()->remove_from_unbound(obj);
	   }
           break;
         }
       case EXT_VERTEX:
       {
         if (!obj->get_incoming_consedge_store()->empty() ||
             !obj->get_incoming_repedge_store()->empty()  ||
             !obj->get_incoming_altedge_store()->empty()  ||
             !obj->get_incoming_inhedge_store()->empty()  ||
             !obj->get_incoming_paredge_store()->empty()  ||
             !obj->get_incoming_parinstedge_store()->empty())
	 {
              sprintf(message,
                 "Delete: Please delete or reroute incoming edges first.\n");
              xm_print_message(message);
              XBell(XtDisplay(draw_area),0);
              return;
	 }
         if (!obj->get_outgoing_consedge_store()->empty() ||
             !obj->get_outgoing_repedge_store()->empty()  ||
             !obj->get_outgoing_altedge_store()->empty()  ||
             !obj->get_outgoing_inhedge_store()->empty()  ||
             !obj->get_outgoing_paredge_store()->empty()  ||
             !obj->get_outgoing_parinstedge_store()->empty())
	 {
              sprintf(message,
                 "Delete: Please delete or reroute outgoing edges first.\n");
              xm_print_message(message);
              XBell(XtDisplay(draw_area),0);
              return;
	 }

         if (obj->get_primary_flag() == PRIMARY_OF)
	 {
              sprintf(message,
                 "Delete: Please make one of its secondary vertices primary first.\n");
              xm_print_message(message);
              XBell(XtDisplay(draw_area),0);
              return;
	 }

         int doit = 0;
   
         create_prompt("Delete the external vertex?",&doit);

         if (doit)
         {
              done = 1;
              extvstore->get_tempstore()->remove(obj);
	 }
         break;
       }
       case PARAM_VERTEX:
        {
          if ( !obj->get_incoming_consedge_store()->empty() ||
               !obj->get_incoming_repedge_store()->empty() ||
               !obj->get_incoming_paredge_store()->empty())

	  {
             sprintf(message,
               "Delete: Please delete incoming edges first.\n");
             xm_print_message(message);
             XBell(XtDisplay(draw_area),0);
             return;
	  }
           int doit = 0;
   
           create_prompt("Delete the parameter vertex?",&doit);

           if (doit)
           {
              done = 1;
              paravstore->get_vstore()->remove_from_unbound(obj);
	   }
         break;
	}
       default:
         break;
     }

}

void VertexObject::deleteObject(int &done)
{
   if (this->get_selected_flag() == SELECT_VERTEX_NAME)
   {
      sprintf(message,
              "Delete: You cannot delete vertex names.\n");
      xm_print_message(message);
      XBell(XtDisplay(draw_area),0);
      return;
   }
    if (this->get_selected_flag() == SELECT_VERTEX)
      vertex_store->deleteElm(done,this);
}

void PointObjectList::deleteInnerPoint()
{
   if (this->get_next()->get_elm()->get_selected_flag() == SELECT_EDGE_INNER_POINT)
   {
      PointObjectList *t = this->get_next();
      this->get_next()->get_next()->set_prev(this);
      this->set_next(this->get_next()->get_next());
      t->set_next(NULL);
      t->set_prev(NULL);
      delete t;
   }
   else
   if (next)
     next->deleteInnerPoint();
}

void ObjectStore::deleteElm(GraphicsObject* obj)
{
   if (objects)
   {
      if (objects->get_elm() ==  obj)
      {
         objects = objects->get_next();
         if (objects)
	 {
            objects->get_prev()->set_next(NULL);
            objects->set_prev(NULL);
	 }
      }
      else
         objects->deleteElm(obj);
   }
}


void GraphicsObjectList::deleteElm(GraphicsObject* obj)
{
   if (next)
   {
      if (next->get_elm() ==  obj)
      {
         next = next->get_next();
         if (next)
	 {
            next->get_prev()->set_next(NULL);
            next->set_prev(this);
	  }
      }
      else
      if (next)
         next->deleteElm(obj);
   }
}