private ModelItem FindModelItemToFocus(ModelItem itemToFocus)
{
WorkflowViewService viewService = this.WorkflowViewService;
if (viewService == null || itemToFocus == null)
{
return(itemToFocus);
}
ModelUtilities.ReverseTraverse(itemToFocus, (ModelItem modelItem) =>
{
if (modelItem == null)
{
// continue;
return(true);
}
// if the item has Designer, we assume it can get focus.
if (CanFocusOnModelItem(modelItem, viewService))
{
itemToFocus = modelItem;
// break;
return(false);
}
// continue
return(true);
});
return(itemToFocus);
}
public override void Initialize(EditingContext context)
{
this.context = context;
AttachedPropertiesService propertiesService = this.context.Services.GetService<AttachedPropertiesService>();
helpService = this.context.Services.GetService<IIntegratedHelpService>();
oldSelection = this.context.Items.GetValue<Selection>();
isPrimarySelectionProperty = new AttachedProperty<bool>()
{
Getter = (modelItem) => (this.context.Items.GetValue<Selection>().PrimarySelection == modelItem),
Name = "IsPrimarySelection",
OwnerType = typeof(Object)
};
isSelectionProperty = new AttachedProperty<bool>()
{
Getter = (modelItem) => (((IList)this.context.Items.GetValue<Selection>().SelectedObjects).Contains(modelItem)),
Name = "IsSelection",
OwnerType = typeof(Object)
};
propertiesService.AddProperty(isPrimarySelectionProperty);
propertiesService.AddProperty(isSelectionProperty);
if (this.context.Services.GetService<ViewService>() == null)
{
view = new System.Activities.Presentation.View.DesignerView(this.context);
WorkflowViewService viewService = new WorkflowViewService(context);
WorkflowViewStateService viewStateService = new WorkflowViewStateService(context);
this.context.Services.Publish<ViewService>(viewService);
this.context.Services.Publish<VirtualizedContainerService>(new VirtualizedContainerService(this.context));
this.context.Services.Publish<ViewStateService>(viewStateService);
this.context.Services.Publish<DesignerView>(view);
WorkflowAnnotationAdornerService annotationService = new WorkflowAnnotationAdornerService();
annotationService.Initialize(this.context, view.scrollViewer);
this.context.Services.Publish<AnnotationAdornerService>(annotationService);
this.context.Services.Subscribe<ModelService>(delegate(ModelService modelService)
{
this.modelService = modelService;
if (modelService.Root != null)
{
view.MakeRootDesigner(modelService.Root);
}
view.RestoreDesignerStates();
this.context.Items.Subscribe<Selection>(new SubscribeContextCallback<Selection>(OnItemSelected));
});
}
if (helpService != null)
{
helpService.AddContextAttribute(string.Empty, KeywordForWorkflowDesignerHomePage, HelpKeywordType.F1Keyword);
}
}
static Type ResolveGenericParameters(DependencyObject dropTarget, EditingContext context, Type type)
{
// look to see if there is a DefaultTypeArgumentAttribute on it
DefaultTypeArgumentAttribute typeArgumentAttribute = ExtensibilityAccessor.GetAttribute <DefaultTypeArgumentAttribute>(type);
if (typeArgumentAttribute != null && typeArgumentAttribute.Type != null)
{
type = type.MakeGenericType(typeArgumentAttribute.Type);
}
else //require user to resolve generic arguments
{
ActivityTypeResolver wnd = new ActivityTypeResolver();
if (null != context)
{
WindowHelperService service = context.Services.GetService <WindowHelperService>();
if (null != service)
{
service.TrySetWindowOwner(dropTarget, wnd);
}
}
TypeResolvingOptions dropTargetOptions = null;
TypeResolvingOptions activityTypeOptions = null;
//try to see if the container has any customization for type resolver
ICompositeView container = dropTarget as ICompositeView;
if (container != null)
{
dropTargetOptions = container.DroppingTypeResolvingOptions;
}
//try to see if the activity type in discourse has any customization for type resolver
TypeResolvingOptionsAttribute attr = WorkflowViewService.GetAttribute <TypeResolvingOptionsAttribute>(type);
if (attr != null)
{
activityTypeOptions = attr.TypeResolvingOptions;
}
//if both have type resolver, try to merge them
TypeResolvingOptions options = TypeResolvingOptions.Merge(dropTargetOptions, activityTypeOptions);
if (options != null)
{
wnd.Options = options;
}
wnd.Context = context;
wnd.EditedType = type;
wnd.Width = 340;
wnd.Height = 200;
type = (true == wnd.ShowDialog() ? wnd.ConcreteType : null);
}
return(type);
}
private static bool CanFocusOnModelItem(ModelItem itemToFocus, WorkflowViewService viewService)
{
Fx.Assert(itemToFocus != null && viewService != null, "null argument");
if (typeof(ITextExpression).IsAssignableFrom(itemToFocus.ItemType))
{
return(false);
}
Type designerType = viewService.GetDesignerType(itemToFocus.ItemType);
return(typeof(WorkflowViewElement).IsAssignableFrom(designerType));
}
private static bool ModelItemHasDesigner(ModelItem modelItem)
{
if (modelItem != null)
{
DesignerAttribute attribute = WorkflowViewService.GetAttribute <DesignerAttribute>(modelItem.ItemType);
if (attribute != null && !string.IsNullOrEmpty(attribute.DesignerTypeName))
{
return(true);
}
}
return(false);
}
internal IEnumerable <ModelItem> GetItemsOnDesigner(bool preOrder, bool excludeRoot, bool excludeErrorActivity, bool excludeExpression, bool includeOtherObjects)
{
WorkflowViewService viewService = this.WorkflowViewService;
IList <ModelItem> items =
ModelTreeManager.DepthFirstSearch(modelService.Root,
delegate(Type type)
{
// Only find items on the designer surface.
return(includeOtherObjects || (typeof(WorkflowViewElement).IsAssignableFrom(viewService.GetDesignerType(type))));
},
delegate(ModelItem modelItem)
{
return(!(excludeExpression && modelItem != null && typeof(ITextExpression).IsAssignableFrom(modelItem.ItemType)));
},
preOrder);
// ModelItemKeyValuePair is associated with CaseDesigner.
// So ModelItemKeyValuePair will be returned even if they are not really Cases.
// Those ModelItemKeyValuePairs need to be excluded.
IEnumerable <ModelItem> itemsToSearch = null;
if (!excludeErrorActivity)
{
itemsToSearch = items.Where <ModelItem>(item => !ModelUtilities.IsModelItemKeyValuePair(item.ItemType) ||
ModelUtilities.IsSwitchCase(item));
}
else
{
itemsToSearch = items.Where <ModelItem>(item =>
(!ModelUtilities.IsModelItemKeyValuePair(item.ItemType) || ModelUtilities.IsSwitchCase(item)) &&
!IsErrorActivity(item));
}
if (excludeRoot)
{
itemsToSearch = itemsToSearch.Except <ModelItem>(new ModelItem[] { modelService.Root });
}
return(itemsToSearch);
}
private static bool CanFocusOnModelItem(ModelItem itemToFocus, WorkflowViewService viewService)
{
Fx.Assert(itemToFocus != null && viewService != null, "null argument");
if (typeof(ITextExpression).IsAssignableFrom(itemToFocus.ItemType))
{
return false;
}
Type designerType = viewService.GetDesignerType(itemToFocus.ItemType);
return typeof(WorkflowViewElement).IsAssignableFrom(designerType);
}
// Entry point method for setting focus.
// it is executed exactly once, on application idle event
// there are 3 basic paths:
// a) optimistic - element we are looking for, is visible - i bring it into view and set keyboard focus to it
// b) unlikely - element doesn't have any visual parents - i make it a root designer, wait for it to load and set keyboard focus to it
// c) pesimistic/complex - element isn't in the view, moreover, it is located in a tree branch which is not (or is partialy) visible
void Focus()
{
//can i continue?
if (shouldAbort)
{
return;
}
//hide the designer view until focus is set
this.onSetDesignerContentVisibilityDelegate(Visibility.Hidden);
//delegate visibility restore for designer view after focus update is complete
Dispatcher.CurrentDispatcher.BeginInvoke(this.onSetDesignerContentVisibilityDelegate, DispatcherPriority.ApplicationIdle, Visibility.Visible);
//set selection to the item to focus, so all apropriate designers get a chance to update themselfs before we start expanding - this may
//result in visual tree change
Selection.SelectOnly(this.Context, this.itemToFocus);
//easy path - if the current designer is available and visible - bring it to view and focus
if (null != this.itemToFocus.View && ((UIElement)this.itemToFocus.View).IsVisible)
{
this.onElementFocusingDelegate(this.itemToFocus);
return;
}
//get items up to the tree root, which can be visualized (have associated designer)
//include only up to "level" items (avoid expanding whole tree)
bool shouldContinue = true;
int visualItemsCount = 0;
var visualItems = this.itemToFocus
.GetParentEnumerator(p => shouldContinue)
.Where(p =>
{
//filter only items with designer attribute
bool result = false;
var designerType = this.ViewService.GetDesignerType(p.ItemType);
if (null != designerType)
{
result = true;
visualItemsCount++;
//if designer has Options attribute, check if it always collapsed children - if so, this will be the topmost parent
//(displaying anything above, will never display its children)
var options = WorkflowViewService.GetAttribute <ActivityDesignerOptionsAttribute>(designerType);
if (null != options && options.AlwaysCollapseChildren && visualItemsCount > 2)
{
shouldContinue = false;
}
}
return(result);
})
.Take(this.currentLevel)
.ToArray();
//nothing to expand, rather unlikely, but handle it anyway
if (visualItems.Length == 0)
{
//reset ticket, to prevent any further calls from executing
ModelItemFocusHelper.focusTicket = null;
//force item to be root designer (this is last resort, it is executed only if focusTicket is null)
this.onForceElementFocusDelegate();
return;
}
//get the first parent of an item, which is visible
var firstVisibleItem = visualItems.FirstOrDefault(p => null != p.View && ((UIElement)p.View).IsVisible);
bool enqueueFirstExpand = false;
//is there anything visible in the path between item and its parents?
if (null != firstVisibleItem)
{
//yes - limit the amount of items to expand to only designers which are not visible yet
//(include the first visible designer, so algorithm can have a start point with something visible)
this.itemsToExpand = visualItems.TakeWhile(p => firstVisibleItem != p).Concat(new ModelItem[] { firstVisibleItem }).ToArray();
}
else
{
//no, nothing is visible yet
this.itemsToExpand = visualItems;
enqueueFirstExpand = true;
//make the top most parent as root designer
this.DesignerView.MakeRootDesigner(this.itemsToExpand[this.itemsToExpand.Length - 1], false);
}
//delegate Expand call - if nothing is visible yet - onIdle - give new designer time to fully render, if someting is visible - execute immediatelly
Dispatcher.CurrentDispatcher.BeginInvoke(new Action(() => { this.Expand(null); }), enqueueFirstExpand ? DispatcherPriority.ContextIdle : DispatcherPriority.Send);
}
internal static bool IsBreakpointAllowed(Type breakpointCandidateType)
{
return(typeof(Activity).IsAssignableFrom(breakpointCandidateType) || WorkflowViewService.GetAttribute <AllowBreakpointAttribute>(breakpointCandidateType) != null);
}
private void OnViewServiceAvailable(ViewService viewService)
{
this.viewService = (WorkflowViewService)viewService;
this.viewService.ViewCreated += this.ViewCreated;
}
private void OnViewServiceAvailable(ViewService viewService)
{
this.viewService = (WorkflowViewService)viewService;
this.viewService.ViewCreated += this.ViewCreated;
}
private static bool HasView(ModelItem modelItem, WorkflowViewService viewService, bool allowDrillIn)
{
ActivityDesignerOptionsAttribute options = WorkflowViewService.GetAttribute<ActivityDesignerOptionsAttribute>(modelItem.ItemType);
Type viewType = viewService.GetDesignerType(modelItem.ItemType);
return typeof(WorkflowViewElement).IsAssignableFrom(viewType) && (!allowDrillIn || options == null || options.AllowDrillIn);
}
public ErrorActivityView()
{
WorkflowViewService.ShowErrorInViewElement(this, SR.ActivityLoadError, null);
}
private DrawingBrush GetIconByVisualValue()
{
if (this.VisualValue != null)
{
DrawingBrush icon = null;
Type modelItemType = this.VisualValue.ItemType;
if (modelItemType.IsGenericType)
{
// If Type is generic type, whatever T, it should display same icon, so use generic type instead.
modelItemType = this.VisualValue.ItemType.GetGenericTypeDefinition();
}
// If the user specifies the attribute, then the Designer would be providing the icon,
// bypassing the pipeline of retrieving the icons via reflection and attached properties.
ActivityDesignerOptionsAttribute attr = ExtensibilityAccessor.GetAttribute <ActivityDesignerOptionsAttribute>(modelItemType);
if (attr != null && attr.OutlineViewIconProvider != null)
{
icon = attr.OutlineViewIconProvider(this.VisualValue);
}
if (icon == null && !TreeViewItemViewModel.IconCache.TryGetValue(modelItemType, out icon))
{
EditingContext context = this.VisualValue.GetEditingContext();
ViewService service = context.Services.GetService <ViewService>();
WorkflowViewService workflowViewService = service as WorkflowViewService;
ActivityDesigner designer = null;
// first try to create an detached view element that won't participate in the designer,
// if the view service is WorkflowViewService
if (workflowViewService != null)
{
designer = workflowViewService.CreateDetachedViewElement(this.VisualValue) as ActivityDesigner;
icon = GetIconFromUnInitializedDesigner(designer);
}
else
{
// fall back if the view service is not the default implementation
// We only need to get the icon from the designer, so we don't need to make sure the view is parented.
designer = this.VisualValue.View as ActivityDesigner;
if (designer == null && service != null)
{
designer = service.GetView(this.VisualValue) as ActivityDesigner;
}
if (designer != null)
{
if (designer.Icon != null || designer.IsLoaded)
{
icon = designer.Icon;
}
else
{
icon = GetIconFromUnInitializedDesigner(designer);
}
}
}
// Cache even a null icon since answers found above won't change within this AppDomain
TreeViewItemViewModel.IconCache.Add(modelItemType, icon);
}
return(icon);
}
else
{
return(null);
}
}