Example #1
0
        public void ServiceGraphicChanged(Int64 eventId, Int64 requestId, Actioned actioned)
        {
            if (actioned.Created != null)
            {
                foreach (Guid guid in actioned.Created)
                {
                    Item item = serviceGraphic.Get(guid);

                    if (item is GraphicItem)
                    {
                        graphic.Create(item as GraphicItem);
                    }

                    if (item is ModelItem)
                    {
                        model.Create(item as ModelItem);
                    }
                }

                if (actioned.Modified != null)
                {
                    foreach (Guid guid in actioned.Modified)
                    {
                        Item item = serviceGraphic.Get(guid);

                        if (item is GraphicItem)
                        {
                            graphic.Modify(item as GraphicItem);
                        }

                        if (item is ModelItem)
                        {
                            model.Modify(item as ModelItem);
                        }
                    }
                }

                if (actioned.Deleted != null)
                {
                    foreach (Guid guid in actioned.Deleted)
                    {
                        if (graphic.Get(guid) != null)
                        {
                            graphic.Delete(guid);
                        }

                        if (model.Get(guid) != null)
                        {
                            model.Delete(guid);
                        }
                    }
                }

                OnChanged(eventId, requestId, actioned);
            }
        }
Example #2
0
 public void OnChanged(Int64 eventId, Int64 requestId, Actioned actioned)
 {
   if (Changed != null)
   {
     foreach (ChangedHandler changedHandler in Changed.GetInvocationList())
     {
       try { changedHandler(eventId, requestId, actioned); }
       catch (SocketException) { Changed -= changedHandler; }
     }
   }
 }
Example #3
0
 public void OnChanged(Int64 eventId, Int64 requestId, Actioned actioned)
 {
     if (Changed != null)
     {
         foreach (ChangedHandler changedHandler in Changed.GetInvocationList())
         {
             try { changedHandler(eventId, requestId, actioned); }
             catch (SocketException) { Changed -= changedHandler; }
         }
     }
 }
Example #4
0
    public void ServiceGraphicChanged(Int64 eventId, Int64 requestId, Actioned actioned)
      {
      if (actioned.Created != null)
        {
        foreach (Guid guid in actioned.Created)
          {
          Item item = serviceGraphic.Get(guid);

          if (item is GraphicItem)
            graphic.Create(item as GraphicItem);

          if (item is ModelItem)
            model.Create(item as ModelItem);
          }

        if (actioned.Modified != null)
          {
          foreach (Guid guid in actioned.Modified)
            {
            Item item = serviceGraphic.Get(guid);

            if (item is GraphicItem)
              graphic.Modify(item as GraphicItem);

          if (item is ModelItem)
            model.Modify(item as ModelItem);
            }
          }

        if (actioned.Deleted != null)
          {
          foreach (Guid guid in actioned.Deleted)
            {
            if (graphic.Get(guid) != null)
              graphic.Delete(guid);

            if (model.Get(guid) != null)
              model.Delete(guid);
            }
          }

        OnChanged(eventId, requestId, actioned);
        }
      }
 public void DoChanged(Int64 eventId, Int64 requestId, Actioned actioned)
 {
     OnChanged(eventId, requestId, actioned);
 }
Example #6
0
    public bool Change(out Int64 requestId, SysCAD.Protocol.Action action)
      {
      this.requestId++;
      requestId = this.requestId;

      Collection<ModelItem> modelCreate = new Collection<ModelItem>();
      Collection<ModelItem> modelModify = new Collection<ModelItem>();
      Collection<Guid> modelDelete = new Collection<Guid>();

      Collection<GraphicItem> graphicCreate = new Collection<GraphicItem>();
      Collection<GraphicItem> graphicModify = new Collection<GraphicItem>();
      Collection<Guid> graphicDelete = new Collection<Guid>();

        { // Check if OK to go ahead.
        if (action.Create != null)
          {
          foreach (Item item in action.Create)
            {
            if (Exists(item))
              {
              LogMessage(out requestId, "Create: Item " + item.Guid + ", " + item.Tag + " already exists.", MessageType.Error);
              return false; // Can't create an item if guid already exists.
              }
            else
              {
              if (item is ModelItem)
                modelCreate.Add(item as ModelItem);
              else if (item is GraphicItem)
                {
                if (item is GraphicLink)
                  {
                  GraphicLink graphicLink = item as GraphicLink;
                  if (graphicLink.ControlPoints.Count > 2) // Check for duplicate points.
                    {
                    List<SysCAD.Protocol.Point> newControlPoints = new List<SysCAD.Protocol.Point>();
                    SysCAD.Protocol.Point pointA = graphicLink.ControlPoints[0];
                    SysCAD.Protocol.Point pointB = graphicLink.ControlPoints[1];
                    SysCAD.Protocol.Point pointC = graphicLink.ControlPoints[2];

                    int i = 3;
                    while (i < graphicLink.ControlPoints.Count)
                      {
                      if (((pointA.X == pointB.X) && (pointB.X == pointC.X) && (pointC.X == pointA.X))
                        || ((pointA.Y == pointB.Y) && (pointB.Y == pointC.Y) && (pointC.Y == pointA.Y)))
                        {
                        pointB = pointC;
                        pointC = graphicLink.ControlPoints[i];
                        i++;
                        }
                      if (i < graphicLink.ControlPoints.Count)
                      {
                      newControlPoints.Add(pointA);
                      pointA = pointB;
                      pointB = pointC;
                      pointC = graphicLink.ControlPoints[i];
                      i++;
                      }
                      }
                    newControlPoints.Add(pointA);
                    newControlPoints.Add(pointB);
                    newControlPoints.Add(pointC);
                    //if (newControlPoints.Count % 2 == 0)
                    //  newControlPoints.Add(pointC);
                    graphicLink.ControlPoints = newControlPoints;
                    }
                  }
                
                graphicCreate.Add(item as GraphicItem);
                }
              }
            }
          }

        if (action.Modify != null)
          {
          foreach (Item item in action.Modify)
            {
            if (!Exists(item))
              {
              LogMessage(out requestId, "Modify: Item " + item.Guid + ", " + item.Tag + " doesn't exist.", MessageType.Error);
              return false; // Can't modify an item if guid doesn't exist.
              }
            else
              {
              if (item is ModelItem)
                modelModify.Add(item as ModelItem);
              else if (item is GraphicItem)
                graphicModify.Add(item as GraphicItem);
              }
            }
          }

        if (action.Delete != null)
          {
          foreach (Guid guid in action.Delete)
            {
            if (!Exists(guid))
              {
              LogMessage(out requestId, "Delete: Item " + guid + " doesn't exist.", MessageType.Error);
              return false; // Can't modify an item if guid doesn't exist.
              }
            else
              {
              if (ModelExists(guid))
                {
                modelDelete.Add(guid);
                }
              else if (GraphicExists(guid))
                {
                graphicDelete.Add(guid);
                }
              }
            }
          }
        }

        //!!!if (engineClientServiceProtocol.Change(eventId, requestId, modelCreate, modelModify, modelDelete))
        //!!!{

        Actioned actioned = new Actioned();

        foreach (ModelItem modelItem in modelCreate)
          {
          model.Create(modelItem);
          actioned.Created.Add(modelItem.Guid);
          }

        foreach (ModelItem modelItem in modelModify)
          {
          model.Modify(modelItem);
          actioned.Modified.Add(modelItem.Guid);
          }

        foreach (Guid guid in modelDelete)
          {
          model.Delete(guid);
          actioned.Deleted.Add(guid);
          }

        foreach (GraphicItem graphicItem in graphicCreate)
          {
          graphic.Create(graphicItem);
          actioned.Created.Add(graphicItem.Guid);
          }

        foreach (GraphicItem graphicItem in graphicModify)
          {
          graphic.Modify(graphicItem);
          actioned.Modified.Add(graphicItem.Guid);
          }

        foreach (Guid guid in graphicDelete)
          {
          graphic.Delete(guid);
          actioned.Deleted.Add(guid);
          }

          { // Do Change here.
          eventId++;
          clientClientServiceProtocol.DoChanged(eventId, requestId, actioned);
          }

          return true;
      //!!!}
      //!!!else
      //!!!{
      //!!!  return false;
      //!!!}
      }
 public void DoChanged(Int64 eventId, Int64 requestId, Actioned actioned)
 {
   OnChanged(eventId, requestId, actioned);
 }
Example #8
0
 private void fcFlowChart_Changed(Int64 eventId, Int64 requestId, Actioned actioned)
 {
   DoCreated(actioned.Created);
   DoModified(actioned.Modified);
   DoDeleted(actioned.Deleted);
 }