public override void OnDoubleClick(DiagramPointEventArgs e) { base.OnDoubleClick(e); var btPage = ModelElement as CloudcoreUser; SubProcessFiles.OpenView(Store, btPage.VisioId, btPage.SubProcess.VisioId); }
public override void OnDoubleClick(DiagramPointEventArgs e) { base.OnDoubleClick(e); var btRule = ModelElement as WorkflowRule; var file = FileTypes.getFileType(FileType.SqlWorkflowRuleActivity); SubProcessFiles.OpenSql(Store, btRule.VisioId, btRule.SubProcess.VisioId, file); }
public override void OnDoubleClick(DiagramPointEventArgs e) { base.OnDoubleClick(e); var corticon = ModelElement as Corticon; var file = FileTypes.getFileType(FileType.CloudCorticonActivity); SubProcessFiles.OpenClass(Store, corticon.VisioId, corticon.SubProcess.VisioId, file); }
public override void OnDoubleClick(DiagramPointEventArgs e) { base.OnDoubleClick(e); var btEvent = ModelElement as DatabaseEvent; var file = FileTypes.getFileType(FileType.SqlCustomActivity); SubProcessFiles.OpenSql(Store, btEvent.VisioId, btEvent.SubProcess.VisioId, file); }
public override void OnDoubleClick(DiagramPointEventArgs e) { base.OnDoubleClick(e); var btBatchCustomStart = ModelElement as CloudBatchStart; var file = FileTypes.getFileType(FileType.CloudBatchStartActivity); SubProcessFiles.OpenClass(Store, btBatchCustomStart.VisioId, btBatchCustomStart.SubProcess.VisioId, file); }
public override void OnDoubleClick(DiagramPointEventArgs e) { base.OnDoubleClick(e); var btEvent = ModelElement as Email; var file = FileTypes.getFileType(FileType.CloudPostageActivity); SubProcessFiles.OpenClass(Store, btEvent.VisioId, btEvent.SubProcess.VisioId, file); }
public override void OnDoubleClick(DiagramPointEventArgs e) { base.OnDoubleClick(e); var btParkCustom = ModelElement as CloudPark; var file = FileTypes.getFileType(FileType.CloudParkedActivity); SubProcessFiles.OpenClass(Store, btParkCustom.VisioId, btParkCustom.SubProcess.VisioId, file); }
/// <summary> /// If the role object is part of a sticky external constraint shape /// object then activate it on a double click. Equivalent to the /// 'ActiveRoleSequence' diagram command. /// </summary> protected override void OnDoubleClick(DiagramPointEventArgs e) { // Note this looks like a strange place to put this, but this // is the mouse action that is active when a role is clicked on. if (myAllowDoubleClick) { ORMDiagram ormDiagram = Diagram as ORMDiagram; IStickyObject sticky; ExternalConstraintShape constraintShape; if (null != (sticky = ormDiagram.StickyObject) && null != (constraintShape = sticky as ExternalConstraintShape)) { foreach (Role role in e.DiagramHitTestInfo.HitDiagramItem.RepresentedElements) { if (sticky.StickySelectable(role)) { IConstraint constraint = constraintShape.AssociatedConstraint; Role constraintRole = role; switch (constraint.ConstraintType) { case ConstraintType.ExternalUniqueness: case ConstraintType.Frequency: Role oppositeRole; ObjectType oppositeRolePlayer; if (null != (oppositeRole = role.OppositeRole as Role) && null != (oppositeRolePlayer = oppositeRole.RolePlayer) && oppositeRolePlayer.IsImplicitBooleanValue) { constraintRole = oppositeRole; } break; } foreach (ConstraintRoleSequence sequence in constraintRole.ConstraintRoleSequenceCollection) { if (constraint == sequence.Constraint) { ExternalConstraintConnectAction connectAction = ormDiagram.ExternalConstraintConnectAction; connectAction.ConstraintRoleSequenceToEdit = sequence; connectAction.ChainMouseAction(constraintShape, e.DiagramClientView); e.Handled = true; return; } } } break; } } } base.OnDoubleClick(e); }
public override void OnClick(DiagramPointEventArgs e) { if (e!= null && e.HitDiagramItem != null && e.HitDiagramItem.Field != null && e.HitDiagramItem.Field is VDTitleImageField) { VDTitleImageField field = e.HitDiagramItem.Field as VDTitleImageField; VDWidgetShape parentShape = this.ParentShape as VDWidgetShape; if (parentShape != null) { parentShape.OnClickAdditionalTitleIcon(field.Index); } } base.OnClick(e); }
public override void OnDoubleClick(DiagramPointEventArgs e) { base.OnDoubleClick(e); IModelBus modelBus = this.Store.GetService(typeof(SModelBus)) as IModelBus; ModelBusReference reference = ((FromProcessConnector)this.ModelElement).FromProcessConnectorRef; ModelBusAdapter adapter = modelBus.CreateAdapter(reference); ModelBusView view = adapter.GetDefaultView(); if (view != null) { view.Open(); view.SetSelection(reference); view.Show(); } adapter.Dispose(); }
public override void OnClick(DiagramPointEventArgs e) { base.OnClick(e); foreach(var shape in this.Diagram.NestedChildShapes) { if (shape is VDWidgetShape) { VDWidgetShape ws = shape as VDWidgetShape; if (ws.DoHitTest(e.MousePosition, e.DiagramHitTestInfo)) { ws.ZOrder += this.ZOrder; ws.Invalidate(true); //this.Diagram.Invalidate(true); break; } } } }
/// <summary> /// Translate mouse events into OnSubFieldMouseEnter/OnSubFieldMouseLeave events /// </summary> /// <param name="e">DiagramPointEventArgs</param> public override void OnMouseEnter(DiagramPointEventArgs e) { base.OnMouseEnter(e); if (HasSubFieldMouseEnterLeaveHover) { DiagramItem item = e.DiagramHitTestInfo.HitDiagramItem; ShapeSubField subField = item.SubField; ShapeField shapeField = item.Field; // Note that we ignore any existing cached fields here. They // should be null at this point, but ignoring them guards against // the possibility that a leave event did not fire. if (subField == null || shapeField == null) { ActiveShapeSubField = PendingShapeSubField.Token; ActiveShapeField = null; } else { ActiveShapeSubField = subField; ActiveShapeField = shapeField; OnSubFieldMouseEnter(shapeField, subField, e); } } }
public override void OnFieldDoubleClick(ShapeField field, DiagramPointEventArgs e) { string property_Name = this.ModelElement.GetProperties()["Name"].GetValue(this.ModelElement.GetProperties()["Name"]).ToString(); string property_Condition = this.ModelElement.GetProperties()["Condition"].GetValue(this.ModelElement.GetProperties()["Condition"]).ToString(); string property_Constraint = this.ModelElement.GetProperties()["Constraint"].GetValue(this.ModelElement.GetProperties()["Constraint"]).ToString(); string property_Requirements = this.ModelElement.GetProperties()["Requirements"].GetValue(this.ModelElement.GetProperties()["Requirements"]).ToString(); RootFeatureProperties rootFeatureProperties = new RootFeatureProperties(); rootFeatureProperties.NameTextBox.Text = property_Name; rootFeatureProperties.ConditionTextBox.Text = property_Condition; rootFeatureProperties.ConstraintTextBox.Text = property_Constraint; rootFeatureProperties.RequirementsTextBox.Text = property_Requirements; if (rootFeatureProperties.DialogResult == DialogResult.OK) { this.ModelElement.GetProperties()["Name"].SetValue(this.ModelElement.GetProperties()["Name"], rootFeatureProperties.NameTextBox.Text); this.ModelElement.GetProperties()["Condition"].SetValue(this.ModelElement.GetProperties()["Condition"], rootFeatureProperties.ConditionTextBox.Text); this.ModelElement.GetProperties()["Constraint"].SetValue(this.ModelElement.GetProperties()["Constraint"], rootFeatureProperties.ConstraintTextBox.Text); this.ModelElement.GetProperties()["Requirements"].SetValue(this.ModelElement.GetProperties()["Requirements"], rootFeatureProperties.RequirementsTextBox.Text); } }
/// <summary> /// OnDragLeave ensure that the _clipboardObject is cleared. /// </summary> /// <param name="e"></param> public override void OnDragLeave(DiagramPointEventArgs e) { _clipboardObjects = null; base.OnDragLeave(e); }
public override void OnClick(DiagramPointEventArgs e) { if (this.ParentShape == null || this.ParentShape.ParentShape == null) return; VDTabShape tabShape = this.ParentShape.ParentShape as VDTabShape; if (tabShape == null) return; VDTab tab = tabShape.ModelElement as VDTab; if (tab == null) return; VDTabHead curHead = this.ModelElement as VDTabHead; if (curHead == null) return; if (tab.ActiveHead != curHead) { using(Transaction t = this.Store.TransactionManager.BeginTransaction("Set active tab")) { tab.ActiveHead = curHead; tabShape.relayoutChildren = true; // only show active tab's body shape, hide other body shapes t.Commit(); } } }
/// <summary> /// Fired when the mouse enters a subfield. This is called directly /// by OnMouseEnter. /// /// If HasSubFieldHighlighting is set, the default implementation automatically /// sets the HighlightedShapes of the active view to the DiagramItem representing /// this subfield. The subfield item will be invalidated and repainted. It is /// up to shapefield to check the HighlightedShapes collection and draw the subfield /// highlighting explicitly. /// /// Note that introducing a new ShapeSubField-derived base class would allow this /// to be called as the default implementation of an OnMouseEnter event on that class. /// However, this would need to be done at the framework level because ShapeSubField /// is already inherited from. Another alternative is to introduce an interface for /// the Enter/Leave/Hover events along with a stock implementation to help implement it. /// </summary> /// <param name="field">The parent ShapeField</param> /// <param name="subField">The subfield being entered</param> /// <param name="e">Forwarded from the OnMouseEnter event</param> public virtual void OnSubFieldMouseEnter(ShapeField field, ShapeSubField subField, DiagramPointEventArgs e) { if (this.HasSubFieldHighlighting) { DiagramClientView view = e.DiagramClientView; if (view != null) { view.HighlightedShapes.Set(new DiagramItem(this, field, subField)); } } }
/// <summary> /// Disallows expanding and collapsing of the compartment. /// </summary> public override void OnDoubleClick(DiagramPointEventArgs e) { }
/// <summary> /// Translate mouse events into OnSubFieldMouseEnter/OnSubFieldMouseLeave events /// </summary> /// <param name="e">DiagramPointEventArgs</param> public override void OnMouseEnter(DiagramPointEventArgs e) { base.OnMouseEnter(e); if (HasSubFieldMouseEnterLeaveHover) { DiagramItem item = e.DiagramHitTestInfo.HitDiagramItem; ShapeSubField subField = item.SubField; ShapeField shapeField = item.Field; // Note that we ignore any existing cached fields here. They // should be null at this point, but ignoring them guards against // the possibility that a leave event did not fire. if (subField == null || shapeField == null) { ActiveShapeSubField = PendingShapeSubField.Token; ActiveShapeField = null; } else { ActiveShapeSubField = subField; ActiveShapeField = shapeField; OnSubFieldMouseEnter(shapeField, subField, e); } } }
/// <summary> /// Fired when the mouse leaves a subfield. This is called directly /// by OnMouseLeave. /// /// If HasSubFieldHighlighting is set, the default implementation automatically /// removes the DiagramItem representing this subfield from the HighlightedShapes /// of the active view. The subfield item will be invalidated and repainted. It is /// up to shapefield to check the HighlightedShapes collection and draw the subfield /// highlighting explicitly. /// /// Note that introducing a new ShapeSubField-derived base class would allow this /// to be called as the default implementation of an OnMouseLeave event on that class. /// However, this would need to be done at the framework level because ShapeSubField /// is already inherited from. Another alternative is to introduce an interface for /// the Enter/Leave/Hover events along with a stock implementation to help implement it. /// </summary> /// <param name="field">The parent ShapeField</param> /// <param name="subField">The subfield being left</param> /// <param name="e">Forwarded from the OnMouseLeave event</param> public virtual void OnSubFieldMouseLeave(ShapeField field, ShapeSubField subField, DiagramPointEventArgs e) { if (this.HasSubFieldHighlighting) { e.DiagramClientView.HighlightedShapes.Remove(new DiagramItem(this, field, subField)); } }
/// <summary> /// Attempt to activate an activatable error. /// </summary> /// <param name="e">DiagramPointEventArgs. Indicates the element to activate.</param> /// <returns>true if an error was activated</returns> public static bool AttemptErrorActivation(DiagramPointEventArgs e) { bool retVal = false; if (!e.Handled) { DiagramClientView clientView = e.DiagramClientView; MouseAction action = clientView.ActiveMouseAction; if ((action == null || !(action is ConnectAction || action is ToolboxAction)) && clientView.Selection.Count == 1) { DiagramItem diagramItem = e.DiagramHitTestInfo.HitDiagramItem; IModelErrorActivation activator = diagramItem.Shape as IModelErrorActivation; if (activator != null) { IModelErrorOwner errorOwner = null; foreach (ModelElement mel in diagramItem.RepresentedElements) { errorOwner = EditorUtility.ResolveContextInstance(mel, false) as IModelErrorOwner; break; } if (errorOwner != null) { ModelErrorDisplayFilter displayFilter = null; ORMDiagram diagram; ORMModel model; if (null != (diagram = diagramItem.Diagram as ORMDiagram) && null != (model = diagram.ModelElement as ORMModel)) { displayFilter = model.ModelErrorDisplayFilter; } foreach (ModelError error in errorOwner.GetErrorCollection(ModelErrorUses.DisplayPrimary)) { if (displayFilter == null || displayFilter.ShouldDisplay(error)) { if (activator.ActivateModelError(error)) { // UNDONE: MSBUG Report Microsoft bug DiagramClientView.OnDoubleClick is checking // for an active mouse action after the double click and clearing it if it is set. // This may be appropriate if the mouse action was set before the subfield double // click and did not change during the callback, but is definitely not appropriate // if the double click activated the mouse action. // Note that this bug makes it impossible to override OnDoubleClick and OnSubFieldDoubleClick // because e.Handled cannot be reliably checked, so there is no way to call base.OnDoubleClick // of base.OnSubFieldDoubleClick from a more derived class without attempting error activation // twice. If this is fixed, then any OnDoubleClick/OnSubFieldDoubleClick implementation // that simply defers to this method then calls the base can be eliminated in favor // of the same methods here. //e.Handled = true; retVal = true; break; } else { if (!retVal) { IORMToolTaskItem task; IORMToolServices services; IORMToolTaskProvider provider; if (null != (task = error.TaskData as IORMToolTaskItem) && null != (services = error.Store as IORMToolServices) && null != (provider = services.TaskProvider)) { if (provider.NavigateTo(task)) { retVal = true; break; } } } } } } } } } } return retVal; }
/// <summary> /// Attempt to activate an activatable error. /// </summary> /// <param name="e">DiagramPointEventArgs. Indicates the element to activate.</param> /// <returns>true if an error was activated</returns> public static bool AttemptErrorActivation(DiagramPointEventArgs e) { bool retVal = false; if (!e.Handled) { DiagramClientView clientView = e.DiagramClientView; MouseAction action = clientView.ActiveMouseAction; if ((action == null || !(action is ConnectAction || action is ToolboxAction)) && clientView.Selection.Count == 1) { DiagramItem diagramItem = e.DiagramHitTestInfo.HitDiagramItem; IModelErrorActivation activator = diagramItem.Shape as IModelErrorActivation; if (activator != null) { IModelErrorOwner errorOwner = null; foreach (ModelElement mel in diagramItem.RepresentedElements) { errorOwner = EditorUtility.ResolveContextInstance(mel, false) as IModelErrorOwner; break; } if (errorOwner != null) { ModelErrorDisplayFilter displayFilter = null; ORMDiagram diagram; ORMModel model; if (null != (diagram = diagramItem.Diagram as ORMDiagram) && null != (model = diagram.ModelElement as ORMModel)) { displayFilter = model.ModelErrorDisplayFilter; } MouseAction startingMouseAction = clientView.ActiveMouseAction; foreach (ModelError error in errorOwner.GetErrorCollection(ModelErrorUses.DisplayPrimary)) { if (ModelError.IsDisplayed(error, displayFilter)) { if (activator.ActivateModelError(error)) { // UNDONE: MSBUG Report Microsoft bug DiagramClientView.OnDoubleClick is checking // for an active mouse action after the double click and clearing it if it is set. // This may be appropriate if the mouse action was set before the subfield double // click and did not change during the callback, but is definitely not appropriate // if the double click activated the mouse action. // Note that this bug makes it impossible to override OnDoubleClick and OnSubFieldDoubleClick // because e.Handled cannot be reliably checked, so there is no way to call base.OnDoubleClick // of base.OnSubFieldDoubleClick from a more derived class without attempting error activation // twice. If this is fixed, then any OnDoubleClick/OnSubFieldDoubleClick implementation // that simply defers to this method then calls the base can be eliminated in favor // of the same methods here. if (clientView.ActiveMouseAction == startingMouseAction) { e.Handled = true; } retVal = true; break; } else { if (!retVal) { IORMToolTaskItem task; IORMToolServices services; IORMToolTaskProvider provider; if (null != (task = error.TaskData as IORMToolTaskItem) && null != (services = error.Store as IORMToolServices) && null != (provider = services.TaskProvider)) { if (provider.NavigateTo(task)) { retVal = true; break; } } } } } } } } } } return(retVal); }
/// <summary> /// Disallows expanding and collapsing of the compartment. /// </summary> public override void OnDoubleClick(DiagramPointEventArgs e) { }
/// <summary> /// Handle right-clicks on the diagram /// </summary> /// <param name="mouseArgs"></param> protected override void OnContextMenuRequested(DiagramPointEventArgs mouseArgs) { // Command status is set when the selection is changed if (CommandManager.HasEnabledCommands) { base.OnContextMenuRequested(mouseArgs); } else { mouseArgs.Handled = true; } }
/// <summary> /// Fired when the mouse leaves a subfield. This is called directly /// by OnMouseLeave. /// /// If HasSubFieldHighlighting is set, the default implementation automatically /// removes the DiagramItem representing this subfield from the HighlightedShapes /// of the active view. The subfield item will be invalidated and repainted. It is /// up to shapefield to check the HighlightedShapes collection and draw the subfield /// highlighting explicitly. /// /// Note that introducing a new ShapeSubField-derived base class would allow this /// to be called as the default implementation of an OnMouseLeave event on that class. /// However, this would need to be done at the framework level because ShapeSubField /// is already inherited from. Another alternative is to introduce an interface for /// the Enter/Leave/Hover events along with a stock implementation to help implement it. /// </summary> /// <param name="field">The parent ShapeField</param> /// <param name="subField">The subfield being left</param> /// <param name="e">Forwarded from the OnMouseLeave event</param> public virtual void OnSubFieldMouseLeave(ShapeField field, ShapeSubField subField, DiagramPointEventArgs e) { if (this.HasSubFieldHighlighting) { e.DiagramClientView.HighlightedShapes.Remove(new DiagramItem(this, field, subField)); } }
/// <summary> /// Translate mouse event into OnSubFieldMouseHover events /// </summary> /// <param name="e">DiagramPointEventArgs</param> public override void OnMouseHover(DiagramPointEventArgs e) { base.OnMouseHover(e); if (HasSubFieldMouseEnterLeaveHover) { ShapeSubField subField = ActiveShapeSubField; if (subField != null && !PendingShapeSubField.Token.SubFieldEquals(subField)) { Debug.Assert(ActiveShapeField != null); // Should be able to set sub field without shape field OnSubFieldMouseHover(ActiveShapeField, subField, e); } } }
/// <summary> /// Translate mouse events into OnSubFieldMouseEnter/OnSubFieldMouseLeave events /// </summary> /// <param name="e">DiagramPointEventArgs</param> public override void OnMouseLeave(DiagramPointEventArgs e) { base.OnMouseLeave(e); if (HasSubFieldMouseEnterLeaveHover) { ShapeSubField subField = ActiveShapeSubField; ActiveShapeSubField = null; if (subField != null && !PendingShapeSubField.Token.SubFieldEquals(subField)) { ShapeField shapeField = ActiveShapeField; ActiveShapeField = null; OnSubFieldMouseLeave(shapeField, subField, e); } } }
public override void OnDoubleClick(DiagramPointEventArgs e) { var association = ModelElement; if (association != null) { var diagram = Diagram as EntityDesignerDiagram; if (diagram != null) { var ec = diagram.GetModel().EditingContext; var xref = ModelToDesignerModelXRef.GetModelToDesignerModelXRef(ec); var modelAssociation = xref.GetExisting(association) as Model.Entity.Association; Debug.Assert(modelAssociation != null, "couldn't find model association for connector"); if (modelAssociation != null) { var commands = ReferentialConstraintDialog.LaunchReferentialConstraintDialog(modelAssociation); var cpc = new CommandProcessorContext( ec, EfiTransactionOriginator.EntityDesignerOriginatorId, Resources.Tx_ReferentialContraint); var cp = new CommandProcessor(cpc); foreach (var c in commands) { cp.EnqueueCommand(c); } cp.Invoke(); } } } }
/// <summary> /// Fired when the mouse enters a subfield. This is called directly /// by OnMouseEnter. /// /// If HasSubFieldHighlighting is set, the default implementation automatically /// sets the HighlightedShapes of the active view to the DiagramItem representing /// this subfield. The subfield item will be invalidated and repainted. It is /// up to shapefield to check the HighlightedShapes collection and draw the subfield /// highlighting explicitly. /// /// Note that introducing a new ShapeSubField-derived base class would allow this /// to be called as the default implementation of an OnMouseEnter event on that class. /// However, this would need to be done at the framework level because ShapeSubField /// is already inherited from. Another alternative is to introduce an interface for /// the Enter/Leave/Hover events along with a stock implementation to help implement it. /// </summary> /// <param name="field">The parent ShapeField</param> /// <param name="subField">The subfield being entered</param> /// <param name="e">Forwarded from the OnMouseEnter event</param> public virtual void OnSubFieldMouseEnter(ShapeField field, ShapeSubField subField, DiagramPointEventArgs e) { if (this.HasSubFieldHighlighting) { DiagramClientView view = e.DiagramClientView; if (view != null) { view.HighlightedShapes.Set(new DiagramItem(this, field, subField)); } } }
/// <summary> /// Double-click => rotate by 90 degrees. /// /// http://msdn.microsoft.com/library/bb126591.aspx /// </summary> /// <param name="e"></param> public override void OnDoubleClick(DiagramPointEventArgs e) { base.OnDoubleClick(e); this.Rotate90(); e.Handled = true; // Don't pass to parent. }
/// <summary> /// Fired when the mouse hovers over a subfield. This is called directly /// by OnMouseHover. /// /// The default implementation is empty. /// /// Note that introducing a new ShapeSubField-derived base class would allow this /// to be called as the default implementation of an OnMouseHover event on that class. /// However, this would need to be done at the framework level because ShapeSubField /// is already inherited from. Another alternative is to introduce an interface for /// the Enter/Leave/Hover events along with a stock implementation to help implement it. /// </summary> /// <param name="field">The parent ShapeField</param> /// <param name="subField">The subfield being hovered over</param> /// <param name="e">Forwarded from the OnMouseHover event</param> public virtual void OnSubFieldMouseHover(ShapeField field, ShapeSubField subField, DiagramPointEventArgs e) { }
/// <summary> /// Highlight both the name shape and the corresponding role box. /// </summary> public override void OnMouseEnter(DiagramPointEventArgs e) { DiagramClientView clientView; FactTypeShape parentShape; Role role; if (null != (clientView = e.DiagramClientView) && null != (parentShape = ParentShape as FactTypeShape) && null != (role = this.ModelElement as Role)) { DiagramItemCollection items = new DiagramItemCollection(); items.Add(new DiagramItem(this)); items.Add(parentShape.GetDiagramItem(role)); clientView.HighlightedShapes.Set(items); } else { base.OnMouseEnter(e); } }
/// <summary> /// Fired when the mouse hovers over a subfield. This is called directly /// by OnMouseHover. /// /// The default implementation is empty. /// /// Note that introducing a new ShapeSubField-derived base class would allow this /// to be called as the default implementation of an OnMouseHover event on that class. /// However, this would need to be done at the framework level because ShapeSubField /// is already inherited from. Another alternative is to introduce an interface for /// the Enter/Leave/Hover events along with a stock implementation to help implement it. /// </summary> /// <param name="field">The parent ShapeField</param> /// <param name="subField">The subfield being hovered over</param> /// <param name="e">Forwarded from the OnMouseHover event</param> public virtual void OnSubFieldMouseHover(ShapeField field, ShapeSubField subField, DiagramPointEventArgs e) { }
/// <summary> /// Highlight both the name shape and the corresponding role box. /// </summary> public override void OnMouseLeave(DiagramPointEventArgs e) { DiagramClientView clientView; FactTypeShape parentShape; Role role; if (null != (clientView = e.DiagramClientView) && null != (parentShape = ParentShape as FactTypeShape) && null != (role = this.ModelElement as Role)) { clientView.HighlightedShapes.Remove(new DiagramItem[]{new DiagramItem(this), parentShape.GetDiagramItem(role)}); } else { base.OnMouseLeave(e); } }
/// <summary> /// When the user will double-click on the text field, this will show a message box /// and then will set the value of the field to something (here "Changed!") /// Instead of the Message Box the customer will need to provide his own dialogbox /// </summary> /// <param name="e"></param> public override void OnDoubleClick(DiagramPointEventArgs e) { base.OnDoubleClick(e); MessageBox.Show("Double click in the texual decorator"); this.SetValue(e.HitDiagramItem.Shape, "Changed!"); }
/// <summary> /// Attempt model error activation /// </summary> public override void OnDoubleClick(DiagramPointEventArgs e) { ORMBaseShape.AttemptErrorActivation(e); base.OnDoubleClick(e); }
/// <summary> /// A mouse click event has occurred on this ExternalConstraintShape /// </summary> /// <param name="e">DiagramPointEventArgs</param> public override void OnDoubleClick(DiagramPointEventArgs e) { if (!ORMBaseShape.AttemptErrorActivation(e)) { ActivateNewRoleSequenceAction(e.DiagramClientView); } base.OnDoubleClick(e); }