internal override bool OnPreBubbleCommand(CommandEventArgs command)
{
if (_menuLaunched && command.Type != CommandType.MenuCreation &&
command.Type != CommandType.Preview &&
command.Type != CommandType.PreviewRevert &&
command.Type != CommandType.OptionPreview &&
command.Type != CommandType.OptionPreviewRevert &&
command.Type != CommandType.IgnoredByMenu &&
command.Type != CommandType.MenuClose)
{
if (!CUIUtility.IsNullOrUndefined(command.SourceControl))
{
MenuItem selectedItem = (MenuItem)command.SourceControl.DisplayedComponent;
_menu.SelectedMenuItem = selectedItem;
}
Root.CloseMenuStack(this);
}
return(true);
}
/// <summary>
/// Unregister a command handler for the command with the passed in id.
/// </summary>
/// <param name="commandId">The command that the handler is unregistering for.</param>
/// <param name="handler">The handler that should be unregistered for the passed in command id.</param>
public virtual void UnregisterCommandHandler(string commandId, ICommandHandler handler)
{
if (string.IsNullOrEmpty(commandId) || CUIUtility.IsNullOrUndefined(handler))
{
throw new ArgumentNullException("commandId and handler may not be null or undefined");
}
List <ICommandHandler> handlers = GetHandlerRecordForCommand(commandId);
if (CUIUtility.IsNullOrUndefined(handlers))
{
return;
}
if (handlers.Contains(handler))
{
handlers.Remove(handler);
}
}
/// <summary>
/// Removes a page component from this PageManager.
/// </summary>
/// <param name="component">the component that is to be removed</param>
public void RemovePageComponent(PageComponent component)
{
if (CUIUtility.IsNullOrUndefined(_components) || !_components.Contains(component))
{
return;
}
_commandDispatcher.UnregisterMultipleCommandHandler((ICommandHandler)component,
component.GetGlobalCommands());
_components.Remove(component);
// Add this component to the focus manager if it is focusable
if (component.IsFocusable())
{
_focusManager.RemovePageComponent(component);
}
// Remove the component from the hash of their ids
_componentIds[component.GetId()] = null;
}
internal void SetContextualText(string positionText, string contextualText, string groupName, int tabPos, int totalTabs)
{
if (CUIUtility.IsNullOrUndefined(_elmATText))
{
EnsureHiddenATDOMElement();
}
if (Contextual)
{
contextualText = String.Format(contextualText, groupName, tabPos, totalTabs);
}
else
{
contextualText = String.Format(positionText, tabPos, totalTabs);
}
UIUtility.SetInnerText(_elmATText, contextualText);
Utility.EnsureCSSClassOnElement(_elmATText, "ms-cui-hidden");
_elmTitleA.AppendChild(_elmATText);
}
internal void OnKeyPress(HtmlEvent evt)
{
// To make OACR happy
if (evt != null)
{
// using F2 key
int helpKeyPC = 113;
int helpKeyMac = 123;
if (((evt.KeyCode == helpKeyPC) || (evt.KeyCode == helpKeyMac)))
{
string keyword = null;
if (!string.IsNullOrEmpty(_properties.ToolTipHelpKeyWord))
{
keyword = _properties.ToolTipHelpKeyWord;
}
if ((!CUIUtility.IsNullOrUndefined(_disabledInfoProperties)) &&
(!string.IsNullOrEmpty(_disabledInfoProperties.HelpKeyWord)))
{
// if the control is disabled, the disabled info HelpKeyword overrules any previously-set help keyword
keyword = _disabledInfoProperties.HelpKeyWord;
}
if (!string.IsNullOrEmpty(keyword))
{
Dictionary <string, string> dict = new Dictionary <string, string>();
dict["HelpKeyword"] = keyword;
if (!string.IsNullOrEmpty(Root.Properties.ToolTipHelpCommand))
{
RaiseCommandEvent(Root.Properties.ToolTipHelpCommand, CommandType.General, dict);
}
}
// prevent the key's default action
Utility.CancelEventUtility(evt, true, true);
}
else
{
// Close open tooltips
Root.CloseOpenTootips();
}
}
}
internal bool SelectMenuItemById(string menuItemId)
{
// We must have a MenuItemId and a Menu in order to select an item
// The Menu can be null if this control's menu gets populated dynamically
if (string.IsNullOrEmpty(menuItemId) || CUIUtility.IsNullOrUndefined(Menu))
{
return(false);
}
ISelectableControl isc = Menu.GetItemById(menuItemId);
if (CUIUtility.IsNullOrUndefined(isc))
{
return(false);
}
SelectMenuItem(isc);
_itemEverSelected = true;
return(true);
}
/// <summary>
/// Close this Control's tool tip.
/// </summary>
/// <owner alias="HillaryM" />
internal virtual void CloseToolTip()
{
if (!CUIUtility.IsNullOrUndefined(_root))
{
// clear launching timer
Browser.Window.ClearInterval(_root.TooltipLauncherTimer);
}
if (!CUIUtility.IsNullOrUndefined(_toolTip))
{
_toolTip.Hide();
_toolTipLaunched = false;
OnToolTipClosed();
// Remove the tooltip floating div from the DOM
UIUtility.RemoveNode(_toolTip.ElementInternal);
_toolTip = null;
}
}
public override void ReceiveFocus()
{
OnBeginFocus();
ControlComponent comp = DisplayedComponent;
if (CUIUtility.IsNullOrUndefined(comp))
{
return;
}
((MenuItem)comp).Focused = true;
if (!CUIUtility.IsNullOrUndefined(_elmMenu))
{
_elmMenu.PerformFocus();
}
if (!CUIUtility.IsNullOrUndefined(_elmSMenu))
{
_elmSMenu.PerformFocus();
}
}
internal override void PollForStateAndUpdate()
{
// Fix for bug O14:93091 - polling occurs when the spinner DOM element is not
// yet created, so a JS error happens when calling ValidateAndSave()
if (CUIUtility.IsNullOrUndefined(_elmDefault))
{
return;
}
bool succeeded = PollForStateAndUpdateInternal(Properties.Command,
Properties.QueryCommand,
StateProperties,
true);
Unit u = FindUnitByNameOrAbbreviation((string)StateProperties[SpinnerCommandProperties.Unit]);
if (!ValidateAndSave(u, Double.Parse(StateProperties[SpinnerCommandProperties.Value])))
{
throw new ArgumentOutOfRangeException("Invalid valid and/or unit returned when polling");
}
}
/// <summary>
/// Sets Enabled recursively on all this component and all the components below it
/// This is used when a subtree needs to be completely disabled but some of the components
/// have already been set to Enabled=false so they will not call it on their children
/// because the value is not changing. This function will force the whole subtree
/// to become disabled regardless of the Enabled state of the Components in it.
/// </summary>
/// <param name="enabled">the value of Enabled that should be set on the components of this subtree</param>
internal virtual void SetEnabledRecursively(bool enabled)
{
bool changed = _enabled != enabled;
_enabled = enabled;
// Set Enabled for its children if there are any
if (!CUIUtility.IsNullOrUndefined(_children))
{
foreach (Component c in _children)
{
c.SetEnabledRecursively(enabled);
}
}
// If the Enabled value was changed for this component then we let it know
if (changed)
{
OnEnabledChanged(enabled);
}
}
/*
* /// <summary>
* /// Subclassers can hook in here if they want to run their own logic to
* /// get the sought after cui data.
* /// </summary>
* /// <param name="query">The cui query that is to be run.</param>
* public virtual void RunQuery(DataQuery query)
* {
* string version = _version;
* if (!string.IsNullOrEmpty(query.Version))
* version = query.Version;
*
* string lcid = _lcid;
* if (!string.IsNullOrEmpty(query.Lcid))
* lcid = query.Lcid;
*
* string dataUrl = _dataUrl;
* if (!string.IsNullOrEmpty(query.DataUrl))
* dataUrl = query.DataUrl;
*
* string url;
* string type = null;
*
* // The dataUrl passed in might already have parameters
* if (dataUrl.IndexOf('?') == -1)
* url = dataUrl + "?ver=";
* else
* url = dataUrl + "&ver=";
*
* url = url + version + "&id=" + query.Id + "&lcid=" + lcid + "&qt=";
*
* switch (query.QueryType)
* {
* case DataQueryType.All:
* type = "all";
* break;
* case DataQueryType.RibbonTab:
* type = "ribbontab";
* break;
* case DataQueryType.RibbonShallow:
* type = "ribbonshallow";
* break;
* case DataQueryType.Root:
* type = "root";
* break;
* case DataQueryType.RibbonVisibleTabDeep:
* type = "ribbonvisibletabdeep";
* break;
* }
*
* url += type;
#if PERF_METRICS
* PMetrics.PerfMark(PMarker.perfCUIRibbonQueryDataStart);
#endif
* HttpWebRequest req = (HttpWebRequest)WebRequest.Create(url);
* req.Method = "GET";
* req.ContentType = "text/html";
*
* QueryRecord rec = new QueryRecord();
* rec.id = query.Id;
* rec.queryType = query.QueryType;
* rec.data = query.Data;
* rec.handler = query.Handler;
*
* object data= new object();
* RequestState state = new RequestState(req, data, rec);
* IAsyncResult result = req.BeginGetResponse(new AsyncCallback(OnDataReturned),state);
*
* //Register the timeout callback
* ThreadPool.RegisterWaitForSingleObject(result.AsyncWaitHandle,
* new WaitOrTimerCallback(ScanTimeoutCallback), state, (30 * 1000), true);
* }
*
* /// <summary>
* /// Subsclassers could hook in here if they wanted to subprocess the
* /// resulting JSON.
* /// </summary>
* /// <param name="executor">the web executor that has returned from async request</param>
* protected virtual void OnDataReturned(IAsyncResult result)
* {
#if PERF_METRICS
* PMetrics.PerfMark(PMarker.perfCUIRibbonQueryDataEnd);
#endif
* RequestState state = (RequestState)result.AsyncState;
* WebRequest request = (WebRequest)state.Request;
*
* HttpWebResponse response =(HttpWebResponse)request.EndGetResponse(result);
* Stream s = (Stream)response.GetResponseStream();
* StreamReader readStream = new StreamReader(s);
*
* // Get the complete contents of the message
* string dataString = readStream.ReadToEnd();
* response.Close();
* s.Close();
* readStream.Close();
*
* QueryRecord rec = state.Query;
* DataQueryResult res = new DataQueryResult();
* res.ContextData = rec.data;
* res.Id = rec.id;
*
* // If the request succeeded
* // TODO(josefl) figure out right way to find out if it succeeded
* if (!string.IsNullOrEmpty(dataString))
* {
* res.Success = true;
* res.QueryData = dataString;
* rec.handler(res);
* }
* else
* {
* res.Success = false;
* // Return that the data retrieval failed
* rec.handler(res);
* }
* }
*
* private static void ScanTimeoutCallback (object state, bool timedOut)
* {
* if (timedOut)
* {
* RequestState reqState = (RequestState)state;
* if (reqState != null)
* reqState.Request.Abort();
* }
* }
*/
/// <summary>
/// Subclassers can hook in here if they want to run their own logic to
/// get the sought after cui data.
/// </summary>
/// <param name="query">The cui query that is to be run.</param>
public virtual void RunQuery(DataQuery query)
{
QueryRecord rec = new QueryRecord();
rec.id = query.Id;
rec.queryType = query.QueryType;
rec.data = query.Data;
rec.handler = query.Handler;
RibbonData rData = new RibbonData();
JSObject dataBlock;
if (query.TabQuery)
{
dataBlock = rData.GetTabQueryData(query.Id);
}
else
{
dataBlock = rData.GetQueryData(query.Id);
}
DataQueryResult res = new DataQueryResult();
res.ContextData = rec.data;
res.Id = rec.id;
if (!CUIUtility.IsNullOrUndefined(dataBlock))
{
res.Success = true;
res.QueryData = dataBlock;
rec.handler(res);
}
else
{
// Return that the data retrieval failed
res.Success = false;
rec.handler(res);
}
}
/// <summary>
/// Constructs a toolbar from its JSON data.
/// </summary>
private Toolbar BuildToolbarFromData(object data, ToolbarBuildContext context)
{
JSObject toolbarElement = DataNodeWrapper.GetFirstChildNodeWithName(data, DataNodeWrapper.TOOLBAR);
if (CUIUtility.IsNullOrUndefined(toolbarElement))
{
throw new ArgumentNullException("No toolbar element was present in the data");
}
bool hasJewel = !CUIUtility.IsNullOrUndefined(DataNodeWrapper.GetFirstChildNodeWithName(data, DataNodeWrapper.JEWEL));
Toolbar = new Toolbar(
DataNodeWrapper.GetAttribute(toolbarElement, DataNodeWrapper.ID),
DataNodeWrapper.GetNodeAttributes(toolbarElement).To <ToolbarProperties>(),
this,
hasJewel);
Toolbar.ClientID = Options.ClientID;
Toolbar.UseDataCookie = true;
Toolbar.RefreshInternal(); // We need to refresh before we can attach the jewel.
if (hasJewel)
{
Toolbar.AttachAndBuildJewelFromData(data);
}
// Build the ButtonDocks (the Docks will build their subcontrols).
JSObject docks = DataNodeWrapper.GetFirstChildNodeWithName(toolbarElement, DataNodeWrapper.BUTTONDOCKS);
JSObject[] dockChildren = DataNodeWrapper.GetNodeChildren(docks);
for (int i = 0; i < dockChildren.Length; i++)
{
ButtonDock dock = BuildButtonDock(dockChildren[i], context);
Toolbar.AddChild(dock);
}
return(Toolbar);
}
/// <summary>
/// Attaches events to the DOMElements for the given display mode
/// </summary>
/// <param name="displayMode">The display mode to attach events for</param>
/// <owner alias="JKern" />
internal override void AttachEventsForDisplayMode(string displayMode)
{
Anchor elm = GetDisplayedDOMElement(displayMode);
if (CUIUtility.IsNullOrUndefined(elm))
{
return;
}
elm.Click += OnClick;
elm.Blur += OnBlur;
elm.KeyPress += OnKeyPress;
elm.Focus += OnTabFocus;
if (BrowserUtility.InternetExplorer)
{
if (displayMode.StartsWith("Menu"))
{
elm.MouseEnter += OnMouseenter;
elm.MouseLeave += OnMouseleave;
}
else
{
elm.MouseEnter += OnFocus;
elm.MouseLeave += OnBlur;
}
}
else
{
if (displayMode.StartsWith("Menu"))
{
elm.MouseOver += OnMouseover;
elm.MouseOut += OnMouseout;
}
else
{
elm.MouseOver += OnFocus;
elm.MouseOut += OnBlur;
}
}
}
/// <summary>
/// Method called when a Help Command is raised.
/// </summary>
/// <remarks>
/// This function checks that the raised command is indeed a help command and if so takes the
/// appropriate action.
/// </remarks>
/// <param name="commandId">The id of the executed command.</param>
/// <param name="properties">The properties of the executed command.</param>
/// <param name="sequence">The sequence number for the executed command.</param>
/// <returns>True if the command is handled.False otherwise.</returns>
/// <owner alias="HillaryM" />
public override bool HandleCommand(string commandId, Dictionary <string, string> properties, int sequence)
{
if (string.IsNullOrEmpty(commandId) ||
CUIUtility.IsNullOrUndefined(properties))
{
return(false);
}
if (commandId == HelpCommandNames.RequestContextualHelp)
{
HandlingCommand = true;
string helpKeyord = properties["HelpKeyword"];
Browser.Window.Alert("Unable to navigate to help at this time");
HandlingCommand = false;
}
else
{
// not recognized command
return(false);
}
return(true);
}
/// <summary>
/// Close this MenuLauncher's Menu.
/// </summary>
internal virtual void CloseMenu()
{
// There are cases where the Menu was closed by some other function, so this may get called more than once on one menu
if (!_menuLaunched)
{
return;
}
// Remove the menu floating div from the DOM
UIUtility.RemoveNode(_menu.ElementInternal);
if (!CUIUtility.IsNullOrUndefined(_elmBackFrame))
{
UIUtility.RemoveNode(_elmBackFrame);
}
_menu.OnMenuClosed();
// Now remove the Menu Component from the Ribbon Component Hierarchy
// TODO: should we remove this or leave it in the hierarchy?
// Perhaps remove it so that it could be added to a scaled other version of this control
Component parent = _menu.Parent;
parent.IgnoreDirtyingEvents = true;
parent.RemoveChild(_menu.Id);
parent.IgnoreDirtyingEvents = false;
_menuLaunched = false;
_menu.Launched = false;
Root.EndModal(this);
// Only return focus to ribbon if user closed menu using keyboard
if (!CUIUtility.IsNullOrUndefined(_elmHadFocus) && LaunchedByKeyboard)
{
_elmHadFocus.PerformFocus();
}
_elmHadFocus = null;
LaunchedByKeyboard = false;
OnLaunchedMenuClosed();
}
private void FocusOnAppropriateMenuItem(HtmlEvent evt)
{
if (CUIUtility.IsNullOrUndefined(_menu.SelectedMenuItem) && !CUIUtility.IsNullOrUndefined(_selectedControl))
{
Control ctl = (Control)_selectedControl;
ControlComponent dispComp = ctl.DisplayedComponent;
if (dispComp is MenuItem)
{
_menu.SelectedMenuItem = (MenuItem)dispComp;
}
}
// Let focus remain on triggering element if using jaws
// LaunchedByKeyboard true for onkeydown, not jaws onclick
if (LaunchedByKeyboard)
{
_menu.FocusOnFirstItem(evt);
}
else
{
// If nothing has been selected before then we auto-select the first item in some cases
MenuItem selectedItem = _menu.SelectedMenuItem;
if (!CUIUtility.IsNullOrUndefined(selectedItem))
{
// This auto selection only happens for ToggleButtons in DropDowns where one of the
// menu items represents the "currently selected item" in the DropDown.
// Currently selected font in a font dropdown for example.
Control selectedItemControl = selectedItem.Control;
if (selectedItemControl is ToggleButton && selectedItemControl is ISelectableControl)
{
ISelectableControl isc = (ISelectableControl)selectedItemControl;
if (!_menu.FocusOnItemById(isc.GetMenuItemId()))
{
_menu.FocusOnFirstItem(evt);
}
}
}
}
}
internal static string ConvertXMLStringToJSON(string xml)
{
XmlDocument document = new XmlDocument(xml);
if (CUIUtility.IsNullOrUndefined(document))
{
return(string.Empty);
}
if (document.ChildNodes.Length == 0)
{
return(string.Empty);
}
StringBuilder sb = new StringBuilder();
sb.Append("(");
sb.Append(ConvertNodeToJSON(document.ChildNodes[0]));
sb.Append(")");
return(sb.ToString());
}
/// <summary>
/// Checks whether any command handlers can accept the execution of a command.
/// </summary>
/// <param name="commandId">The id of the command that is being checked.</param>
/// <returns>Returns true if one or more command handlers can execute the command.</returns>
public bool IsCommandEnabled(string commandId)
{
List <ICommandHandler> handlers = GetHandlerRecordForCommand(commandId);
if (CUIUtility.IsNullOrUndefined(handlers))
{
return(false);
}
for (int i = 0; i < handlers.Count; i++)
{
ICommandHandler handler = (ICommandHandler)handlers[i];
// If at least one handler handles the command,
// then we return that the command is enabled
if (CallCommandHandlerForEnabled(handler, commandId))
{
return(true);
}
}
return(false);
}
/// <summary>
/// Builds the toolbar and attaches it to the page.
/// Called once the DataQuery completes and the toolbar data is available.
/// </summary>
private void OnReturnToolbarData(DataQueryResult res)
{
ToolbarBuildContext context = (ToolbarBuildContext)res.ContextData;
// Apply any extensions to the data.
res.QueryData = ApplyDataExtensions(res.QueryData);
Toolbar = BuildToolbarFromData(res.QueryData, context);
Toolbar.ToolbarBuilder = this;
BuildClient.OnComponentCreated(Toolbar, Toolbar.Id);
Toolbar.RefreshInternal();
Placeholder.AppendChild(Toolbar.ElementInternal);
// If there's a jewel on the toolbar, position the left buttondock adjacent to it
foreach (ButtonDock dock in Toolbar.Children)
{
if (dock.Alignment == DataNodeWrapper.LEFTALIGN)
{
Div jewelContainer = (Div)Browser.Document.GetById("jewelcontainer");
if (!CUIUtility.IsNullOrUndefined(jewelContainer))
{
if (Toolbar.TextDirection == Direction.LTR)
{
dock.ElementInternal.Style.Left = jewelContainer.OffsetWidth + "px";
}
else
{
dock.ElementInternal.Style.Right = jewelContainer.OffsetWidth + "px";
}
}
break;
}
}
Utility.EnsureCSSClassOnElement(Placeholder, "loaded");
BuildClient.OnComponentBuilt(Toolbar, Toolbar.Id);
}
internal void PositionToolTip()
{
HtmlElement flyOut = this.ElementInternal;
HtmlElement launcher = this.Parent.ElementInternal;
if (CUIUtility.IsNullOrUndefined(flyOut) || CUIUtility.IsNullOrUndefined(launcher))
{
return;
}
// Set temporary position on flyOut and get dimensions
flyOut.Style.Top = "0px";
flyOut.Style.Left = "0px";
Dictionary <string, int> d = Root.GetAllElementDimensions(flyOut, launcher);
int flyOutWidth = d["flyOutWidth"];
// check if launching control is within ribbon body
if ((Parent.ComponentTopPosition > Root.ComponentTopPosition) &&
((Parent.ComponentTopPosition + Parent.ComponentHeight) < (Root.ComponentTopPosition + Root.ComponentHeight)))
{
d["launcherTop"] = Root.ComponentTopPosition;
d["launcherHeight"] = Root.ComponentHeight;
}
else
{
// if the tooltip is launched within a menu, we offset it vertically and horizontally to prevent occluding menu items
int launcherTop = d["launcherTop"];
int launcherLeft = d["launcherLeft"];
launcherLeft += _tooltipHorizontalOffsetInMenus;
launcherTop += _tooltipVerticalOffsetInMenus;
d["launcherLeft"] = launcherLeft;
d["launcherTop"] = launcherTop;
}
Root.SetFlyOutCoordinates(flyOut, d, false);
// O14: 545739 - the setFlyoutCoordinates method sets the midwidth of the flyout. We don't want this set for tootips
flyOut.Style.MinWidth = flyOutWidth + "px";
}
/// <summary>
/// Starts timer that will launch tooltip if this control has focus for 500 ms.
/// </summary>
/// <owner alias="HillaryM" />
public virtual void OnBeginFocus()
{
Browser.Window.ClearInterval(Root.TooltipLauncherTimer);
// if there is currently an open tooltip and it was not launched by this control, close it
if (!CUIUtility.IsNullOrUndefined(Root.TooltipLauncher))
{
if (Root.TooltipLauncher.Id == this.Id)
{
// launch tooltip immediately (bug O14: 299699)
LaunchToolTip();
return;
}
else
{
Root.CloseOpenTootips();
Root.TooltipLauncherTimer = Browser.Window.SetTimeout(new Action(LaunchToolTip), 500);
}
}
else
{
Root.TooltipLauncherTimer = Browser.Window.SetTimeout(new Action(LaunchToolTip), 500);
}
}
private void AddTabsToRibbon(JSObject[] tabs, string contextualGroupId, RibbonBuildContext rbc)
{
bool shownTabsSpecified = !CUIUtility.IsNullOrUndefined(RibbonBuildOptions.ShownTabs);
for (int j = 0; j < tabs.Length; j++)
{
if (shownTabsSpecified)
{
// Only construct the tabs/tabheaders that have been made available
string tabId = DataNodeWrapper.GetAttribute(tabs[j], DataNodeWrapper.ID);
if (!string.IsNullOrEmpty(tabId))
{
if (!RibbonBuildOptions.ShownTabs.ContainsKey(tabId) ||
CUIUtility.IsNullOrUndefined(RibbonBuildOptions.ShownTabs[tabId]))
{
continue;
}
}
}
Tab tab = BuildTab(tabs[j], rbc, contextualGroupId);
Ribbon.AddChild(tab);
}
}
internal bool ExecuteCommandInternal(string commandId, Dictionary <string, string> properties, int sequenceNumber)
{
List <ICommandHandler> handlers = GetHandlerRecordForCommand(commandId);
if (CUIUtility.IsNullOrUndefined(handlers))
{
return(false);
}
bool success = false;
for (int i = 0; i < handlers.Count; i++)
{
ICommandHandler handler = (ICommandHandler)handlers[i];
// If at least one handler handles the command, then we return success
if (CallCommandHandler(handler, commandId, properties, sequenceNumber))
{
success = true;
}
}
return(success);
}
protected override void ReleaseEventHandlers()
{
if (!CUIUtility.IsNullOrUndefined(_elmLarge))
{
RemoveEvents(_elmLarge, true);
}
if (!CUIUtility.IsNullOrUndefined(_elmMedium))
{
RemoveEvents(_elmMedium, true);
}
if (!CUIUtility.IsNullOrUndefined(_elmSmall))
{
RemoveEvents(_elmSmall, true);
}
if (!CUIUtility.IsNullOrUndefined(_elmMenu32))
{
RemoveEvents(_elmMenu32, false);
}
if (!CUIUtility.IsNullOrUndefined(_elmMenu16))
{
RemoveEvents(_elmMenu16, false);
}
}
protected void OnMenuButtonClick(HtmlEvent args)
{
if (CUIUtility.IsNullOrUndefined(args))
{
return;
}
Utility.CancelEventUtility(args, false, true);
CloseToolTip();
if (!Enabled || !_menuButtonEnabled)
{
return;
}
Root.FixedPositioningEnabled = false;
Root.LastCommittedControl = this;
focusOnArrow = true;
HtmlElement prev = args.TargetElement;
LaunchMenu(prev);
DisplayedComponent.RaiseCommandEvent(Properties.CommandMenuOpen, CommandType.MenuCreation, null);
}
protected override void OnClick(HtmlEvent evt)
{
CloseToolTip();
Utility.CancelEventUtility(evt, false, true);
if (!Enabled)
{
return;
}
Toggle();
CommandType ct = CommandType.General;
string cmdtpe = Properties.CommandType;
Dictionary <string, string> dict = StateProperties;
dict[GalleryButtonCommandProperties.CommandValueId] = Properties.CommandValueId;
dict["MenuItemId"] = Properties.MenuItemId;
dict["SourceControlId"] = Properties.Id;
if (!CUIUtility.IsNullOrUndefined(cmdtpe) && cmdtpe == "OptionSelection")
{
ct = CommandType.OptionSelection;
}
DisplayedComponent.RaiseCommandEvent(Properties.Command,
ct,
dict);
if (Root.PollForState)
{
PollForStateAndUpdate();
}
else
{
SetState(Utility.IsTrue(StateProperties[GalleryButtonCommandProperties.On]));
}
}
public bool BuildRibbonAndInitialTab(string initialTabId)
{
if (string.IsNullOrEmpty(initialTabId))
{
throw new ArgumentNullException("Initial tab for ribbon is null or undefined");
}
if (InQuery)
{
return(false);
}
RibbonBuildContext rbc = new RibbonBuildContext();
rbc.InitialTabId = initialTabId;
// If this is server rendered, then we want to set and use the initial
// scaling index for this first tab.
if (!CUIUtility.IsNullOrUndefined(RibbonBuildOptions.AttachToDOM) &&
RibbonBuildOptions.AttachToDOM)
{
rbc.InitialScalingIndex = this.RibbonBuildOptions.InitialScalingIndex;
}
InQuery = true;
DataQuery query = new DataQuery();
query.TabQuery = false;
query.Id = rbc.InitialTabId;
query.QueryType = DataQueryType.RibbonVisibleTabDeep;
query.Handler = new DataReturnedEventHandler(OnReturnRibbonAndInitialTab);
query.Data = rbc;
DataSource.RunQuery(query);
return(true);
}
public override void OnBeginFocus()
{
string dictKey = DropDownCommandProperties.Value;
string selectedItemTitle = StateProperties.ContainsKey(dictKey) ? StateProperties[dictKey] : "";
if (string.IsNullOrEmpty(selectedItemTitle))
{
// get currently selected item ID
string itemKey = DropDownCommandProperties.SelectedItemId;
string currentSelectedItemId = StateProperties.ContainsKey(itemKey) ? StateProperties[itemKey] : "";
// If we currently don't have an item set, then we set it here to let the application know
// since this is what we'll fall back to unless they set something else.
if (string.IsNullOrEmpty(currentSelectedItemId))
{
currentSelectedItemId = Properties.InitialItem;
}
// get the title of the selected item
// The Menu can be null if this control's menu gets populated dynamically
if ((!string.IsNullOrEmpty(currentSelectedItemId)) &&
(!CUIUtility.IsNullOrUndefined(Menu)))
{
ISelectableControl isc = Menu.GetItemById(currentSelectedItemId);
if (!CUIUtility.IsNullOrUndefined(isc))
{
selectedItemTitle = isc.GetTextValue();
}
}
}
if (!string.IsNullOrEmpty(selectedItemTitle))
{
Properties.ToolTipSelectedItemTitle = selectedItemTitle;
}
base.OnBeginFocus();
}
protected override void OnClick(HtmlEvent args)
{
if (!CUIUtility.IsNullOrUndefined(typeof(PMetrics)))
{
PMetrics.PerfMark(PMarker.perfCUIRibbonButtonOnClickStart);
}
Utility.CancelEventUtility(args, true, true);
CloseToolTip();
if (!Enabled)
{
return;
}
Root.LastCommittedControl = this;
CommandType ct = CommandType.General;
Dictionary <string, string> dict = this.StateProperties;
string cmdtpe = Properties.CommandType;
if (!string.IsNullOrEmpty(cmdtpe) && cmdtpe == "OptionSelection")
{
ct = CommandType.OptionSelection;
}
dict["CommandValueId"] = this._commandValueId;
dict["MenuItemId"] = this._menuItemId;
dict["SourceControlId"] = this.Id;
DisplayedComponent.RaiseCommandEvent(Properties.Command,
ct,
dict);
if (!CUIUtility.IsNullOrUndefined(typeof(PMetrics)))
{
PMetrics.PerfMark(PMarker.perfCUIRibbonButtonOnClickEnd);
}
}
internal override bool FocusNext(HtmlEvent evt)
{
if (_focusedIndex == -1)
{
_focusedIndex = 0;
}
int i = _focusedIndex;
while (i < Children.Count)
{
Component comp = Children[i];
if (comp.FocusNext(evt))
{
// If focus is not moving, don't reset the focus of the menu item
if (i != _focusedIndex)
{
if (!CUIUtility.IsNullOrUndefined(Children[_focusedIndex]))
{
((Component)Children[_focusedIndex]).ResetFocusedIndex();
}
_focusedIndex = i;
}
return(true);
}
i++;
}
if (Children.Count > 0)
{
((Component)Children[_focusedIndex]).ResetFocusedIndex();
}
_focusedIndex = -1;
return(false);
}