/// <summary> /// Traverses the specified path, inserting <see cref="BranchNode"/>s as necessary, until the end of the path /// is reached, at which point the <paramref name="leafNodeProvider"/> is called to provide a leaf node to insert. /// </summary> protected void Insert(Path path, int pathDepth, Converter <PathSegment, ActionModelNode> leafNodeProvider) { int segmentCount = path.Segments.Count; if (segmentCount < 2) { throw new ArgumentException(SR.ExceptionInvalidActionPath); } PathSegment segment = path.Segments[pathDepth]; if (pathDepth + 1 == segmentCount) { // this is the last path segment -> leaf node _childNodes.Add(leafNodeProvider(segment)); } else { ActionModelNode child = FindChild(segment); if (child == null) { child = new BranchNode(segment); _childNodes.Add(child); } child.Insert(path, pathDepth + 1, leafNodeProvider); } }
public static void BuildMenu(MenuShell menu, ActionModelNode node) { if (node.PathSegment != null) { MenuItem menuItem; if (node.Action != null) { // this is a leaf node (terminal menu item) menuItem = new ActiveMenuItem((IClickAction)node.Action); } else { // this menu item has a sub menu string menuText = node.PathSegment.LocalizedText.Replace('&', '_'); menuItem = new MenuItem(menuText); menuItem.Submenu = new Menu(); } menu.Append(menuItem); menu = (MenuShell)menuItem.Submenu; } foreach (ActionModelNode child in node.ChildNodes) { BuildMenu(menu, child); } }
/// <summary> /// Creates a copy of the subtree beginning at this node. /// </summary> protected ActionModelNode CloneTree() { ActionModelNode clone = CloneNode(this.PathSegment); foreach (ActionModelNode child in _childNodes) { clone._childNodes.Add(child.CloneTree()); } return(clone); }
private static void ShowContextMenu(ContextMenuStrip contextMenuStrip, ActionModelNode actionModel, Point screenPoint, int minWidth, bool alignRight) { ToolStripBuilder.Clear(contextMenuStrip.Items); if (actionModel != null) { ToolStripBuilder.BuildMenu(contextMenuStrip.Items, actionModel.ChildNodes); if (alignRight) screenPoint.Offset(-contextMenuStrip.Width, 0); contextMenuStrip.Show(screenPoint); } }
/// <summary> /// Persists an in-memory abstract action model to the XML model. /// </summary> /// <remarks> /// This method functions as a counterpart to <see cref="BuildAbstractActionModel"/>. The specified abstract action model /// (created by <see cref="BuildAbstractActionModel"/>, or potentially modified further) is flattened and its nodes /// written out to the XML mode, replacing any existing model at the same qualified site. This allows action model /// configuration interfaces to make changes to the action model. /// </remarks> /// <param name="namespace">A namespace to qualify the site.</param> /// <param name="site">The site.</param> /// <param name="abstractActionModel">The abstract action model to be persisted.</param> /// <returns>An <see cref="ActionModelNode"/> representing the root of the action model.</returns> public void PersistAbstractActionModel(string @namespace, string site, ActionModelRoot abstractActionModel) { // do one time initialization if (_actionModelXmlDoc == null) { Initialize(); } XmlElement separatorTemplate = _actionModelXmlDoc.CreateElement("separator"); string actionModelId = string.Format("{0}:{1}", @namespace, site); XmlElement xmlActionModel = FindXmlActionModel(actionModelId); if (xmlActionModel != null) { // clear the action model List <XmlNode> childrenToClear = CollectionUtils.Cast <XmlNode>(xmlActionModel.ChildNodes); foreach (XmlNode childNode in childrenToClear) { xmlActionModel.RemoveChild(childNode); } } else { // add a new action model this.GetActionModelsNode().AppendChild(xmlActionModel = CreateXmlActionModel(actionModelId)); } ActionModelNode[] leafNodes = abstractActionModel.GetLeafNodesInOrder(); for (int n = 0; n < leafNodes.Length; n++) { ActionModelNode leafNode = leafNodes[n]; if (leafNode is ActionNode) { xmlActionModel.AppendChild(CreateXmlAction(_actionModelXmlDoc, ((ActionNode)leafNode).Action)); } else if (leafNode is SeparatorNode) { xmlActionModel.AppendChild(separatorTemplate.Clone()); } } if (!_temporary) { this.ActionModelsXml = _actionModelXmlDoc; this.Save(); } }
/// <summary> /// Merges the specified model into this model. /// </summary> public void Merge(ActionModelNode other) { foreach (ActionModelNode otherChild in other._childNodes) { ActionModelNode thisChild = FindChild(otherChild.PathSegment); if (thisChild != null) { thisChild.Merge(otherChild); } else { _childNodes.Add(otherChild.CloneTree()); } } }
/// <summary> /// Searches <paramref name="actionNode"/> and returns the action (represented as HTML) whose label matches /// <paramref name="labelSearch"/>. /// </summary> /// <param name="actionNode">The node to be searched.</param> /// <param name="labelSearch">The label to match on.</param> /// <param name="actionLabel">The new label to be applied to the action in the returned HTML.</param> /// <returns>The found action represented as HTML, otherwise an empty string.</returns> public string GetHTML(ActionModelNode actionNode, string labelSearch, string actionLabel) { IAction[] actions = actionNode.GetActionsInOrder(); if (actions.Length == 0) return ""; // find the action corresponding to the action label, if exist foreach (var action in actions) { if (action.Label == labelSearch) return GetHTML(action.Path.LocalizedPath, actionLabel); } return ""; }
public static void BuildToolbar(Toolbar toolbar, Tooltips tooltips, ActionModelNode node, int depth) { if (node.Action != null) { // create the tool button ToolButton button = new ActiveToolbarButton((IClickAction)node.Action, tooltips); toolbar.Insert(button, toolbar.NItems); } else { foreach (ActionModelNode child in node.ChildNodes) { BuildToolbar(toolbar, tooltips, child, depth + 1); } } }
/// <summary> /// Constructor. /// </summary> public BiographyOrderReportsComponentControl(BiographyOrderReportsComponent component) : base(component) { _component = component; InitializeComponent(); Control reportPreview = (Control) _component.ReportPreviewComponentHost.ComponentView.GuiElement; reportPreview.Dock = DockStyle.Fill; _reportPreviewPanel.Controls.Add(reportPreview); _reports.DataSource = _component.Reports; _reports.DataBindings.Add("Value", _component, "SelectedReport", true, DataSourceUpdateMode.OnPropertyChanged); _reports.Format += delegate(object sender, ListControlConvertEventArgs e) { e.Value = _component.FormatReportListItem(e.ListItem); }; _toolbarActionModel = _component.ActionModel; ToolStripBuilder.BuildToolbar(_toolstrip.Items, _toolbarActionModel.ChildNodes); _component.AllPropertiesChanged += AllPropertiesChangedEventHandler; }
////TODO (CR May 2010): We should add in the capability for handler extensions, /// much like the applicationcomponent views. public static ActionNodeEntityHandler Create(ActionModelNode modelNode) { if (modelNode is ActionNode) { IAction action = ((ActionNode)modelNode).Action; if (action is DropDownButtonAction) { IEntityHandler handler = Create<DropDownButtonActionEntityHandler>(); handler.SetModelObject(action); return (ActionNodeEntityHandler)handler; } if (action is DropDownAction) { IEntityHandler handler = Create<DropDownActionEntityHandler>(); handler.SetModelObject(action); return (ActionNodeEntityHandler)handler; } if (action is LayoutChangerAction) { IEntityHandler handler = Create<LayoutChangerActionEntityHandler>(); handler.SetModelObject(action); return (ActionNodeEntityHandler)handler; } if (action is IClickAction) { IEntityHandler handler = Create<ClickActionEntityHandler>(); handler.SetModelObject(action); return (ActionNodeEntityHandler)handler; } } else if (modelNode.ChildNodes.Count > 0) { IEntityHandler handler = Create<BranchActionEntityHandler>(); handler.SetModelObject(modelNode); return (ActionNodeEntityHandler)handler; } //TODO (CR May 2010): although we won't get here, if we did, we should throw return null; }
/// <summary> /// Sets the toolbar model, causing the toolbar displayed on the screen to be updated. /// </summary> /// <remarks> /// </remarks> /// <param name="model"></param> public virtual void SetToolbarModel(ActionModelNode model) { }
private void AppendActionModel(TableView table, ActionModelNode model) { if (table.ToolbarModel == null) table.ToolbarModel = model; else table.ToolbarModel.Merge(model); if (table.MenuModel == null) table.MenuModel = model; else table.MenuModel.Merge(model); }
/// <summary> /// Called to build menus and toolbars. Override this method to customize menu and toolbar building. /// </summary> /// <remarks> /// The default implementation simply clears and re-creates the toolstrip using methods on the /// utility class <see cref="ToolStripBuilder"/>. /// </remarks> /// <param name="kind"></param> /// <param name="toolStrip"></param> /// <param name="actionModel"></param> protected virtual void BuildToolStrip(ToolStripBuilder.ToolStripKind kind, ToolStrip toolStrip, ActionModelNode actionModel) { // avoid flicker toolStrip.SuspendLayout(); // very important to clean up the existing ones first ToolStripBuilder.Clear(toolStrip.Items); if (actionModel != null) { if (actionModel.ChildNodes.Count > 0) { // Toolstrip should only be visible if there are items on it if (kind == ToolStripBuilder.ToolStripKind.Toolbar) ToolStripBuilder.BuildToolStrip(kind, toolStrip.Items, actionModel.ChildNodes, ToolStripBuilder.ToolStripBuilderStyle.GetDefault(), ToolStripSettings.Default.IconSize); else ToolStripBuilder.BuildToolStrip(kind, toolStrip.Items, actionModel.ChildNodes); } } toolStrip.ResumeLayout(); }
public void AppendToAvailableItemsActionModel(ActionModelNode model) { AppendActionModel(_availableItems, model); }
private void ProcessExplicitContextMenuRequest(Point? location, ActionModelNode actionModel) { //Force a handler with capture to release. if (this.CaptureHandler != null) ReleaseCapture(true); //When we show the context menu, reset the active button and start count, //because the user is going to have to start over again with a new click. _activeButton = 0; _startCount = 0; if (!location.HasValue || !TileClientRectangle.Contains(location.Value)) location = _currentMousePoint; if (actionModel == null) { CompositeGraphic sceneGraph = ((PresentationImage)_tile.PresentationImage).SceneGraph; //Get all the mouse button handlers that provide a context menu. foreach (var handlerGraphic in GetHandlerGraphics(sceneGraph).OfType<IContextMenuProvider>()) { var actionSet = handlerGraphic.GetContextMenuModel(this); if (actionSet != null && actionSet.ChildNodes.Count > 0) { ContextMenuProvider = handlerGraphic; break; } } } else { ContextMenuProvider = new ActionModelProvider(actionModel); } //Request the context menu. _contextMenuEnabled = true; EventsHelper.Fire(_contextMenuRequested, this, new ItemEventArgs<Point>(location.Value)); ContextMenuProvider = null; }
public static void BuildToolbar(Toolbar toolbar, Tooltips tooltips, ActionModelNode node) { BuildToolbar(toolbar, tooltips, node, 0); }
public ItemTag(ActionModelNode node, IActionView view) { _node = node; _view = view; }
/// <summary> /// Sets the menu model, causing the menu displayed on the screen to be updated. /// </summary> /// <remarks> /// </remarks> /// <param name="model"></param> public virtual void SetMenuModel(ActionModelNode model) { }
/// <summary> /// Sets the menu model, causing the menu displayed on the screen to be updated. /// </summary> /// <remarks> /// The default implementation just sets the <see cref="DesktopForm.MenuModel"/> property. /// Override this method if you need to perform custom processing. /// </remarks> /// <param name="model"></param> public virtual void SetMenuModel(ActionModelNode model) { _form.MenuModel = model; }
/// <summary> /// Sets the toolbar model, causing the toolbar displayed on the screen to be updated. /// </summary> /// <remarks> /// The default implementation just sets the <see cref="DesktopForm.ToolbarModel"/> property. /// Override this method if you need to perform custom processing. /// </remarks> /// <param name="model"></param> public virtual void SetToolbarModel(ActionModelNode model) { _form.ToolbarModel = model; }
public ActionModelProvider(ActionModelNode actionModel) { _actionModel = actionModel; }
public void AppendToSelectedItemsActionModel(ActionModelNode model) { AppendActionModel(_selectedItems, model); }