private void OnExpandCollapse(object sender, EventArgs e)
{
MenuCommand command = (MenuCommand)sender;
foreach (object obj2 in this.selectionService.GetSelectedComponents())
{
Activity activity = obj2 as Activity;
if (activity != null)
{
CompositeActivityDesigner designer = ActivityDesigner.GetDesigner(activity) as CompositeActivityDesigner;
if (designer != null)
{
designer.Expanded = command.CommandID.ID == WorkflowMenuCommands.Expand.ID;
}
}
}
MenuCommand command2 = this.menuCommandService.FindCommand(WorkflowMenuCommands.Expand);
if (command2 != null)
{
this.OnStatusExpandCollapse(command2, EventArgs.Empty);
}
MenuCommand command3 = this.menuCommandService.FindCommand(WorkflowMenuCommands.Collapse);
if (command3 != null)
{
this.OnStatusExpandCollapse(command3, EventArgs.Empty);
}
}
public override AccessibleObject Navigate(AccessibleNavigation navdir)
{
if (((navdir == AccessibleNavigation.Up) || (navdir == AccessibleNavigation.Previous)) || ((navdir == AccessibleNavigation.Down) || (navdir == AccessibleNavigation.Next)))
{
DesignerNavigationDirection down = DesignerNavigationDirection.Down;
if ((navdir == AccessibleNavigation.Up) || (navdir == AccessibleNavigation.Previous))
{
down = DesignerNavigationDirection.Up;
}
else
{
down = DesignerNavigationDirection.Down;
}
CompositeActivityDesigner parentDesigner = base.ActivityDesigner.ParentDesigner;
if (parentDesigner != null)
{
object nextSelectableObject = parentDesigner.GetNextSelectableObject(base.ActivityDesigner.Activity, down);
if (nextSelectableObject is ConnectorHitTestInfo)
{
return(this.GetChild(((ConnectorHitTestInfo)nextSelectableObject).MapToIndex()));
}
}
}
return(base.Navigate(navdir));
}
private void InitiateDragDrop()
{
WorkflowView parentView = ParentView;
ISelectionService selectionService = (ISelectionService)GetService(typeof(ISelectionService));
IDesignerHost designerHost = (IDesignerHost)GetService(typeof(IDesignerHost));
if (selectionService == null || designerHost == null)
{
return;
}
// check if we are cutting root component
ICollection components = selectionService.GetSelectedComponents();
if (components == null || components.Count < 1 || selectionService.GetComponentSelected(designerHost.RootComponent) || !Helpers.AreAllActivities(components))
{
return;
}
DragDropEffects effects = DragDropEffects.None;
try
{
// get component serialization service
this.existingDraggedActivities.AddRange(Helpers.GetTopLevelActivities(components));
//IMPORTANT: FOR WITHIN DESIGNER COMPONENT MOVE WE REMOVE THE ACTIVITIES BEFORE WE ADD THEM WHICH IS IN
//ONDRAGDROP FUNCTION. ALTHOUGH THIS VIOLATES THE DODRAGDROP FUNCTION SIMANTICS, WE NEED TO DO THIS
//SO THAT WE CAN USE THE SAME IDS FOR THE ACTIVITIES
DragDropEffects allowedEffects = (DesignerHelpers.AreAssociatedDesignersMovable(this.existingDraggedActivities)) ? DragDropEffects.Move | DragDropEffects.Copy : DragDropEffects.Copy;
IDataObject dataObject = CompositeActivityDesigner.SerializeActivitiesToDataObject(ParentView, this.existingDraggedActivities.ToArray());
effects = parentView.DoDragDrop(dataObject, allowedEffects);
//
}
catch (Exception e)
{
DesignerHelpers.ShowError(ParentView, e.Message);
}
finally
{
//This means drag drop occurred across designer
if (effects == DragDropEffects.Move && this.existingDraggedActivities.Count > 0)
{
string transactionDescription = String.Empty;
if (this.existingDraggedActivities.Count > 1)
{
transactionDescription = SR.GetString(SR.MoveMultipleActivities, this.existingDraggedActivities.Count);
}
else
{
transactionDescription = SR.GetString(SR.MoveSingleActivity, this.existingDraggedActivities[0].GetType());
}
CompositeActivityDesigner.RemoveActivities(ParentView, this.existingDraggedActivities.AsReadOnly(), transactionDescription);
}
this.existingDraggedActivities.Clear();
}
}
private void EnsureValidDesignerPreview(ActivityDesigner designer)
{
CompositeActivityDesigner designer2 = designer as CompositeActivityDesigner;
if ((designer2 != null) && designer2.Expanded)
{
ActivityPreviewDesignerTheme designerTheme = this.parentDesigner.DesignerTheme as ActivityPreviewDesignerTheme;
if (designerTheme != null)
{
System.Drawing.Size previewWindowSize = designerTheme.PreviewWindowSize;
System.Drawing.Size size = designer2.Size;
float num = ((float)previewWindowSize.Width) / ((float)size.Width);
if (Math.Min(num, ((float)previewWindowSize.Height) / ((float)size.Height)) < 0.1f)
{
if (!designer2.CanExpandCollapse && (designer2.ContainedDesigners.Count > 0))
{
designer2 = designer2.ContainedDesigners[0] as CompositeActivityDesigner;
}
if (designer2 != null)
{
designer2.Expanded = false;
}
}
}
}
}
protected override bool OnMouseUp(MouseEventArgs eventArgs)
{
if ((Control.ModifierKeys & Keys.Shift) > 0)
{
base.OnMouseUp(eventArgs);
//Select all the shapes
WorkflowView parentView = ParentView;
if (!DragRectangle.IsEmpty && parentView.RootDesigner != null)
{
ActivityDesigner[] intersectingDesigners = CompositeActivityDesigner.GetIntersectingDesigners(parentView.RootDesigner, DragRectangle);
ArrayList selectableComponents = new ArrayList();
foreach (ActivityDesigner activityDesigner in intersectingDesigners)
{
selectableComponents.Add(activityDesigner.Activity);
}
ISelectionService selectionService = GetService(typeof(ISelectionService)) as ISelectionService;
if (selectableComponents.Count > 0 && selectionService != null)
{
selectionService.SetSelectedComponents((object[])selectableComponents.ToArray(typeof(object)), SelectionTypes.Replace);
}
}
return(true);
}
return(false);
}
protected override void OnDragDrop(ActivityDragEventArgs e)
{
base.OnDragDrop(e);
bool ctrlKeyPressed = ((e.KeyState & 8) == 8);
if (ctrlKeyPressed && (e.AllowedEffect & DragDropEffects.Copy) == DragDropEffects.Copy)
{
e.Effect = DragDropEffects.Copy;
}
else if ((e.AllowedEffect & DragDropEffects.Move) == DragDropEffects.Move)
{
e.Effect = DragDropEffects.Move;
}
//If the component is sited then that means that we are moving it
try
{
CompositeActivityDesigner.InsertActivities(this, new ConnectorHitTestInfo(this, HitTestLocations.Designer, CurrentDropTarget), e.Activities, SR.GetString(SR.DragDropActivities));
}
finally
{
CurrentDropTarget = -1;
}
}
internal static Activity GetNextSelectableActivity(Activity currentActivity)
{
object obj2;
ActivityDesigner designer = ActivityDesigner.GetDesigner(currentActivity);
CompositeActivityDesigner designer2 = (designer != null) ? designer.ParentDesigner : null;
if (designer2 == null)
{
return(null);
}
DesignerNavigationDirection direction = ((designer2 is ParallelActivityDesigner) || (designer2 is ActivityPreviewDesigner)) ? DesignerNavigationDirection.Right : DesignerNavigationDirection.Down;
Activity activity = null;
for (obj2 = designer2.GetNextSelectableObject(currentActivity, direction); ((activity == null) && (obj2 != null)) && (obj2 != currentActivity); obj2 = designer2.GetNextSelectableObject(obj2, direction))
{
activity = obj2 as Activity;
}
if (activity == null)
{
direction = ((designer2 is ParallelActivityDesigner) || (designer2 is ActivityPreviewDesigner)) ? DesignerNavigationDirection.Left : DesignerNavigationDirection.Up;
for (obj2 = designer2.GetNextSelectableObject(currentActivity, direction); ((activity == null) && (obj2 != null)) && (obj2 != currentActivity); obj2 = designer2.GetNextSelectableObject(obj2, direction))
{
activity = obj2 as Activity;
}
}
if (activity == null)
{
activity = designer2.Activity;
}
return(activity);
}
protected override bool OnMouseUp(MouseEventArgs eventArgs)
{
if ((Control.ModifierKeys & Keys.Shift) <= Keys.None)
{
return(false);
}
base.OnMouseUp(eventArgs);
WorkflowView parentView = base.ParentView;
if (!base.DragRectangle.IsEmpty && (parentView.RootDesigner != null))
{
ActivityDesigner[] intersectingDesigners = CompositeActivityDesigner.GetIntersectingDesigners(parentView.RootDesigner, base.DragRectangle);
ArrayList list = new ArrayList();
foreach (ActivityDesigner designer in intersectingDesigners)
{
list.Add(designer.Activity);
}
ISelectionService service = base.GetService(typeof(ISelectionService)) as ISelectionService;
if ((list.Count > 0) && (service != null))
{
service.SetSelectedComponents((object[])list.ToArray(typeof(object)), SelectionTypes.Replace);
}
}
return(true);
}
public override void OnActivate()
{
if (this.AssociatedDesigner == null)
{
Type type = base.UserData[UserDataKey_ActivityType] as Type;
CompositeActivity activity = this.parentDesigner.Activity as CompositeActivity;
if (((type != null) && (activity != null)) && this.parentDesigner.IsEditable)
{
Activity activity2 = Activator.CreateInstance(type) as Activity;
try
{
CompositeActivityDesigner.InsertActivities(this.parentDesigner, new System.Workflow.ComponentModel.Design.HitTestInfo(this.parentDesigner, HitTestLocations.Designer), new List <Activity>(new Activity[] { activity2 }).AsReadOnly(), SR.GetString("AddingImplicitActivity"));
}
catch (Exception exception)
{
if (exception != CheckoutException.Canceled)
{
IUIService service = this.parentDesigner.Activity.Site.GetService(typeof(IUIService)) as IUIService;
if (service != null)
{
service.ShowError(exception.Message);
}
}
}
ActivityDesigner designer = ActivityDesigner.GetDesigner(activity2);
base.UserData[UserDataKey_Designer] = designer;
}
}
}
private void SetAutoExpandableDesigner(CompositeActivityDesigner value)
{
if (this.autoExpandableDesigner == value)
{
return;
}
//We always remove this so that the timer counter gets reset
if (value == null || value.Expanded || !value.CanExpandCollapse)
{
this.autoExpandableDesigner = null;
if (this.autoExpandEventHandler != null)
{
WorkflowTimer.Default.Unsubscribe(this.autoExpandEventHandler);
this.autoExpandEventHandler = null;
}
}
else
{
//User has to hover for 2 seconds
this.autoExpandableDesigner = value;
if (this.autoExpandEventHandler == null)
{
this.autoExpandEventHandler = new EventHandler(OnAutoExpand);
WorkflowTimer.Default.Subscribe(500, this.autoExpandEventHandler);
}
}
}
public override AccessibleObject Navigate(AccessibleNavigation navdir)
{
if (navdir == AccessibleNavigation.Up || navdir == AccessibleNavigation.Previous ||
navdir == AccessibleNavigation.Down || navdir == AccessibleNavigation.Next)
{
DesignerNavigationDirection navigate = default(DesignerNavigationDirection);
if (navdir == AccessibleNavigation.Up || navdir == AccessibleNavigation.Previous)
{
navigate = DesignerNavigationDirection.Up;
}
else
{
navigate = DesignerNavigationDirection.Down;
}
CompositeActivityDesigner compositeDesigner = this.ActivityDesigner.ParentDesigner;
if (compositeDesigner != null)
{
object nextSelectableObj = compositeDesigner.GetNextSelectableObject(this.ActivityDesigner.Activity, navigate);
if (nextSelectableObj is ConnectorHitTestInfo)
{
return(GetChild(((ConnectorHitTestInfo)nextSelectableObj).MapToIndex()));
}
}
}
return(base.Navigate(navdir));
}
private void OnStatusDelete(object sender, EventArgs e)
{
MenuCommand command = (MenuCommand)sender;
command.Enabled = false;
IDesignerHost service = this.serviceProvider.GetService(typeof(IDesignerHost)) as IDesignerHost;
if (((service == null) || (service.RootComponent == null)) || !this.selectionService.GetComponentSelected(service.RootComponent))
{
ICollection selectedComponents = this.selectionService.GetSelectedComponents();
if (DesignerHelpers.AreComponentsRemovable(selectedComponents))
{
foreach (DictionaryEntry entry in Helpers.PairUpCommonParentActivities(Helpers.GetTopLevelActivities(selectedComponents)))
{
CompositeActivityDesigner designer = ActivityDesigner.GetDesigner(entry.Key as Activity) as CompositeActivityDesigner;
if ((designer != null) && !designer.CanRemoveActivities(new List <Activity>((Activity[])((ArrayList)entry.Value).ToArray(typeof(Activity))).AsReadOnly()))
{
command.Enabled = false;
return;
}
}
command.Enabled = true;
}
}
}
internal ContainedDesignSurface(IServiceProvider parentServiceProvider, CompositeActivityDesigner parentDesigner) : base(parentServiceProvider)
{
this.parentDesigner = parentDesigner;
if (base.ServiceContainer != null)
{
base.ServiceContainer.RemoveService(typeof(ISelectionService));
}
}
public override bool CanBeParentedTo(CompositeActivityDesigner parentActivityDesigner)
{
if (parentActivityDesigner == null)
{
throw new ArgumentNullException("parentActivity");
}
return((parentActivityDesigner.Activity is IfElseActivity) && base.CanBeParentedTo(parentActivityDesigner));
}
private void OnMenuCopy(object sender, EventArgs e)
{
if (Helpers.AreAllActivities(this.selectionService.GetSelectedComponents()))
{
Activity[] topLevelActivities = Helpers.GetTopLevelActivities(this.selectionService.GetSelectedComponents());
Clipboard.SetDataObject(CompositeActivityDesigner.SerializeActivitiesToDataObject(this.serviceProvider, topLevelActivities));
}
}
public ConnectorHitTestInfo(CompositeActivityDesigner compositeActivityDesigner, HitTestLocations flags, int connector) : base(compositeActivityDesigner, flags)
{
if (this.connector < 0)
{
throw new ArgumentException(SR.GetString("Error_InvalidConnectorValue"), "connector");
}
this.connector = connector;
}
public override AccessibleObject GetChild(int index)
{
CompositeActivityDesigner activityDesigner = base.ActivityDesigner as CompositeActivityDesigner;
if ((index >= 0) && (index < activityDesigner.ContainedDesigners.Count))
{
return(activityDesigner.ContainedDesigners[index].AccessibilityObject);
}
return(base.GetChild(index));
}
private void OnStatusPaste(object sender, EventArgs e)
{
MenuCommand command = (MenuCommand)sender;
command.Enabled = false;
object primarySelection = this.selectionService.PrimarySelection;
CompositeActivityDesigner parentDesigner = ActivityDesigner.GetDesigner(primarySelection as Activity) as CompositeActivityDesigner;
if (parentDesigner == null)
{
parentDesigner = ActivityDesigner.GetParentDesigner(primarySelection);
}
if ((parentDesigner != null) && parentDesigner.IsEditable)
{
IDesignerHost host = this.serviceProvider.GetService(typeof(IDesignerHost)) as IDesignerHost;
IToolboxService service = (IToolboxService)this.serviceProvider.GetService(typeof(IToolboxService));
IDataObject dataObject = Clipboard.GetDataObject();
if (((dataObject != null) && (host != null)) && ((dataObject.GetDataPresent("CF_WINOEDESIGNERCOMPONENTS") || (service == null)) || service.IsSupported(dataObject, host)))
{
System.Workflow.ComponentModel.Design.HitTestInfo insertLocation = null;
if (primarySelection is System.Workflow.ComponentModel.Design.HitTestInfo)
{
insertLocation = (System.Workflow.ComponentModel.Design.HitTestInfo)primarySelection;
}
else if (primarySelection is CompositeActivity)
{
insertLocation = new System.Workflow.ComponentModel.Design.HitTestInfo(parentDesigner, HitTestLocations.Designer);
}
else if (primarySelection is Activity)
{
Activity item = primarySelection as Activity;
CompositeActivity parent = item.Parent;
CompositeActivityDesigner designer = ActivityDesigner.GetDesigner(parent) as CompositeActivityDesigner;
if (designer != null)
{
insertLocation = new ConnectorHitTestInfo(designer, HitTestLocations.Designer, parent.Activities.IndexOf(item) + 1);
}
}
ICollection activities = null;
try
{
activities = CompositeActivityDesigner.DeserializeActivitiesFromDataObject(this.serviceProvider, dataObject);
}
catch (CheckoutException exception)
{
if (exception != CheckoutException.Canceled)
{
throw exception;
}
}
command.Enabled = ((activities != null) && (insertLocation != null)) && parentDesigner.CanInsertActivities(insertLocation, new List <Activity>(Helpers.GetTopLevelActivities(activities)).AsReadOnly());
}
}
}
public override bool CanBeParentedTo(CompositeActivityDesigner parentActivityDesigner)
{
for (Activity activity = parentActivityDesigner.Activity; activity != null; activity = activity.Parent)
{
if (((activity is CancellationHandlerActivity) || (activity is CompensationHandlerActivity)) || (activity is FaultHandlerActivity))
{
return(true);
}
}
return(false);
}
private void OnSelectionChanged(object sender, EventArgs e)
{
ISelectionService selectionService = GetService(typeof(ISelectionService)) as ISelectionService;
if (selectionService == null || ActiveDesigner != this)
{
return;
}
foreach (ItemInfo itemInfo in this.previewStrip.Items)
{
if (itemInfo.UserData[DesignerUserDataKeys.Activity] == selectionService.PrimarySelection)
{
this.previewStrip.ActiveItem = itemInfo;
break;
}
}
//We need to make sure that for preview designer; if we select the designer using property grid or
//any other means then selection is visible
if (selectionService.SelectionCount == 1)
{
ActivityDesigner selectedDesigner = ActivityDesigner.GetDesigner(selectionService.PrimarySelection as Activity);
if (selectedDesigner != null && !selectedDesigner.IsVisible && this != selectedDesigner.ParentDesigner)
{
//PLEASE NOTE:
//We want to search if the current designer is ancestor of selected designer
//We do the search till we hit the immediate child of the "this" designer in ancestor chain
//so that if we are in preview mode then we make sure that we make the imamediate child of "this" visible
ActivityDesigner designer = selectedDesigner;
while (designer != null)
{
CompositeActivityDesigner parentDesigner = designer.ParentDesigner;
if (this == parentDesigner)
{
break;
}
designer = parentDesigner;
}
if (designer != null)
{
if (this.previewWindow != null && this.previewWindow.PreviewMode)
{
designer.EnsureVisible();
}
else
{
selectedDesigner.EnsureVisible();
}
}
}
}
}
public override bool CanBeParentedTo(CompositeActivityDesigner parentActivityDesigner)
{
if (parentActivityDesigner == null)
{
throw new ArgumentNullException("parentActivity");
}
if ((!Type.GetType("System.Workflow.Activities.ListenActivity,System.Workflow.Activities, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35").IsAssignableFrom(parentActivityDesigner.Activity.GetType()) && !(parentActivityDesigner.Activity is EventHandlersActivity)) && !Type.GetType("System.Workflow.Activities.StateActivity,System.Workflow.Activities, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35").IsAssignableFrom(parentActivityDesigner.Activity.GetType()))
{
return(false);
}
return(base.CanBeParentedTo(parentActivityDesigner));
}
public override bool CanBeParentedTo(CompositeActivityDesigner parentActivityDesigner)
{
if (parentActivityDesigner == null)
{
throw new ArgumentNullException("parentActivity");
}
if ((parentActivityDesigner.Activity != null) && !(parentActivityDesigner.Activity is EventHandlingScopeActivity))
{
return(false);
}
return(base.CanBeParentedTo(parentActivityDesigner));
}
public override AccessibleObject GetChild(int index)
{
CompositeActivityDesigner compositeDesigner = base.ActivityDesigner as CompositeActivityDesigner;
if (index >= 0 && index < compositeDesigner.ContainedDesigners.Count)
{
return(compositeDesigner.ContainedDesigners[index].AccessibilityObject);
}
else
{
return(base.GetChild(index));
}
}
private List <ActivityDesigner> GetMatchingActivityDesigners(ActivityDesigner activityDesigner)
{
CompositeActivityDesigner rootDesigner = DesignerPainter.GetRootDesigner(activityDesigner);
matchingActivityDesigner = new List <ActivityDesigner>();
Walker activityTreeWalker = new Walker();
activityTreeWalker.FoundActivity += new WalkerEventHandler(OnWalkerFoundActivity);
activityTreeWalker.Walk(rootDesigner.Activity);
return(matchingActivityDesigner);
}
internal bool IsValidDropContext(HitTestInfo dropLocation)
{
if (this.draggedActivities.Count == 0)
{
return(false);
}
if (dropLocation == null || dropLocation.AssociatedDesigner == null)
{
return(false);
}
CompositeActivityDesigner compositeDesigner = dropLocation.AssociatedDesigner as CompositeActivityDesigner;
if (compositeDesigner == null)
{
return(false);
}
if (!compositeDesigner.IsEditable || !compositeDesigner.CanInsertActivities(dropLocation, new List <Activity>(this.draggedActivities).AsReadOnly()))
{
return(false);
}
if (!this.wasCtrlKeyPressed && this.existingDraggedActivities.Count > 0)
{
//We are trying to move the actvities with designer
if (!DesignerHelpers.AreAssociatedDesignersMovable(this.draggedActivities))
{
return(false);
}
if (IsRecursiveDropOperation(dropLocation.AssociatedDesigner))
{
return(false);
}
IDictionary commonParentActivities = Helpers.PairUpCommonParentActivities(this.draggedActivities);
foreach (DictionaryEntry entry in commonParentActivities)
{
CompositeActivityDesigner compositeActivityDesigner = ActivityDesigner.GetDesigner(entry.Key as Activity) as CompositeActivityDesigner;
Activity[] activitiesToMove = (Activity[])((ArrayList)entry.Value).ToArray(typeof(Activity));
if (compositeActivityDesigner != null && !compositeActivityDesigner.CanMoveActivities(dropLocation, new List <Activity>(activitiesToMove).AsReadOnly()))
{
return(false);
}
}
}
return(true);
}
public override void EnsureVisibleContainedDesigner(ActivityDesigner containedDesigner)
{
if (containedDesigner == null)
{
throw new ArgumentNullException("containedDesigner");
}
//we could be collapsed, make sure the view itself is visible
this.Expanded = true;
ActivityDesigner activeDesigner = ActiveDesigner;
if (containedDesigner != activeDesigner && containedDesigner != this)
{
DesignerView viewToActivate = null;
ReadOnlyCollection <DesignerView> views = ValidatedViews;
//Go thru the views and check if the child designer is one of the views
foreach (DesignerView view in views)
{
if (containedDesigner == view.AssociatedDesigner)
{
viewToActivate = view;
break;
}
}
//This means that the child designer is in our main flow
if (viewToActivate == null)
{
viewToActivate = views[0];
}
ActiveView = viewToActivate;
//Invoking a verb might change the shown view so we map again
CompositeActivityDesigner activeCompositeDesigner = ActiveDesigner as CompositeActivityDesigner;
if (activeCompositeDesigner != null)
{
if (activeCompositeDesigner != this)
{
activeCompositeDesigner.EnsureVisibleContainedDesigner(containedDesigner);
}
else
{
base.EnsureVisibleContainedDesigner(containedDesigner);
}
}
}
}
public override bool CanBeParentedTo(CompositeActivityDesigner parentActivityDesigner)
{
if (parentActivityDesigner == null)
{
throw new ArgumentNullException("parentActivityDesigner");
}
if (!(parentActivityDesigner.Activity is FaultHandlersActivity))
{
return(false);
}
return(base.CanBeParentedTo(parentActivityDesigner));
}
public static CompositeActivityDesigner GetRootDesigner(ActivityDesigner designer)
{
if (designer == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("designer");
}
CompositeActivityDesigner rootDesigner = designer.ParentDesigner;
while (!rootDesigner.IsRootDesigner && rootDesigner.ParentDesigner != null)
{
rootDesigner = rootDesigner.ParentDesigner;
}
return(rootDesigner);
}
private void OnAddBranch(object sender, EventArgs e)
{
CompositeActivity activity = this.OnCreateNewBranch();
CompositeActivity activity2 = base.Activity as CompositeActivity;
if ((activity2 != null) && (activity != null))
{
int count = this.ContainedDesigners.Count;
CompositeActivityDesigner.InsertActivities(this, new ConnectorHitTestInfo(this, HitTestLocations.Designer, activity2.Activities.Count), new List <Activity>(new Activity[] { activity }).AsReadOnly(), DR.GetString("AddingBranch", new object[] { activity.GetType().Name }));
if ((this.ContainedDesigners.Count > count) && (this.ContainedDesigners.Count > 0))
{
this.ContainedDesigners[this.ContainedDesigners.Count - 1].EnsureVisible();
}
}
}
//Please note that before changing this algorithm, you need to know that changing this algorithm
//will affect the z order of the designers and will affect the way glyphs are drawn.
//Here what we are using depth first search algorithm to maintain the Z order.
//Please note that even though one might think the algo might cause some inefficiency, the algo
//has been timed for huge workflow and typically takes < 20ms to execute
private ActivityDesigner[] GetActivityDesigners(Rectangle logicalViewPort)
{
//We need to go to the deepest point and then start drawing outwards
List <ActivityDesigner> designerList = new List <ActivityDesigner>();
bool viewPortEmpty = logicalViewPort.IsEmpty;
ActivityDesigner rootDesigner = ActivityDesigner.GetSafeRootDesigner(ParentView);
if (rootDesigner != null)
{
Stack <object> designerStack = new Stack <object>();
designerStack.Push(rootDesigner);
CompositeActivityDesigner compositeDesigner = rootDesigner as CompositeActivityDesigner;
if (compositeDesigner != null && compositeDesigner.ContainedDesigners.Count > 0)
{
designerStack.Push(compositeDesigner.ContainedDesigners);
}
while (designerStack.Count > 0)
{
object topOfStack = designerStack.Pop();
ICollection designers = topOfStack as ICollection;
if (designers != null)
{
foreach (ActivityDesigner activityDesigner in designers)
{
if ((viewPortEmpty || logicalViewPort.IntersectsWith(activityDesigner.Bounds)) && activityDesigner.IsVisible)
{
designerStack.Push(activityDesigner);
compositeDesigner = activityDesigner as CompositeActivityDesigner;
if (compositeDesigner != null && compositeDesigner.ContainedDesigners.Count > 0)
{
designerStack.Push(compositeDesigner.ContainedDesigners);
}
}
}
}
else
{
//Draw glyphs for composite designers
designerList.Add((ActivityDesigner)topOfStack);
}
}
}
return(designerList.ToArray());
}
