/// <summary> /// Constructor. /// </summary> public MouseButtonMessage(Point location, XMouseButtons mouseButton, ButtonActions buttonAction, uint clickCount, ModifierFlags modifierFlags) : this(location, mouseButton, buttonAction, clickCount, (modifierFlags & ModifierFlags.Control) == ModifierFlags.Control, (modifierFlags & ModifierFlags.Alt) == ModifierFlags.Alt, (modifierFlags & ModifierFlags.Shift) == ModifierFlags.Shift) { }
/// <summary> /// Initializes a new instance of the <see cref="MemberOrderHelper"/> struct. /// </summary> /// <param name="member">The member to wrap.</param> public MemberOrderHelper(MemberDeclarationSyntax member) { this.Member = member; var modifiers = member.GetModifiers(); this.modifierFlags = GetModifierFlags(modifiers); this.accessibilty = AccessLevelHelper.GetAccessLevel(modifiers); }
/// <summary> /// Initializes a new instance of the <see cref="MemberOrderHelper"/> struct. /// </summary> /// <param name="member">The member to wrap.</param> /// <param name="checks">The element ordering checks.</param> internal MemberOrderHelper(MemberDeclarationSyntax member, ElementOrderingChecks checks) { this.Member = member; var modifiers = member.GetModifiers(); var type = member.Kind(); type = type == SyntaxKind.EventFieldDeclaration ? SyntaxKind.EventDeclaration : type; this.elementPriority = checks.ElementType ? TypeMemberOrder.IndexOf(type) : 0; this.modifierFlags = GetModifierFlags(modifiers, checks); if (checks.AccessLevel) { if ((type == SyntaxKind.ConstructorDeclaration && this.modifierFlags.HasFlag(ModifierFlags.Static)) || (type == SyntaxKind.MethodDeclaration && ((MethodDeclarationSyntax)member).ExplicitInterfaceSpecifier != null) || (type == SyntaxKind.PropertyDeclaration && ((PropertyDeclarationSyntax)member).ExplicitInterfaceSpecifier != null) || (type == SyntaxKind.IndexerDeclaration && ((IndexerDeclarationSyntax)member).ExplicitInterfaceSpecifier != null)) { this.accessibilty = AccessLevel.Public; } else { this.accessibilty = AccessLevelHelper.GetAccessLevel(modifiers); if (this.accessibilty == AccessLevel.NotSpecified) { if (member.Parent.IsKind(SyntaxKind.CompilationUnit) || member.Parent.IsKind(SyntaxKind.NamespaceDeclaration)) { this.accessibilty = AccessLevel.Internal; } else { this.accessibilty = AccessLevel.Private; } } } } else { this.accessibilty = AccessLevel.Public; } }
public void Deconstruct(out double x, out double y, out ModifierFlags modifier) { x = X; y = Y; modifier = Modifier; }
/// <summary> /// Initializes a new instance of the <see cref="InputArgs"/> struct. /// </summary> /// <param name="x">The input X position.</param> /// <param name="y">The input Y position.</param> /// <param name="modifier">The input modifier flags.</param> public InputArgs(double x, double y, ModifierFlags modifier) { this.X = x; this.Y = y; this.Modifier = modifier; }
/// <summary> /// Constructor that accepts <see cref="ModifierFlags"/> as input. /// </summary> /// <param name="modifiers"></param> public MouseWheelHandlerAttribute(ModifierFlags modifiers) { _shortcut = new MouseWheelShortcut(modifiers); }
public static bool HasModifier(INode node, ModifierFlags flags) { return((GetModifierFlags(node) & flags) != 0); }
private static string GetName(ModifierFlags value, IDictionary<ModifierFlags, string> map) { if (map.ContainsKey(value)) return map[value]; else if (Enum.IsDefined(typeof (ModifierFlags), (int) value)) return Enum.GetName(typeof (ModifierFlags), (int) value); return string.Empty; }
public static ModifierFlags GetModifierFlags(this MemberDeclarationSyntax member) { ModifierFlags result = 0; foreach (var modifier in member.GetModifiers()) { switch (modifier.Kind()) { case SyntaxKind.PublicKeyword: result |= ModifierFlags.Public; break; case SyntaxKind.ProtectedKeyword: result |= ModifierFlags.Protected; break; case SyntaxKind.InternalKeyword: result |= ModifierFlags.Internal; break; case SyntaxKind.PrivateKeyword: result |= ModifierFlags.Private; break; case SyntaxKind.VirtualKeyword: result |= ModifierFlags.Virtual; break; case SyntaxKind.AbstractKeyword: result |= ModifierFlags.Abstract; break; case SyntaxKind.NewKeyword: result |= ModifierFlags.New; break; case SyntaxKind.OverrideKeyword: result |= ModifierFlags.Override; break; case SyntaxKind.SealedKeyword: result |= ModifierFlags.Sealed; break; case SyntaxKind.StaticKeyword: result |= ModifierFlags.Static; break; case SyntaxKind.ExternKeyword: result |= ModifierFlags.Extern; break; case SyntaxKind.ReadOnlyKeyword: result |= ModifierFlags.ReadOnly; break; case SyntaxKind.ConstKeyword: result |= ModifierFlags.Const; break; case SyntaxKind.VolatileKeyword: result |= ModifierFlags.Volatile; break; case SyntaxKind.UnsafeKeyword: result |= ModifierFlags.Unsafe; break; case SyntaxKind.AsyncKeyword: result |= ModifierFlags.Async; break; case SyntaxKind.PartialKeyword: result |= ModifierFlags.Partial; break; } } return(result); }
private void AssertEquivalency(string sModifiers, ModifierFlags eModifiers, CultureInfo culture, string message) { AssertStringFormat(sModifiers, eModifiers, culture, message); AssertStringParse(sModifiers, eModifiers, culture, message); }
/// <summary> /// Constructor. /// </summary> public DefaultMouseToolButtonAttribute(XMouseButtons mouseButton, ModifierFlags modifierFlags) { _shortcut = new MouseButtonShortcut(mouseButton, modifierFlags); }
protected virtual void OnGlobalMouseButtonComboShortcutChanged() { this.NotifyPropertyChanged("GlobalMouseButtonCombo"); this.GlobalMouseButtons = _globalMouseButtonCombo.MouseButtons; this.GlobalModifiers = _globalMouseButtonCombo.Modifiers; }
protected override DragDropOption CheckDropLocalItems(IList <IGalleryItem> droppingItems, int targetIndex, DragDropOption actions, ModifierFlags modifiers) { DragDropOption allowedActions = base.CheckDropLocalItems(droppingItems, targetIndex, actions, modifiers); if (allowedActions == DragDropOption.None && modifiers == ModifierFlags.Shift) { bool allow = true; foreach (IGalleryItem droppingItem in droppingItems) { if (!(droppingItem is IStudyComposerItem)) { allow &= false; } } if (allow) { return(DragDropOption.Copy); } } return(allowedActions); }
protected override DragDropOption PerformDropLocalItems(IList <IGalleryItem> droppedItems, int targetIndex, DragDropOption actions, ModifierFlags modifiers) { DragDropOption performedActions = base.PerformDropLocalItems(droppedItems, targetIndex, actions, modifiers); if (performedActions == DragDropOption.None && modifiers == ModifierFlags.Shift) { bool allow = true; foreach (IGalleryItem droppedItem in droppedItems) { if (droppedItem is IStudyComposerItem) { IStudyComposerItem item = (IStudyComposerItem)droppedItem; base.DataSource.Insert(targetIndex, item.Clone()); } } performedActions = DragDropOption.Copy; } return(performedActions); }
protected override DragDropOption PerformDropForeignItems(IList <IGalleryItem> droppingItems, IGalleryItem targetItem, DragDropOption actions, ModifierFlags modifiers) { SeriesItem series = (SeriesItem)targetItem; DragDropOption action = DragDropOption.None; foreach (IGalleryItem droppingItem in droppingItems) { if (droppingItem is ImageItem) { ImageItem image = (ImageItem)droppingItem; if (modifiers == ModifierFlags.None) { if (!series.Images.Contains(image)) { series.Images.Add(image.Copy()); action = DragDropOption.Move; } } else if (modifiers == ModifierFlags.Shift) { series.Images.Add(image.Copy()); action = DragDropOption.Copy; } } } return(action); }
protected override DragDropOption CheckDropForeignItems(IList <IGalleryItem> droppingItems, IGalleryItem targetItem, DragDropOption actions, ModifierFlags modifiers) { SeriesItem series = (SeriesItem)targetItem; bool allowed = true; foreach (IGalleryItem droppingItem in droppingItems) { if (droppingItem is ImageItem) { ImageItem image = (ImageItem)droppingItem; if (modifiers == ModifierFlags.None) { allowed &= !(series.Images.Contains(image)); // disallow moves where the item is already in the target tree } else if (modifiers == ModifierFlags.Shift) { allowed &= true; } } else { allowed &= false; } } if (allowed) { if (modifiers == ModifierFlags.None) { return(DragDropOption.Move); } else if (modifiers == ModifierFlags.Shift) { return(DragDropOption.Copy); } } return(DragDropOption.None); }
protected override DragDropOption PerformDropForeignItems(IList <IGalleryItem> droppingItems, IGalleryItem targetItem, DragDropOption actions, ModifierFlags modifiers) { StudyItem study = (StudyItem)targetItem; DragDropOption action = DragDropOption.None; foreach (IGalleryItem droppingItem in droppingItems) { if (droppingItem is SeriesItem) { SeriesItem series = (SeriesItem)droppingItem; if (modifiers == ModifierFlags.None) { if (!study.Series.Contains(series)) { study.Series.Add(series.Copy()); action = DragDropOption.Move; } } else if (modifiers == ModifierFlags.Shift) { study.Series.Add(series.Copy()); action = DragDropOption.Copy; } } else if (droppingItem is ImageItem) { ImageItem image = (ImageItem)droppingItem; if (modifiers == ModifierFlags.None) { SeriesNode seriesNode = (SeriesNode)GetNodeAncestor(image.Node, 1); StudyNode studyNode = (StudyNode)GetNodeAncestor(seriesNode, 1); if (study.Node != studyNode) { SeriesItem series = new SeriesItem(seriesNode.Copy(false)); series.Images.Add(image.Copy()); series.UpdateIcon(); study.Series.Add(series); action = DragDropOption.Move; } } else if (modifiers == ModifierFlags.Shift) { SeriesNode seriesNode = (SeriesNode)GetNodeAncestor(image.Node, 1); SeriesItem series = new SeriesItem(seriesNode.Copy(false)); series.Images.Add(image.Copy()); series.UpdateIcon(); study.Series.Add(series); action = DragDropOption.Copy; } } } return(action); }
public ActionControl AddBinding(Binding b, ModifierFlags flags) { bindings.Add(b, flags); return(this); }
public MouseImageViewerToolPropertyComponent(AbstractActionModelTreeNode selectedNode, XMouseButtons activeMouseButtons, XMouseButtons globalMouseButtons, ModifierFlags globalModifiers, bool initiallyActive) : base(selectedNode) { _activeMouseButtons = activeMouseButtons; _globalMouseButtonCombo = new XMouseButtonCombo(globalMouseButtons, globalModifiers); _globalMouseButtons = globalMouseButtons; _globalModifiers = globalModifiers; _initiallyActive = initiallyActive; }
protected override IVariableDeclarationModel InstantiateVariableDeclaration(Type variableTypeToCreate, TypeHandle variableDataType, string variableName, ModifierFlags modifierFlags, bool isExposed, IConstant initializationModel, SerializableGUID guid, Action <IVariableDeclarationModel, IConstant> initializationCallback = null) { var vdm = base.InstantiateVariableDeclaration(variableTypeToCreate, variableDataType, variableName, modifierFlags, isExposed, initializationModel, guid, initializationCallback); if (vdm is VariableDeclarationModel testVdm) { testVdm.SetGraphModel(this); } return(vdm); }
/// <summary> /// Formats a <see cref="ModifierFlags"/> value as a string using the <see cref="CultureInfo.CurrentUICulture">current thread's UI CultureInfo</see>. /// </summary> /// <param name="value">The <see cref="ModifierFlags"/> value to be formatted.</param> /// <returns>The string representation of the given <paramref name="value"/>.</returns> public static string Format(ModifierFlags value) { return(Format(value, CultureInfo.CurrentUICulture)); }
public CreateGraphVariableDeclarationAction(string name, bool isExposed, TypeHandle typeHandle, ModifierFlags modifierFlags = ModifierFlags.None) { Name = name; IsExposed = isExposed; TypeHandle = typeHandle; ModifierFlags = modifierFlags; }
private void AssertStringParse(string sModifiers, ModifierFlags eModifiers, CultureInfo culture, string message) { ModifierFlags actualEnum = (ModifierFlags) _converter.ConvertFromString(null, culture, sModifiers); //System.Diagnostics.Trace.WriteLine(actualEnum); Assert.AreEqual((int) eModifiers, (int) actualEnum, message + ": converting " + sModifiers + " which is " + actualEnum.ToString()); }
/// <summary> /// Initializes an <see cref="XMouseButtonCombo"/> with the specified pressed mouse buttons. /// </summary> /// <param name="mouseButtons">The pressed mouse buttons.</param> public XMouseButtonCombo(XMouseButtons mouseButtons) { _mouseButtons = mouseButtons; _modifiers = ModifierFlags.None; }
/// <summary> /// Constructor that takes a <see cref="ModifierFlags"/> as input. /// </summary> public Modifiers(ModifierFlags modifierFlags) { _modifierFlags = modifierFlags; }
/// <summary> /// Initializes an <see cref="XMouseButtonCombo"/> with the specified pressed mouse buttons. /// </summary> /// <param name="mouseButtons">The pressed mouse buttons.</param> /// <param name="modifiers">The pressed keyboard modifiers.</param> public XMouseButtonCombo(XMouseButtons mouseButtons, ModifierFlags modifiers) { _mouseButtons = mouseButtons; _modifiers = mouseButtons != XMouseButtons.None ? modifiers : ModifierFlags.None; }
/// <summary> /// Performs a drag-drop of a non-<see cref="IGalleryItem"/> object from outside this gallery on top of the specified item. /// </summary> /// <param name="droppedData">The data object to drop.</param> /// <param name="targetItem">The target <see cref="IGalleryItem"/> at which the <paramref name="droppedData"/> is being dropped.</param> /// <param name="actions">The interaction to take.</param> /// <param name="modifiers">The modifier keys that were pressed at the time of the drop.</param> /// <returns>The actual interaction on the <paramref name="droppedData"/> that was taken.</returns> protected virtual DragDropOption PerformDropForeignObject(IDragDropObject droppedData, IGalleryItem targetItem, DragDropOption actions, ModifierFlags modifiers) { return(DragDropOption.None); }
/// <summary> /// Constructor. /// </summary> public MouseButtonShortcut(XMouseButtons mouseButton, ModifierFlags modifierFlags) : this(mouseButton, new Modifiers(modifierFlags)) { }
public void Deconstruct(out double x, out double y, out ModifierFlags modifier) { x = this.X; y = this.Y; modifier = this.Modifier; }
/// <summary> /// 根据枚举来指定特殊修饰符 /// </summary> /// <param name="modifierEnum">特殊修饰符枚举</param> /// <returns></returns> public T Modifier(ModifierFlags modifierEnum) { _status.Add(modifierEnum); return(Link); }
/// <summary> /// Initializes a new instance of the <see cref="InputArgs"/> struct. /// </summary> /// <param name="x">The input X position.</param> /// <param name="y">The input Y position.</param> /// <param name="modifier">The input modifier flags.</param> public InputArgs(double x, double y, ModifierFlags modifier) { X = x; Y = y; Modifier = modifier; }
/// <summary> /// Checks for allowed drag & drop actions involving the specified foreign data and the given target on this component. /// </summary> /// <param name="droppingData">The <see cref="IDragDropObject"/> object that encapsulates all forms of the foreign data.</param> /// <param name="targetItem">The target item that the user is trying to drop on to.</param> /// <param name="actions"></param> /// <param name="modifiers">The modifier keys that are being held by the user.</param> /// <returns>The allowed <see cref="DragDropKind"/> action for this attempted drag & drop operation.</returns> public override sealed DragDropOption CheckDrop(IDragDropObject droppingData, IGalleryItem targetItem, DragDropOption actions, ModifierFlags modifiers) { DragDropOption allowedActions; IList<IGalleryItem> droppingItems = ExtractGalleryItemList(droppingData); if (droppingItems != null) { if (_draggedItems == droppingItems) { allowedActions = CheckDropLocalItems(droppingItems, targetItem, actions, modifiers); } else { allowedActions = CheckDropForeignItems(droppingItems, targetItem, actions, modifiers); } } else { allowedActions = CheckDropForeignObject(droppingData, targetItem, actions, modifiers); } return actions & allowedActions; }
public static MemberDeclarationSyntax UpdateModifiers(this MemberDeclarationSyntax member, ModifierFlags flags) { // The starting token for this member may change, so we need to save // the leading trivia and reattach it after updating the modifiers. // We also need to remove it here to avoid duplicates. var leadingTrivia = member.GetLeadingTrivia(); member = member.WithLeadingTrivia(SyntaxTriviaList.Empty); var newModifierList = new List<SyntaxToken>(); foreach (var modifierDefinition in s_modifierDefinitions) { if ((flags & modifierDefinition.Key) != 0) { newModifierList.Add(SyntaxFactory.Token(modifierDefinition.Value)); } } var newModifiers = SyntaxFactory.TokenList(newModifierList); var newMember = (MemberDeclarationSyntax)member.WithModifiers(SyntaxFactory.TokenList(newModifierList)); return newMember.WithLeadingTrivia(leadingTrivia); }
/// <summary> /// /// </summary> /// <param name="droppedData"></param> /// <param name="targetItem"></param> /// <param name="action"></param> /// <param name="modifiers"></param> /// <returns></returns> public override sealed DragDropOption PerformDrop(IDragDropObject droppedData, IGalleryItem targetItem, DragDropOption action, ModifierFlags modifiers) { DragDropOption performedAction; IList<IGalleryItem> droppedItems = ExtractGalleryItemList(droppedData); if (droppedItems != null) { if (_draggedItems == droppedItems) { performedAction = PerformDropLocalItems(droppedItems, targetItem, action, modifiers); } else { performedAction = PerformDropForeignItems(droppedItems, targetItem, action, modifiers); } } else { performedAction = PerformDropForeignObject(droppedData, targetItem, action, modifiers); } return performedAction; }
/// <summary> /// Checks if drag-dropping <see cref="IGalleryItem"/>s from within this gallery to the specified target index is allowed. /// </summary> /// <param name="droppingItems">The list of <see cref="IGalleryItem"/>s to drop.</param> /// <param name="targetIndex">The target index at which the <paramref name="droppingItems"/> are being dropped.</param> /// <param name="actions">The interactions that are being allowed by the data source.</param> /// <param name="modifiers">The modifier keys that currently being pressed.</param> /// <returns>The allowed interactions for dropping the <paramref name="droppingItems"/> here.</returns> protected virtual DragDropOption CheckDropLocalItems(IList<IGalleryItem> droppingItems, int targetIndex, DragDropOption actions, ModifierFlags modifiers) { DragDropOption allowedActions = DragDropOption.None; if (modifiers == ModifierFlags.None) { // check for null drops and drops to a point within the source data if (droppingItems.Count == 0) return DragDropOption.None; int draggedIndex = base.DataSource.IndexOf(droppingItems[0]); if (targetIndex >= draggedIndex && targetIndex < draggedIndex + droppingItems.Count) return DragDropOption.None; // we are dragging an item, and the item we want to drop is the same as that which we are dragging // then this is a reordering operation allowedActions = actions & DragDropOption.Move; } return allowedActions; }
public static MemberDeclarationSyntax UpdateModifiers(this MemberDeclarationSyntax member, ModifierFlags flags) { // The starting token for this member may change, so we need to save // the leading trivia and reattach it after updating the modifiers. // We also need to remove it here to avoid duplicates. var leadingTrivia = member.GetLeadingTrivia(); member = member.WithLeadingTrivia(SyntaxTriviaList.Empty); var newModifierList = new List <SyntaxToken>(); foreach (var modifierDefinition in s_modifierDefinitions) { if ((flags & modifierDefinition.Key) != 0) { newModifierList.Add(SyntaxFactory.Token(modifierDefinition.Value)); } } var newModifiers = SyntaxFactory.TokenList(newModifierList); var newMember = (MemberDeclarationSyntax)member.WithModifiers(SyntaxFactory.TokenList(newModifierList)); return(newMember.WithLeadingTrivia(leadingTrivia)); }
/// <summary> /// Checks if drag-dropping <see cref="IGalleryItem"/>s from outside this gallery to the specified target index is allowed. /// </summary> /// <param name="droppingItems">The list of <see cref="IGalleryItem"/>s to drop.</param> /// <param name="targetIndex">The target index at which the <paramref name="droppingItems"/> are being dropped.</param> /// <param name="actions">The interactions that are being allowed by the data source.</param> /// <param name="modifiers">The modifier keys that currently being pressed.</param> /// <returns>The allowed interactions for dropping the <paramref name="droppingItems"/> here.</returns> protected virtual DragDropOption CheckDropForeignItems(IList<IGalleryItem> droppingItems, int targetIndex, DragDropOption actions, ModifierFlags modifiers) { return DragDropOption.None; }
/// <summary> /// Creates a new variable declaration in the graph. /// </summary> /// <param name="self">The graph to add a variable declaration to.</param> /// <param name="variableDataType">The type of data the new variable declaration to create represents.</param> /// <param name="variableName">The name of the new variable declaration to create.</param> /// <param name="modifierFlags">The modifier flags of the new variable declaration to create.</param> /// <param name="isExposed">Whether the variable is exposed externally or not.</param> /// <param name="initializationModel">The initialization model of the new variable declaration to create. Can be <code>null</code>.</param> /// <param name="guid">The SerializableGUID to assign to the newly created item.</param> /// <param name="initializationCallback">An initialization method to be called right after the variable declaration is created.</param> /// <param name="spawnFlags">The flags specifying how the variable declaration is to be spawned.</param> /// <typeparam name="TDeclType">The type of variable declaration to create.</typeparam> /// <returns>The newly created variable declaration.</returns> public static TDeclType CreateGraphVariableDeclaration <TDeclType>(this IGraphModel self, TypeHandle variableDataType, string variableName, ModifierFlags modifierFlags, bool isExposed, IConstant initializationModel = null, SerializableGUID guid = default, Action <TDeclType, IConstant> initializationCallback = null, SpawnFlags spawnFlags = SpawnFlags.Default) where TDeclType : class, IVariableDeclarationModel { return((TDeclType)self.CreateGraphVariableDeclaration(typeof(TDeclType), variableDataType, variableName, modifierFlags, isExposed, initializationModel, guid, (d, c) => initializationCallback?.Invoke((TDeclType)d, c), spawnFlags)); }
/// <summary> /// Checks if drag-dropping <see cref="IGalleryItem"/>s from within this gallery on top of the specified item is allowed. /// </summary> /// <param name="droppingItems">The list of <see cref="IGalleryItem"/>s to drop.</param> /// <param name="targetItem">The target <see cref="IGalleryItem"/> at which the <paramref name="droppingItems"/> are being dropped.</param> /// <param name="actions">The interactions that are being allowed by the data source.</param> /// <param name="modifiers">The modifier keys that currently being pressed.</param> /// <returns>The allowed interactions for dropping the <paramref name="droppingItems"/> here.</returns> protected virtual DragDropOption CheckDropLocalItems(IList<IGalleryItem> droppingItems, IGalleryItem targetItem, DragDropOption actions, ModifierFlags modifiers) { return DragDropOption.None; }
public ActionControl AddBinding(Binding b, ModifierFlags flags) { bindings.Add(b, flags); return this; }
/// <summary> /// Formats a <see cref="ModifierFlags"/> value as a string using the <see cref="CultureInfo.CurrentUICulture">current thread's UI CultureInfo</see>. /// </summary> /// <param name="value">The <see cref="ModifierFlags"/> value to be formatted.</param> /// <returns>The string representation of the given <paramref name="value"/>.</returns> public static string Format(ModifierFlags value) { return Format(value, CultureInfo.CurrentUICulture); }
private void AssertStringFormat(string sModifiers, ModifierFlags eModifiers, CultureInfo culture, string message) { string actualString = _converter.ConvertToString(null, culture, eModifiers); //System.Diagnostics.Trace.WriteLine(actualString); Assert.AreEqual(sModifiers, actualString, message + ": converting " + (int) eModifiers + " which is " + eModifiers.ToString()); }
/// <summary> /// Formats a <see cref="ModifierFlags"/> value as a string using the <see cref="CultureInfo.InvariantCulture"/>. /// </summary> /// <param name="value">The <see cref="ModifierFlags"/> value to be formatted.</param> /// <returns>The string representation of the given <paramref name="value"/>.</returns> public static string FormatInvariant(ModifierFlags value) { return Format(value, CultureInfo.InvariantCulture); }
/// <summary> /// Constructor. /// </summary> public ModifiedMouseToolButtonAttribute(XMouseButtons mouseButton, ModifierFlags modifierFlags) : base(mouseButton, modifierFlags) { }
/// <summary> /// Parses a string as an <see cref="ModifierFlags"/> value using the specified <see cref="CultureInfo"/>. /// </summary> /// <param name="s">The string to be parsed.</param> /// <param name="culture">The <see cref="CultureInfo"/> for which the string should be parsed.</param> /// <param name="result">The <see cref="ModifierFlags"/> value parsed from <paramref name="s"/> if the string was successfully parsed; <see cref="ModifierFlags.None"/> otherwise.</param> /// <returns>True if the string was successfully parsed; False otherwise.</returns> public static bool TryParse(string s, CultureInfo culture, out ModifierFlags result) { try { result = Parse(s, culture); return true; } catch (FormatException) { result = ModifierFlags.None; return false; } }
/// <summary> /// Performs a drag-drop of <see cref="IGalleryItem"/>s from within this gallery to the specified target index. /// </summary> /// <param name="droppedItems">The list of <see cref="IGalleryItem"/>s to drop.</param> /// <param name="targetIndex">The target index at which the <paramref name="droppedItems"/> are being dropped.</param> /// <param name="actions">The interaction to take.</param> /// <param name="modifiers">The modifier keys that were pressed at the time of the drop.</param> /// <returns>The actual interaction on the <paramref name="droppedItems"/> that was taken.</returns> protected virtual DragDropOption PerformDropLocalItems(IList<IGalleryItem> droppedItems, int targetIndex, DragDropOption actions, ModifierFlags modifiers) { DragDropOption performedAction = DragDropOption.None; if (modifiers == ModifierFlags.None) { // check for null drops and drops to a point within the source data if (droppedItems.Count == 0) return DragDropOption.None; int draggedIndex = base.DataSource.IndexOf(droppedItems[0]); if (targetIndex >= draggedIndex && targetIndex < draggedIndex + droppedItems.Count) return DragDropOption.None; // we are dragging something, and the item we want to drop is the same as that which we are dragging // then this is a reordering operation if (droppedItems != this.DraggedItems) return DragDropOption.None; if (draggedIndex < targetIndex) targetIndex -= droppedItems.Count; Stack<IGalleryItem> stack = new Stack<IGalleryItem>(); foreach (IGalleryItem droppedItem in droppedItems) { base.DataSource.Remove(droppedItem); stack.Push(droppedItem); } while (stack.Count > 0) { base.DataSource.Insert(targetIndex, stack.Pop()); } this.DraggedItems = null; performedAction = DragDropOption.Move; } return performedAction; }
/// <summary> /// Gets whether or not this object is equal to <paramref name="other"/>. /// </summary> public bool Equals(ModifierFlags other) { return(this.ModifierFlags == other); }
/// <summary> /// Formats a <see cref="ModifierFlags"/> value as a string using the specified <see cref="CultureInfo"/>. /// </summary> /// <param name="value">The <see cref="ModifierFlags"/> value to be formatted.</param> /// <param name="culture">The <see cref="CultureInfo"/> for which the value should be formatted.</param> /// <returns>The string representation of the given <paramref name="value"/>.</returns> public static string Format(ModifierFlags value, CultureInfo culture) { return Default.ConvertToString(null, culture, value); }
/// <summary> /// Performs a drag-drop of a non-<see cref="IGalleryItem"/> object from outside this gallery to the specified index. /// </summary> /// <param name="droppedData">The data object to drop.</param> /// <param name="targetIndex">The target index at which the <paramref name="droppedData"/> is being dropped.</param> /// <param name="actions">The interaction to take.</param> /// <param name="modifiers">The modifier keys that were pressed at the time of the drop.</param> /// <returns>The actual interaction on the <paramref name="droppedData"/> that was taken.</returns> protected virtual DragDropOption PerformDropForeignObject(IDragDropObject droppedData, int targetIndex, DragDropOption actions, ModifierFlags modifiers) { return DragDropOption.None; }
/// <summary> /// Parses a string as an <see cref="ModifierFlags"/> value using the <see cref="CultureInfo.CurrentUICulture">current thread's UI CultureInfo</see>. /// </summary> /// <param name="s">The string to be parsed.</param> /// <param name="result">The <see cref="ModifierFlags"/> value parsed from <paramref name="s"/> if the string was successfully parsed; <see cref="ModifierFlags.None"/> otherwise.</param> /// <returns>True if the string was successfully parsed; False otherwise.</returns> public static bool TryParse(string s, out ModifierFlags result) { return TryParse(s, CultureInfo.CurrentUICulture, out result); }
/// <summary> /// Performs a drag-drop of <see cref="IGalleryItem"/>s from outside this gallery on top of the specified item. /// </summary> /// <param name="droppedItems">The list of <see cref="IGalleryItem"/>s to drop.</param> /// <param name="targetItem">The target <see cref="IGalleryItem"/> at which the <paramref name="droppedItems"/> are being dropped.</param> /// <param name="actions">The interaction to take.</param> /// <param name="modifiers">The modifier keys that were pressed at the time of the drop.</param> /// <returns>The actual interaction on the <paramref name="droppedItems"/> that was taken.</returns> protected virtual DragDropOption PerformDropForeignItems(IList<IGalleryItem> droppedItems, IGalleryItem targetItem, DragDropOption actions, ModifierFlags modifiers) { return DragDropOption.None; }
/// <summary> /// Parses a string as an <see cref="ModifierFlags"/> value using the <see cref="CultureInfo.InvariantCulture"/>. /// </summary> /// <param name="s">The string to be parsed.</param> /// <param name="result">The <see cref="ModifierFlags"/> value parsed from <paramref name="s"/> if the string was successfully parsed; <see cref="ModifierFlags.None"/> otherwise.</param> /// <returns>True if the string was successfully parsed; False otherwise.</returns> public static bool TryParseInvariant(string s, out ModifierFlags result) { return TryParse(s, CultureInfo.InvariantCulture, out result); }
/// <summary> /// Performs a drag-drop of a non-<see cref="IGalleryItem"/> object from outside this gallery on top of the specified item. /// </summary> /// <param name="droppedData">The data object to drop.</param> /// <param name="targetItem">The target <see cref="IGalleryItem"/> at which the <paramref name="droppedData"/> is being dropped.</param> /// <param name="actions">The interaction to take.</param> /// <param name="modifiers">The modifier keys that were pressed at the time of the drop.</param> /// <returns>The actual interaction on the <paramref name="droppedData"/> that was taken.</returns> protected virtual DragDropOption PerformDropForeignObject(IDragDropObject droppedData, IGalleryItem targetItem, DragDropOption actions, ModifierFlags modifiers) { return DragDropOption.None; }
/// <summary> /// Initializes a new CreateGraphVariableDeclarationCommand. /// </summary> /// <param name="name">The name of the variable to create.</param> /// <param name="isExposed">Whether or not the variable is exposed.</param> /// <param name="typeHandle">The type of data the new variable declaration to create represents.</param> /// <param name="variableType">The type of variable declaration to create.</param> /// <param name="modifierFlags">The modifiers to apply to the newly created variable.</param> /// <param name="guid">The SerializableGUID to assign to the newly created item. If none is provided, a new /// SerializableGUID will be generated for it.</param> public CreateGraphVariableDeclarationCommand(string name, bool isExposed, TypeHandle typeHandle, Type variableType, ModifierFlags modifierFlags = ModifierFlags.None, SerializableGUID guid = default) : this(name, isExposed, typeHandle, modifierFlags, guid) { VariableType = variableType; }