// ------------------------------------------------------------------
/// <summary>
/// Initializes a new instance of the <see cref="T:ConnectorBase"/>
/// class.
/// </summary>
/// <param name="p">Point: The location of the conector.</param>
// ------------------------------------------------------------------
protected ConnectorBase(Point p)
: base()
{
mAttachedConnectors = new CollectionBase <IConnector>();
this.mPoint = p;
this.InitializeConnector();
}
/// <summary>
/// Inits this instance.
/// </summary>
protected override void Initialize()
{
base.Initialize();
mConnectors = new CollectionBase <IConnector>();
mConnectors.OnItemAdded += new EventHandler <CollectionEventArgs <IConnector> >(mConnectors_OnItemAdded);
mRectangle = new Rectangle(0, 0, 100, 70);
}
/// <summary>
/// Perform redo of this command.
/// </summary>
public override void Redo()
{
//create a new group; use the standard GroupShape or the CollapsibleGroupShape for a painted group with collapse/expand features.
//GroupShape group = new GroupShape(this.Controller.Model);
CollapsibleGroupShape group = new CollapsibleGroupShape(this.controller.Model);
//asign the entities to the group
group.Entities.Clear();
foreach (IDiagramEntity entity in bundle.Entities)
{
//this will be recursive if an entity is itself an IGroup
entity.Group = group;
group.Entities.Add(entity);
}
//add the new group to the layer
this.Controller.Model.DefaultPage.DefaultLayer.Entities.Add(group);
mGroup = group;
//select the newly created group
CollectionBase <IDiagramEntity> col = new CollectionBase <IDiagramEntity>();
col.Add(mGroup);
Selection.SelectedItems = col;
mGroup.Invalidate();
}
// ------------------------------------------------------------------
/// <summary>
/// Unwraps the specified collection.
/// </summary>
/// <param name="collection">The collection.</param>
// ------------------------------------------------------------------
public void Unwrap(CollectionBase <IDiagramEntity> collection)
{
if (collection == null)
{
return;
}
foreach (IDiagramEntity entity in collection)
{
Unwrap(entity);
}
//reconnect the connectors, just like the deserialization of a filed diagram
Dictionary <Guid, Anchor> .Enumerator enumer = Anchors.GetEnumerator();
System.Collections.Generic.KeyValuePair <Guid, Anchor> pair;
Anchor anchor;
while (enumer.MoveNext())
{
pair = enumer.Current;
anchor = pair.Value;
if (anchor.Parent != Guid.Empty) //there's a parent connector
{
if (Anchors.ContainsKey(anchor.Parent))
{
Anchors.GetAnchor(anchor.Parent).Instance.AttachConnector(anchor.Instance);
}
}
}
//clean up the anchoring matrix
Anchors.Clear();
}
/// <summary>
/// Depth-first traversal of an <see cref="IGroup"/>
/// </summary>
/// <param name="group"></param>
/// <param name="collection"></param>
public static void TraverseCollect(IGroup group, ref CollectionBase <IDiagramEntity> collection)
{
#region Checks
if (group == null)
{
throw new InconsistencyException("Cannot collect entities of a 'null' IGroup");
}
if (collection == null)
{
throw new InconsistencyException("You need to instantiate a collection before using this method.");
}
#endregion
foreach (IDiagramEntity entity in group.Entities)
{
if (entity is IGroup)
{
TraverseCollect(entity as IGroup, ref collection);
}
else
{
collection.Add(entity);
}
}
}
///<summary>
///Default constructor
///</summary>
public FolderMaterial(string title)
: base()
{
myTextStyle = new TextStyle(
Color.Black,
new Font("Arial", 10),
StringAlignment.Near,
StringAlignment.Near);
mEntries = new CollectionBase <IShapeMaterial>();
mEntries.OnItemAdded +=
new EventHandler <CollectionEventArgs <IShapeMaterial> >(
mEntries_OnItemAdded);
Gliding = false;
Resizable = true;
plusminus = new SwitchIconMaterial(SwitchIconType.PlusMinus);
plusminus.TextStyle = myTextStyle;
plusminus.Transform(new Rectangle(0, 0, 16, 16));
plusminus.Visible = true;
plusminus.Gliding = false;
plusminus.OnExpand += new EventHandler(plusminus_OnExpand);
plusminus.OnCollapse += new EventHandler(plusminus_OnCollapse);
header = new ClickableLabelMaterial();
header.TextStyle = myTextStyle;
header.Transform(new Rectangle(0, 0, 100, HeaderHeight));
header.Text = title;
header.Gliding = false;
header.Visible = true;
header.Resizable = true;
}
/// <summary>
/// Unwraps the given bundle to the diagram.
/// </summary>
/// <param name="collection">CollectionBase<IDiagramEntity></param>
void UnwrapBundle(CollectionBase <IDiagramEntity> collection)
{
if (collection != null)
{
#region Unwrap the bundle
this.Controller.Model.Unwrap(collection);
Rectangle rec = Utils.BoundingRectangle(collection);
// The InsertionPoint specifies where the pasted
// entities should be. So, shift each entity in the
// collection to the InsertionPoint.
Point delta = new Point(
InsertionPoint.X - rec.Location.X,
InsertionPoint.Y - rec.Location.Y);
//delta.Offset(rec.Location);
foreach (IDiagramEntity entity in collection)
{
entity.MoveBy(delta);
}
// Recalculate the bounding rectangle and invalidate
// that area on the canvas.
rec = Utils.BoundingRectangle(collection);
rec.Inflate(30, 30);
this.Controller.View.Invalidate(rec);
#endregion
}
}
/// <summary>
/// Initializes a new instance of the <see cref="T:DeleteCommand"/> class.
/// </summary>
/// <param name="controller">The controller.</param>
/// <param name="bundle">The bundle.</param>
public DeleteCommand(IController controller, CollectionBase <IDiagramEntity> bundle)
: base(controller)
{
this.Text = "Delete";
this.controller = controller;
this.bundle = bundle;
}
/// <summary>
/// Re-sets the scene-index of the paintables
/// </summary>
private void ReAssignSceneIndex(CollectionBase <IDiagramEntity> entities)
{
for (int i = 0; i < entities.Count; i++)
{
entities[i].SceneIndex = i;
}
}
///<summary>
///Default constructor
///</summary>
public GroupShape(IModel model) : base(model)
{
this.mEntities = new CollectionBase <IDiagramEntity>();
this.mEntities.OnItemAdded += new EventHandler <CollectionEventArgs <IDiagramEntity> >(mEntities_OnItemAdded);
this.mEntities.OnClear += new EventHandler(mEntities_OnClear);
this.mEntities.OnItemRemoved += new EventHandler <CollectionEventArgs <IDiagramEntity> >(mEntities_OnItemRemoved);
}
// ------------------------------------------------------------------
/// <summary>
/// Sets the current page.
/// </summary>
/// <param name="page">The page.</param>
// ------------------------------------------------------------------
public void SetCurrentPage(IPage page)
{
mCurrentPage = page;
RaiseOnAmbienceChanged(new AmbienceEventArgs(page.Ambience));
RaiseOnCurrentPageChanged(new PageEventArgs(page));
//change the paintables as well
//Paintables = new CollectionBase<IDiagramEntity>();
#region Reload of the z-order, usually only necessary after deserialization
CollectionBase <IDiagramEntity> collected = new CollectionBase <IDiagramEntity>();
//pick up the non-group entities
foreach (IDiagramEntity entity in Paintables)
{
if (!typeof(IGroup).IsInstanceOfType(entity))
{
collected.Add(entity);
}
}
if (collected.Count > 0)
{
Algorithms.SortInPlace <IDiagramEntity>(collected, new SceneIndexComparer <IDiagramEntity>());
//Paintables.AddRange(collected);
}
#endregion
}
// ------------------------------------------------------------------
/// <summary>
/// Constructs a connector, passing its location
/// </summary>
/// <param name="p">Point: The location of the conector.</param>
/// <param name="model">IModel: The model.</param>
// ------------------------------------------------------------------
protected ConnectorBase(Point p, IModel model)
: base(model)
{
mAttachedConnectors = new CollectionBase <IConnector>();
mPoint = p;
this.InitializeConnector();
}
/// <summary>
/// Perform undo of this command.
/// </summary>
public override void Undo()
{
//create a new group
GroupShape group = new GroupShape(this.Controller.Model);
//asign the entities to the group
group.Entities = bundle.Entities;
foreach (IDiagramEntity entity in group.Entities)
{
//this will be recursive if an entity is itself an IGroup
entity.Group = group;
}
//add the new group to the layer
this.Controller.Model.DefaultPage.DefaultLayer.Entities.Add(group);
mGroup = group;
//select the newly created group
CollectionBase <IDiagramEntity> col = new CollectionBase <IDiagramEntity>();
col.Add(mGroup);
Selection.SelectedItems = col;
mGroup.Invalidate();
}
/// <summary>
/// Perform redo of this command.
/// </summary>
public override void Redo()
{
//remove the group from the layer
this.Controller.Model.DefaultPage.DefaultLayer.Entities.Remove(mGroup);
//detach the entities from the group
foreach (IDiagramEntity entity in mGroup.Entities)
{
//this will be recursive if an entity is itself an IGroup
entity.Group = null;
bundle.Entities.Add(entity);
//mGroup.Entities.Remove(entity);
}
//change the visuals such that the entities in the group are selected
CollectionBase <IDiagramEntity> col = new CollectionBase <IDiagramEntity>();
col.AddRange(mGroup.Entities);
Selection.SelectedItems = col;
mGroup.Invalidate();
mGroup = null;
//note that the entities have never been disconnected from the layer
//so they don't have to be re-attached to the anything.
//The insertion of the Group simply got pushed in the scene-graph.
}
// -------------------------------------------------------------------
/// <summary>
/// Deserialization constructor
/// </summary>
/// <param name="info">The info.</param>
/// <param name="context">The context.</param>
// -------------------------------------------------------------------
protected ShapeBase(
SerializationInfo info,
StreamingContext context)
: base(info, context)
{
if (Tracing.BinaryDeserializationSwitch.Enabled)
{
Trace.WriteLine("Deserializing the fields of 'ShapeBase'.");
}
double version = info.GetDouble("ShapeBaseVersion");
mConnectors = new CollectionBase <IConnector>();
//transform to the new bounding rectangle
Transform(
(Rectangle)info.GetValue("Rectangle", typeof(Rectangle))
);
this.mConnectors = info.GetValue(
"Connectors",
typeof(CollectionBase <IConnector>)) as
CollectionBase <IConnector>;
mShowConnectors = info.GetBoolean("ShowConnectors");
mIsFixed = info.GetBoolean("IsFixed");
}
/// <summary>
/// Adds a collection of entities to the diagram
/// </summary>
/// <param name="collection">The collection.</param>
public void AddEntities(CollectionBase <IDiagramEntity> collection)
{
foreach (IDiagramEntity entity in collection)
{
SetModel(entity);
DefaultPage.DefaultLayer.Entities.Add(entity);
}
}
// ------------------------------------------------------------------
/// <summary>
/// Initializes this instance.
/// </summary>
// ------------------------------------------------------------------
protected override void Initialize()
{
base.Initialize();
mChildren = new CollectionBase <IShapeMaterial>();
mChildren.OnItemAdded +=
new EventHandler <CollectionEventArgs <IShapeMaterial> >
(mChildren_OnItemAdded);
}
/// <summary>
/// Initializes a new instance of the <see cref="T:FillStyleCommand"/> class.
/// </summary>
/// <param name="controller">The controller.</param>
/// <param name="bundle">The bundle.</param>
/// <param name="paintStyle">The paint style.</param>
public FillStyleCommand(IController controller, CollectionBase <IDiagramEntity> bundle, IPaintStyle paintStyle)
: base(controller)
{
this.Text = "Fill style";
this.controller = controller;
this.bundle = bundle;//the bundle should contain only IShape and IConnection entities!
this.newStyle = paintStyle;
}
/// <summary>
/// Inits this instance.
/// </summary>
private void Init()
{
mConnectors = new CollectionBase <IConnector>();
mConnectors.OnItemAdded += new EventHandler <CollectionEventArgs <IConnector> >(mConnectors_OnItemAdded);
mRectangle = new Rectangle(0, 0, 100, 70);
PaintStyle = ArtPallet.GetDefaultPaintStyle();
PenStyle = ArtPallet.GetDefaultPenStyle();
}
/// <summary>
/// Returns a copy of this instance.
/// </summary>
/// <returns></returns>
public CollectionBase <T> Copy()
{
CollectionBase <T> copy = new CollectionBase <T>();
foreach (T item in this.innerList)
{
copy.Add(item);
}
return(copy);
}
/// <summary>
/// Initializes this instance.
/// </summary>
private void Init()
{
mChildren = new CollectionBase <IShapeMaterial>();
mChildren.OnItemAdded += new EventHandler <CollectionEventArgs <IShapeMaterial> >(mChildren_OnItemAdded);
mServices = new Dictionary <Type, IInteraction>();
//mChildren.Clear();
//mServices.Clear();
mServices[typeof(IMouseListener)] = this;
mServices[typeof(IHoverListener)] = this;
}
/// <summary>
/// Default constructor
/// </summary>
public Model()
{
//here I'll have to work on the scene graph
//this.mShapes = new CollectionBase<IShape>();
//the default page
//the page collection
mPages = new CollectionBase <IPage>();
mPages.Add(new Page("Default Page", this));
Init();
}
/// <summary>
/// Adds a collection range to this collection.
/// </summary>
/// <param name="items">The items.</param>
public virtual void AddRange(CollectionBase <T> items)
{
if (mReadOnly)
{
throw new InconsistencyException("The collection is read only");
}
this.innerList.AddRange(items);
foreach (T item in items)
{
RaiseOnItemAdded(item);
}
}
///<summary>
///Default constructor
///</summary>
public Page(string name, IModel model)
{
this.mModel = model;
mName = name;
mAmbience = new Ambience(this);
//the one and only and indestructible layer
mLayers = new CollectionBase <ILayer>();
mLayers.Add(new Layer("Default Layer"));
Init();
}
// ------------------------------------------------------------------
/// <summary>
/// Hooks-up the required events to monitor the collection of entities
/// specified.
/// </summary>
/// <param name="entities">CollectionBase<IDiagramEntity></param>
// ------------------------------------------------------------------
protected virtual void AttachEventsToEnityCollection(
CollectionBase <IDiagramEntity> entities)
{
this.mEntities.OnItemAdded +=
new EventHandler <CollectionEventArgs <IDiagramEntity> >(
OnEntityAdded);
this.mEntities.OnClear += new EventHandler(OnClearEntities);
this.mEntities.OnItemRemoved +=
new EventHandler <CollectionEventArgs <IDiagramEntity> >(
OnEntityRemoved);
}
/// <summary>
/// Sets the items.
/// </summary>
/// <param name="editValue">The edit value.</param>
/// <param name="value">The value.</param>
/// <returns></returns>
protected override object SetItems(object editValue, object[] value)
{
CollectionBase <IShapeMaterial> entries = editValue as CollectionBase <IShapeMaterial>;
entries.Clear();
for (int k = 0; k < value.Length; k++)
{
entries.Add(value[k] as IShapeMaterial);
}
object retValue = base.SetItems(entries, value);
return(retValue);
}
/// <summary>
/// Deserialization constructor
/// </summary>
/// <param name="info">The info.</param>
/// <param name="context">The context.</param>
protected ConnectorBase(SerializationInfo info, StreamingContext context) : base(info, context)
{
if (Tracing.BinaryDeserializationSwitch.Enabled)
{
Trace.WriteLine("Deserializing the fields of 'ConnectorBase'.");
}
this.mPoint = (Point)info.GetValue("Point", typeof(Point));
attachedConnectors = new CollectionBase <IConnector>();
#region Preparation of the anchoring process
Guid tuid = new Guid(info.GetString("AttachedTo"));
Anchors.Add(this.Uid, new Anchor(tuid, this));
#endregion
}
/// <summary>
/// Default constructor
/// </summary>
public Model()
{
//here I'll have to work on the scene graph
//this.mShapes = new CollectionBase<IShape>();
//the default page
//the page collection
mPages = new CollectionBase <IPage>();
mPages.Add(new Page("Default Page", this));
mConnectorHolders = new Dictionary <IConnector, IDiagramEntity>();
Init();
}
/// <summary>
/// Moves the connectors of the children to the central group connector location.
/// </summary>
internal void MoveConnectors(CollectionBase <IDiagramEntity> entities, Point point)
{
IConnection cnn;
foreach (IDiagramEntity entity in entities)
{
if (entity is IGroup)
{
continue; //since we use a flattened collection (the Leafs) we don't care about the groups here
//the inclusion of the subgroups in the Leafs is however important to make the subgroups
//(in)visible when collapsed/expanded.
}
if (entity is IShape)
{
foreach (IConnector cn in (entity as IShape).Connectors)
{
if (cn.AttachedConnectors.Count > 0)
{
foreach (IConnector cn2 in cn.AttachedConnectors)
{
if (cn2.Parent is IConnection)
{
cnn = cn2.Parent as IConnection;
//the ends have to be connected
if (cnn.From.AttachedTo.Parent is IShape && cnn.To.AttachedTo.Parent is IShape)
{
if (entities.Contains(cnn.From.AttachedTo.Parent as IShape) && entities.Contains(cnn.To.AttachedTo.Parent as IShape))
{
continue;//both endconnectors are internal
}
else//one of the connectors is external
{
if (entities.Contains(cnn.From.AttachedTo.Parent as IShape)) //the From is internal
{
MoveConnector(cnn.From, point);
}
else //the To is internal
{
MoveConnector(cnn.To, point);
}
}
}
}
}
}
}
}
}
}
// ------------------------------------------------------------------
/// <summary>
/// Default constructor
/// </summary>
// ------------------------------------------------------------------
public Model()
{
//here I'll have to work on the scene graph
//this.mShapes = new CollectionBase<IShape>();
//the default page
//the page collection
mPages = new CollectionBase <IPage>();
Page p = new Page("Default Page", this);
p.Ambience.PageColor = ArtPalette.DefaultPageColor;
mPages.Add(p);
Init();
}