// FIXME: map all modifiers correctly
static MemberAttributes ConvMemberAttributes(Modifiers modifier)
{
MemberAttributes attr = (MemberAttributes)0;
if ((modifier & Modifiers.Abstract) != 0)
attr |= MemberAttributes.Abstract;
if ((modifier & Modifiers.Const) != 0)
attr |= MemberAttributes.Const;
if ((modifier & Modifiers.Sealed) != 0)
attr |= MemberAttributes.Final;
if ((modifier & Modifiers.New) != 0)
attr |= MemberAttributes.New;
if ((modifier & Modifiers.Virtual) != 0)
attr |= MemberAttributes.Overloaded;
if ((modifier & Modifiers.Override) != 0)
attr |= MemberAttributes.Override;
if ((modifier & Modifiers.Static) != 0)
attr |= MemberAttributes.Static;
if ((modifier & Modifiers.Private) != 0)
attr |= MemberAttributes.Private;
else if ((modifier & Modifiers.Public) != 0)
attr |= MemberAttributes.Public;
else if ((modifier & Modifiers.Internal) != 0 && (modifier & Modifiers.Protected) != 0)
attr |= MemberAttributes.FamilyOrAssembly;
else if ((modifier & Modifiers.Internal) != 0)
attr |= MemberAttributes.Assembly;
else if ((modifier & Modifiers.Protected) != 0)
attr |= MemberAttributes.Family;
return attr;
}
public void DoControlGroup(World world, int group, Modifiers mods)
{
if (mods.HasModifier(Modifiers.Ctrl))
{
if (actors.Count == 0)
return;
controlGroups[group].Clear();
for (var i = 0; i < 10; i++) /* all control groups */
controlGroups[i].RemoveAll(a => actors.Contains(a));
controlGroups[group].AddRange(actors);
return;
}
if (mods.HasModifier(Modifiers.Alt))
{
Game.viewport.Center(controlGroups[group]);
return;
}
Combine(world, controlGroups[group],
mods.HasModifier(Modifiers.Shift), false);
}
void CheckName(TypeDeclaration node, AffectedEntity entity, Identifier identifier, Modifiers accessibilty)
{
TypeResolveResult resolveResult = ctx.Resolve(node) as TypeResolveResult;
if (resolveResult == null)
return;
var type = resolveResult.Type;
if (type.DirectBaseTypes.Any(t => t.FullName == "System.Attribute")) {
if (CheckNamedResolveResult(resolveResult, node, AffectedEntity.CustomAttributes, identifier, accessibilty)) {
return;
}
} else if (type.DirectBaseTypes.Any(t => t.FullName == "System.EventArgs")) {
if (CheckNamedResolveResult(resolveResult, node, AffectedEntity.CustomEventArgs, identifier, accessibilty)) {
return;
}
} else if (type.DirectBaseTypes.Any(t => t.FullName == "System.Exception")) {
if (CheckNamedResolveResult(resolveResult, node, AffectedEntity.CustomExceptions, identifier, accessibilty)) {
return;
}
}
var typeDef = type.GetDefinition();
if (typeDef != null && typeDef.Attributes.Any(attr => attr.AttributeType.FullName == "NUnit.Framework.TestFixtureAttribute")) {
if (CheckNamedResolveResult(resolveResult, node, AffectedEntity.TestType, identifier, accessibilty)) {
return;
}
}
CheckNamedResolveResult(resolveResult, node, entity, identifier, accessibilty);
}
public ConstantFieldDeclarationNode(Token token,
ParseNodeList attributes,
Modifiers modifiers,
ParseNode type,
ParseNodeList initializers)
: base(ParseNodeType.ConstFieldDeclaration, token, attributes, modifiers, type, initializers, false) {
}
public string CheckName(SemanticModel ctx, string name, AffectedEntity entity, Modifiers accessibilty = Modifiers.Private, bool isStatic = false)
{
foreach (var rule in Rules)
{
if (!rule.AffectedEntity.HasFlag(entity))
{
continue;
}
if (!rule.VisibilityMask.HasFlag(accessibilty))
{
continue;
}
if (isStatic && !rule.IncludeStaticEntities || !isStatic && !rule.IncludeInstanceMembers)
{
continue;
}
if (!rule.IsValid(name))
{
IList<string> suggestedNames;
rule.GetErrorMessage(ctx, name, out suggestedNames);
if (suggestedNames.Any())
return suggestedNames[0];
}
}
return name;
}
public Hotkey(Keys key, Modifiers modifiers, HotkeyHandler handler)
{
Key = key;
Modifiers = modifiers;
Handler = handler;
Id = GetHashCode();
}
/// <summary>
/// Creates a new KeyboardEventArgs, given a time for the event, the key that was pressed, and
/// the modifiers that were applied at the time of the press, as well as the keyboard state at
/// the time the event occurred.
/// </summary>
public CharacterEventArgs(TimeSpan time, char character, Modifiers modifiers, KeyboardState state)
: base(time)
{
Character = character;
State = state;
Modifiers = modifiers;
}
public DestructorDeclarationNode(Token token,
ParseNodeList attributes,
Modifiers modifiers,
AtomicNameNode name,
BlockStatementNode body)
: base(ParseNodeType.DestructorDeclaration, token, attributes, modifiers, /* return type */ null, name, new ParseNodeList(), body) {
}
public void DoControlGroup(World world, WorldRenderer worldRenderer, int group, Modifiers mods, int MultiTapCount)
{
var addModifier = Platform.CurrentPlatform == PlatformType.OSX ? Modifiers.Meta : Modifiers.Ctrl;
if (mods.HasModifier(addModifier))
{
if (actors.Count == 0)
return;
if (!mods.HasModifier(Modifiers.Shift))
controlGroups[group].Clear();
for (var i = 0; i < 10; i++) /* all control groups */
controlGroups[i].RemoveAll(a => actors.Contains(a));
controlGroups[group].AddRange(actors.Where(a => a.Owner == world.LocalPlayer));
return;
}
var groupActors = controlGroups[group].Where(a => !a.IsDead() && !world.FogObscures(a));
if (mods.HasModifier(Modifiers.Alt) || MultiTapCount >= 2)
{
worldRenderer.Viewport.Center(groupActors);
return;
}
Combine(world, groupActors, mods.HasModifier(Modifiers.Shift), false);
}
public ConstructorDeclaration(string name, Modifiers modifier,
List<ParameterDeclarationExpression> parameters,
ConstructorInitializer constructorInitializer,
List<AttributeSection> attributes)
: base(modifier, attributes, name, parameters)
{
}
public void DoControlGroup(World world, int group, Modifiers mods, int MultiTapCount)
{
var addModifier = Platform.CurrentPlatform == PlatformType.OSX ? Modifiers.Meta : Modifiers.Ctrl;
if (mods.HasModifier(addModifier))
{
if (actors.Count == 0)
return;
if (!mods.HasModifier(Modifiers.Shift))
controlGroups[group].Clear();
for (var i = 0; i < 10; i++) /* all control groups */
controlGroups[i].RemoveAll(a => actors.Contains(a));
controlGroups[group].AddRange(actors);
return;
}
if (mods.HasModifier(Modifiers.Alt) || MultiTapCount >= 2)
{
Game.viewport.Center(controlGroups[group]);
return;
}
Combine(world, controlGroups[group],
mods.HasModifier(Modifiers.Shift), false);
}
// public void Add(Modifiers m)
// {
// Add(m.cur, m.Location);
// }
public void Check(Modifiers allowed)
{
Modifiers wrong = cur & ~allowed;
if (wrong != Modifiers.None) {
// parser.Error("modifier(s) " + wrong + " not allowed here");
}
}
public VariableDeclarationNode(Token token,
ParseNodeList attributes,
Modifiers modifiers,
ParseNode type,
ParseNodeList initializers,
bool isFixed)
: this(ParseNodeType.VariableDeclaration, token, attributes, modifiers, type, initializers, isFixed) {
}
/// <summary>
/// Creates a new KeyboardEventArgs, given a time for the event, the key that was pressed, and
/// the modifiers that were applied at the time of the press, as well as the keyboard state at
/// the time the event occurred.
/// </summary>
public KeyboardEventArgs(TimeSpan time, Keys key, Modifiers modifiers, KeyboardState state)
: base(time)
{
Character = KeyboardUtil.ToChar(key, modifiers);
State = state;
Modifiers = modifiers;
Key = key;
}
public void ReplaceModifiers(AttributedNode node, Modifiers oldModifier, Modifiers newModifier)
{
if (ContainsModifier(node, oldModifier))
{
RemoveModifierFrom(node, oldModifier);
AddModifierTo(node, newModifier);
}
}
protected CompilerGeneratedContainer (TypeContainer parent, MemberName name, Modifiers mod, MemberKind kind)
: base (parent, name, null, kind)
{
Debug.Assert ((mod & Modifiers.AccessibilityMask) != 0);
ModFlags = mod | Modifiers.COMPILER_GENERATED | Modifiers.SEALED;
spec = new TypeSpec (Kind, null, this, null, ModFlags);
}
int GetAccessSortValue (Modifiers mods)
{
if ((mods & Modifiers.Private) != 0) return 0;
if ((mods & Modifiers.Internal) != 0) return 1;
if ((mods & Modifiers.Protected) != 0) return 2;
if ((mods & Modifiers.Public) != 0) return 3;
return 4;
}
public GlobalHotKey(IntPtr handle, Key keys, Modifiers modifiers, Action handler)
{
this.handle = handle;
this.key = keys;
this.modifiers = modifiers;
this.handler = handler;
this.id = (int)keys ^ (int)modifiers;
}
// This checks if the only key being held is the one we want using the Modifier helper.
public bool GetModifier(Modifiers key)
{
switch (key)
{
case Modifiers.Control: return Modifier(Modifiers.Control) && !Modifier(Modifiers.Alt) && !Modifier(Modifiers.Shift);
case Modifiers.Alt: return !Modifier(Modifiers.Control) && Modifier(Modifiers.Alt) && !Modifier(Modifiers.Shift);
default: return !Modifier(Modifiers.Control) && !Modifier(Modifiers.Alt) && Modifier(Modifiers.Shift);
}
}
public static PropertyDeclaration CreateAutoPropertyDeclaration(string name, string type, Modifiers modifiers)
{
return new PropertyDeclaration(modifiers, new List<AttributeSection>(), name, new List<ParameterDeclarationExpression>())
{
TypeReference = CreateTypeReference(type),
GetRegion = CreateAutoPropertyGetRegion(),
SetRegion = CreateAutoPropertySetRegion()
};
}
public MouseInput(MouseInputEvent ev, MouseButton button, int scrollDelta, int2 location, Modifiers mods, int multiTapCount)
{
Event = ev;
Button = button;
ScrollDelta = scrollDelta;
Location = location;
Modifiers = mods;
MultiTapCount = multiTapCount;
}
private static bool IsPrivateOrNone(Modifiers modifiers)
{
if ((modifiers & Modifiers.Private) == Modifiers.Private)
return true;
if ((modifiers & Modifiers.Visibility) == Modifiers.None)
return true;
return false;
}
public OperatorDeclarationNode(Token token,
ParseNodeList attributes,
Modifiers modifiers,
TokenType operatorNodeType,
ParseNode returnType,
ParseNodeList formals,
BlockStatementNode body)
: base(ParseNodeType.OperatorDeclaration, token, attributes, modifiers, returnType, /* name */ null, formals, body) {
this.operatorTokenType = operatorNodeType;
}
public Hotkey(Modifiers modifier, Keys key, Window window, bool registerImmediately = false)
{
if (window == null) throw new ArgumentException("You must provide a form or window to register the hotkey to.", "window");
Modifier = modifier;
Key = key;
_hWnd = new WindowInteropHelper(window).Handle;
Id = GetHashCode();
HookWndProc(window);
if (registerImmediately) Register();
}
public PropertyDeclarationNode(Token token,
ParseNodeList attributes,
Modifiers modifiers,
ParseNode type,
NameNode interfaceType,
AtomicNameNode name,
AccessorNode getOrRemove,
AccessorNode setOrAdd)
: this(ParseNodeType.PropertyDeclaration, token, attributes, modifiers, type, interfaceType, getOrRemove, setOrAdd) {
_name = (AtomicNameNode)GetParentedNode(name);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="AccessModifier">Access modifier</param>
/// <param name="Modifier">Modifier</param>
/// <param name="Type">Type</param>
/// <param name="FunctionName">Function name</param>
/// <param name="ParameterList">Parameter list</param>
/// <param name="Body">Body of the function</param>
/// <param name="Parser">Parser to use</param>
public Function(AccessModifier AccessModifier, Modifiers Modifier, string Type,
string FunctionName, IParameter[] ParameterList, string Body, IParser Parser)
: base(Parser)
{
this.AccessModifier = AccessModifier;
this.Modifier = Modifier;
this.Type = Type;
this.Name = FunctionName;
this.Parameters = ParameterList.ToList();
this.Body = Body;
}
public static MethodDeclaration CreateEmptyMethodDeclaration(string name, string returnTypeName, Modifiers modifiers, List<ParameterDeclarationExpression> parameters)
{
return new MethodDeclaration
{
Name = name,
TypeReference = CreateTypeReference(returnTypeName),
Modifier = modifiers,
Parameters = parameters,
Body = CreateEmptyBlockStatement(returnTypeName)
};
}
/// <summary>
/// Creates a GlobalHotkey object.
/// </summary>
/// <param name="modifier">Hotkey modifier keys</param>
/// <param name="key">Hotkey</param>
/// <param name="window">The Window that the hotkey should be registered to</param>
/// <param name="registerImmediately"> </param>
public GlobalHotkey(Modifiers modifier, Keys key, IWin32Window window, bool registerImmediately = false)
{
if (window == null && registerImmediately) throw new ArgumentNullException("window", "You must provide a form or window to register the hotkey against.");
Modifier = modifier;
Key = (int)key;
if (window != null)
hWnd = window.Handle;
Id = GetHashCode();
if (registerImmediately) Register();
nextId+=10;
}
public AccessorNode(Token token,
ParseNodeList attributes,
AtomicNameNode name,
BlockStatementNode body,
Modifiers modifiers)
: base(ParseNodeType.AccessorDeclaration, token) {
_name = (AtomicNameNode)GetParentedNode(name);
_implementation = (BlockStatementNode)GetParentedNode(body);
_attributes = GetParentedNodeList(attributes);
_modifiers = modifiers;
}
public IndexerDeclarationNode(Token token,
ParseNodeList attributes,
Modifiers modifiers,
ParseNode type,
NameNode interfaceType,
ParseNodeList parameters,
AccessorNode get,
AccessorNode set)
: base(ParseNodeType.IndexerDeclaration, token, attributes, modifiers, type, interfaceType, get, set)
{
_parameters = GetParentedNodeList(parameters);
}
// ignore all input
public void ModifierKeys(Modifiers mods)
{
}
public ClassInfo(TypeDefinition c)
{
this.def = c;
this.modifiers = Util.ConvertModifiers(c);
Rename();
}
///<summary> Add radiation sub-panel, including tooltips </summary>
private static void AddSubPanelRadiation(Panel p)
{
// get first radiation rule
// - guaranteed to exist, as this panel is not rendered if it doesn't
// - even without crew, it is safe to evaluate the modifiers that use it
Rule rule = Profile.rules.Find(k => k.modifiers.Contains("radiation"));
// detect if it use shielding
bool use_shielding = rule.modifiers.Contains("shielding");
// calculate various radiation levels
double[] levels = new[]
{
Math.Max(Radiation.Nominal, (env_analyzer.surface_rad + vessel_analyzer.emitted)), // surface
Math.Max(Radiation.Nominal, (env_analyzer.magnetopause_rad + vessel_analyzer.emitted)), // inside magnetopause
Math.Max(Radiation.Nominal, (env_analyzer.inner_rad + vessel_analyzer.emitted)), // inside inner belt
Math.Max(Radiation.Nominal, (env_analyzer.outer_rad + vessel_analyzer.emitted)), // inside outer belt
Math.Max(Radiation.Nominal, (env_analyzer.heliopause_rad + vessel_analyzer.emitted)), // interplanetary
Math.Max(Radiation.Nominal, (env_analyzer.extern_rad + vessel_analyzer.emitted)), // interstellar
Math.Max(Radiation.Nominal, (env_analyzer.storm_rad + vessel_analyzer.emitted)) // storm
};
// evaluate modifiers (except radiation)
List <string> modifiers_except_radiation = new List <string>();
foreach (string s in rule.modifiers)
{
if (s != "radiation")
{
modifiers_except_radiation.Add(s);
}
}
double mod = Modifiers.Evaluate(env_analyzer, vessel_analyzer, resource_sim, modifiers_except_radiation);
// calculate life expectancy at various radiation levels
double[] estimates = new double[7];
for (int i = 0; i < 7; ++i)
{
estimates[i] = rule.fatal_threshold / (rule.degeneration * mod * levels[i]);
}
// generate tooltip
RadiationModel mf = Radiation.Info(env_analyzer.body).model;
string tooltip = Lib.BuildString
(
"<align=left />",
String.Format("{0,-20}\t<b>{1}</b>\n", "surface", Lib.HumanReadableDuration(estimates[0])),
mf.has_pause ? String.Format("{0,-20}\t<b>{1}</b>\n", "magnetopause", Lib.HumanReadableDuration(estimates[1])) : "",
mf.has_inner ? String.Format("{0,-20}\t<b>{1}</b>\n", "inner belt", Lib.HumanReadableDuration(estimates[2])) : "",
mf.has_outer ? String.Format("{0,-20}\t<b>{1}</b>\n", "outer belt", Lib.HumanReadableDuration(estimates[3])) : "",
String.Format("{0,-20}\t<b>{1}</b>\n", "interplanetary", Lib.HumanReadableDuration(estimates[4])),
String.Format("{0,-20}\t<b>{1}</b>\n", "interstellar", Lib.HumanReadableDuration(estimates[5])),
String.Format("{0,-20}\t<b>{1}</b>", "storm", Lib.HumanReadableDuration(estimates[6]))
);
// render the panel
p.AddSection("RADIATION", string.Empty,
() => { p.Prev(ref special_index, panel_special.Count); enforceUpdate = true; },
() => { p.Next(ref special_index, panel_special.Count); enforceUpdate = true; });
p.AddContent("surface", Lib.HumanReadableRadiation(env_analyzer.surface_rad + vessel_analyzer.emitted), tooltip);
p.AddContent("orbit", Lib.HumanReadableRadiation(env_analyzer.magnetopause_rad), tooltip);
if (vessel_analyzer.emitted >= 0.0)
{
p.AddContent("emission", Lib.HumanReadableRadiation(vessel_analyzer.emitted), tooltip);
}
else
{
p.AddContent("active shielding", Lib.HumanReadableRadiation(-vessel_analyzer.emitted), tooltip);
}
p.AddContent("shielding", rule.modifiers.Contains("shielding") ? Habitat.Shielding_to_string(vessel_analyzer.shielding) : "n/a", tooltip);
}
internal static void HandleModifierKeys(Modifiers mods)
{
modifiers = mods;
}
/// <summary>
/// send MG_ACT_ARROW_KEY to worker thread form key down,up,left,right
/// we are handling those keys
/// </summary>
/// <param name = "mgControl"> </param>
/// <param name = "modifier"> </param>
/// <param name = "keyCode"> </param>
/// <param name = "suggestedValue"> </param>
/// <returns> true if need to ignore this action key</returns>
private bool processKeyForSelectionControl(MgFormBase mgForm, MgControlBase mgControl, Modifiers modifier, int keyCode, String suggestedValue)
{
bool isSelectionKey = false;
switch (keyCode)
{
case GuiConstants.KEY_DOWN:
case GuiConstants.KEY_UP:
isSelectionKey = true;
break;
case GuiConstants.KEY_RIGHT:
case GuiConstants.KEY_LEFT:
if (!mgControl.isListBox())
{
isSelectionKey = true;
}
break;
case GuiConstants.KEY_SPACE:
if (mgControl.isRadio())
{
isSelectionKey = true;
}
break;
case GuiConstants.KEY_PG_DOWN:
case GuiConstants.KEY_PG_UP:
case GuiConstants.KEY_HOME:
case GuiConstants.KEY_END:
if (mgControl.isComboBox())
{
isSelectionKey = true;
}
break;
}
if (isSelectionKey)
{
// raise event
Manager.EventsManager.AddKeyboardEvent(mgForm, mgControl, modifier, keyCode,
0, 0, null, null,
false, suggestedValue, InternalInterface.MG_ACT_ARROW_KEY);
}
return(isSelectionKey);
}
public Hotkey(Keycode virtKey, Modifiers mod)
{
Key = virtKey;
Modifiers = mod;
}
public Command(Modifiers modifiers, Key main)
{
Shortcut = new Shortcut(modifiers, main);
}
void CheckName(MethodDeclaration node, AffectedEntity entity, Identifier identifier, Modifiers accessibilty)
{
ResolveResult resolveResult = null;
if (node != null && node.Attributes.Any())
{
resolveResult = ctx.Resolve(node);
}
if (resolveResult is MemberResolveResult)
{
var member = ((MemberResolveResult)resolveResult).Member;
if (member.EntityType == EntityType.Method && member.Attributes.Any(attr => attr.AttributeType.FullName == "NUnit.Framework.TestAttribute"))
{
if (CheckNamedResolveResult(resolveResult, node, AffectedEntity.TestMethod, identifier, accessibilty))
{
return;
}
}
}
CheckNamedResolveResult(resolveResult, node, entity, identifier, accessibilty);
}
void CheckName(AstNode node, AffectedEntity entity, Identifier identifier, Modifiers accessibilty)
{
CheckNamedResolveResult(null, node, entity, identifier, accessibilty);
}
bool CheckNamedResolveResult(ResolveResult resolveResult, AstNode node, AffectedEntity entity, Identifier identifier, Modifiers accessibilty)
{
bool wasHandled = false;
foreach (var rule in service.Rules)
{
if (!rule.AffectedEntity.HasFlag(entity))
{
continue;
}
if (!rule.VisibilityMask.HasFlag(accessibilty))
{
continue;
}
if (!rule.IncludeInstanceMembers || !rule.IncludeStaticEntities)
{
EntityDeclaration typeSystemEntity;
if (node is VariableInitializer)
{
typeSystemEntity = node.Parent as EntityDeclaration;
}
else
{
typeSystemEntity = node as EntityDeclaration;
}
if (!rule.IncludeInstanceMembers)
{
if (typeSystemEntity == null || !typeSystemEntity.HasModifier(Modifiers.Static) || typeSystemEntity.HasModifier(Modifiers.Sealed))
{
continue;
}
}
if (!rule.IncludeStaticEntities)
{
if (typeSystemEntity == null || typeSystemEntity.HasModifier(Modifiers.Static) || typeSystemEntity.HasModifier(Modifiers.Sealed))
{
continue;
}
}
}
wasHandled = true;
if (!rule.IsValid(identifier.Name))
{
IList <string> suggestedNames;
var msg = rule.GetErrorMessage(ctx, identifier.Name, out suggestedNames);
var actions = new List <CodeAction>(suggestedNames.Select(n => new CodeAction(string.Format(ctx.TranslateString("Rename to '{0}'"), n), (Script script) => {
if (resolveResult == null)
{
resolveResult = ctx.Resolve(node);
}
if (resolveResult is MemberResolveResult)
{
script.Rename(((MemberResolveResult)resolveResult).Member, n);
}
else if (resolveResult is TypeResolveResult)
{
var def = ((TypeResolveResult)resolveResult).Type.GetDefinition();
if (def != null)
{
script.Rename(def, n);
}
else
{
script.RenameTypeParameter(((TypeResolveResult)resolveResult).Type, n);
}
}
else if (resolveResult is LocalResolveResult)
{
script.Rename(((LocalResolveResult)resolveResult).Variable, n);
}
else if (resolveResult is NamespaceResolveResult)
{
script.Rename(((NamespaceResolveResult)resolveResult).Namespace, n);
}
else
{
script.Replace(identifier, Identifier.Create(n));
}
}, identifier)));
if (entity != AffectedEntity.Label)
{
actions.Add(new CodeAction(string.Format(ctx.TranslateString("Rename '{0}'..."), identifier.Name), (Script script) => {
if (resolveResult == null)
{
resolveResult = ctx.Resolve(node);
}
if (resolveResult is MemberResolveResult)
{
script.Rename(((MemberResolveResult)resolveResult).Member);
}
else if (resolveResult is TypeResolveResult)
{
var def = ((TypeResolveResult)resolveResult).Type.GetDefinition();
if (def != null)
{
script.Rename(def);
}
else
{
script.RenameTypeParameter(((TypeResolveResult)resolveResult).Type);
}
}
else if (resolveResult is LocalResolveResult)
{
script.Rename(((LocalResolveResult)resolveResult).Variable);
}
else if (resolveResult is NamespaceResolveResult)
{
script.Rename(((NamespaceResolveResult)resolveResult).Namespace);
}
}, identifier));
}
AddIssue(identifier, msg, actions);
}
}
return(wasHandled);
}
protected override string Append(string name)
{
return(name + " " + String.Join(" ", Modifiers.Select(m => m.ToString())));
}
public CSharpModifierToken(TextLocation location, Modifiers modifier) : base(location, null)
{
this.Modifier = modifier;
}
public MouseInput(MouseInputEvent ev, MouseButton button, int2 location, int2 delta, Modifiers mods, int multiTapCount)
{
Event = ev;
Button = button;
Location = location;
Delta = delta;
Modifiers = mods;
MultiTapCount = multiTapCount;
}
public T OopModifier(Modifiers enumModifier)
{
OopModifierScript = ModifierReverser.GetModifier(enumModifier);
return(Link);
}
public TypeDeclaration(Modifiers modifier, List <AttributeSection> attributes) : base(modifier, attributes)
{
}
public FieldInfo(FieldDefinition f)
{
this.def = f;
modifiers = Util.ConvertModifiers(f);
Rename();
}
public SystemElement(SystemElementControl control, SystemElementType type, int size, Modifiers modifiers)
{
Control = control;
Type = type;
Size = size;
this.modifiers = modifiers;
Name = control.Name + " " + type.Name;
float modifier = (Type.Power + Control.Power) * Size;
PowerModifier = Mathf.RoundToInt(modifier);
}
public static IEnumerable <Actor> SelectActorsInBoxWithDeadzone(World world, int2 a, int2 b, Modifiers modifiers)
{
// For dragboxes that are too small, shrink the dragbox to a single point (point b)
if ((a - b).Length <= Game.Settings.Game.SelectionDeadzone)
{
a = b;
}
if (a == b)
{
return(SelectHighestPriorityActorAtPoint(world, a, modifiers));
}
return(world.ScreenMap.ActorsInMouseBox(a, b)
.Select(x => x.Actor)
.Where(x => x.Info.HasTraitInfo <ISelectableInfo>() && (x.Owner.IsAlliedWith(world.RenderPlayer) || !world.FogObscures(x)))
.SubsetWithHighestSelectionPriority(modifiers));
}
/// <summary>Pass keycode and modifier to bridge, bridge then converts it to keyboard action and adds in MgCore.dll
/// events queue</summary>
/// <param name="form"></param>
/// <param name="guiMgCtrl"></param>
/// <param name="modifier"></param>
/// <param name="keyCode"></param>
/// <param name="start"></param>
/// <param name="end"></param>
/// <param name="caretPos"></param>
/// <param name="text"></param>
/// <param name="im"></param>
/// <param name="isActChar"></param>
/// <param name="suggestedValue"></param>
/// <param name="ComboIsDropDown"></param>
/// <param name="handled">boolean variable event is handled or not.</param>
/// <returns> true only if we have handled the KeyDown event (otherwise the CLR should handle). If true magic will handle else CLR will handle.</returns>
protected virtual bool processKeyDown(GuiMgForm guiMgForm, GuiMgControl guiMgCtrl, Modifiers modifier, int keyCode,
int start, int end, string text, ImeParam im,
bool isActChar, string suggestedValue, bool ComboIsDropDown, bool handled)
{
bool eventHandled = handled;
bool addKeyBoardEvent = true;
MgControlBase mgControl = (MgControlBase)guiMgCtrl;
MgFormBase mgForm = (MgFormBase)guiMgForm;
if (mgControl != null)
{
//In case of help window, the events like up arrow\down arrow key, should be handled by the
//CLR.So first check if the form is help form and return the value true or false.
if (mgControl.getForm() != null && mgControl.getForm().IsHelpWindow&& keyCode != GuiConstants.KEY_ESC)
{
//events related with the help window will NOT be handled by magic.
return(false);
}
// DOWN or UP invoked on a SELECT/RADIO control
if ((mgControl.isRadio() || mgControl.isListBox() ||
(mgControl.isComboBox() && ComboIsDropDown) ||
(mgControl.isTabControl() && !suggestedValue.Equals("-1"))))
{
if (processKeyForSelectionControl(mgForm, mgControl, modifier, keyCode, suggestedValue))
{
addKeyBoardEvent = false;
}
}
}
if (addKeyBoardEvent)
{
// raise event
Manager.EventsManager.AddKeyboardEvent(mgForm, mgControl, modifier, keyCode,
start, end, text, im,
isActChar, suggestedValue, InternalInterface.MG_ACT_CTRL_KEYDOWN);
}
return(eventHandled);
}
public static IEnumerable <Actor> SelectHighestPriorityActorAtPoint(World world, int2 a, Modifiers modifiers)
{
var selected = world.ScreenMap.ActorsAtMouse(a)
.Where(x => x.Actor.Info.HasTraitInfo <ISelectableInfo>() && (x.Actor.Owner.IsAlliedWith(world.RenderPlayer) || !world.FogObscures(x.Actor)))
.WithHighestSelectionPriority(a, modifiers);
if (selected != null)
{
yield return(selected);
}
}
/// <summary>
/// put multimark hit event
/// </summary>
/// <param name="guiMgCtrl"></param>
/// <param name="row"></param>
void processMultimarkHitEvent(GuiMgControl guiMgCtrl, int row, Modifiers modifier)
{
Manager.EventsManager.addGuiTriggeredEvent((MgControlBase)guiMgCtrl, InternalInterface.MG_ACT_MULTI_MARK_HIT, row, modifier);
}
public static string GetModifierName(Modifiers modifier)
{
switch (modifier)
{
case Modifiers.Private:
return("private");
case Modifiers.Internal:
return("internal");
case Modifiers.Protected:
return("protected");
case Modifiers.Public:
return("public");
case Modifiers.Abstract:
return("abstract");
case Modifiers.Virtual:
return("virtual");
case Modifiers.Sealed:
return("sealed");
case Modifiers.Static:
return("static");
case Modifiers.Override:
return("override");
case Modifiers.Ref:
return("ref");
case Modifiers.Readonly:
return("readonly");
case Modifiers.Const:
return("const");
case Modifiers.New:
return("new");
case Modifiers.Partial:
return("partial");
case Modifiers.Extern:
return("extern");
case Modifiers.Volatile:
return("volatile");
case Modifiers.Unsafe:
return("unsafe");
case Modifiers.Async:
return("async");
case Modifiers.Any:
// even though it's used for pattern matching only, 'any' needs to be in this list to be usable in the AST
return("any");
default:
throw new NotSupportedException("Invalid value for Modifiers");
}
}
public string CheckName(RefactoringContext ctx, string name, AffectedEntity entity, Modifiers accessibilty = Modifiers.Private, bool isStatic = false)
{
foreach (var rule in Rules)
{
if (!rule.AffectedEntity.HasFlag(entity))
{
continue;
}
if (!rule.VisibilityMask.HasFlag(accessibilty))
{
continue;
}
if (isStatic && !rule.IncludeStaticEntities || !isStatic && !rule.IncludeInstanceMembers)
{
continue;
}
if (!rule.IsValid(name))
{
IList <string> suggestedNames;
rule.GetErrorMessage(ctx, name, out suggestedNames);
if (suggestedNames.Any())
{
return(suggestedNames [0]);
}
}
}
return(name);
}
public static bool HasModifier(this Modifiers k, Modifiers mod)
{
// PERF: Enum.HasFlag is slower and requires allocations.
return((k & mod) == mod);
}
public void ModifierKeys(Modifiers mods)
{
Game.HandleModifierKeys(mods);
}
public KeyEventArgs(Keys keyCode, Modifiers keyModifiers)
{
this._keyCode = keyCode;
this._keyModifiers = keyModifiers;
}
protected FieldBase(TypeDefinition parent, FullNamedExpression type, Modifiers mod, Modifiers allowed_mod, MemberName name, Attributes attrs)
: base(parent, type, mod, allowed_mod | Modifiers.ABSTRACT, Modifiers.PRIVATE, name, attrs)
{
if ((mod & Modifiers.ABSTRACT) != 0)
{
Report.Error(681, Location, "The modifier 'abstract' is not valid on fields. Try using a property instead");
}
}
void CheckName(TypeDeclaration node, AffectedEntity entity, Identifier identifier, Modifiers accessibilty)
{
TypeResolveResult resolveResult = ctx.Resolve(node) as TypeResolveResult;
if (resolveResult == null)
{
return;
}
var type = resolveResult.Type;
if (type.DirectBaseTypes.Any(t => t.FullName == "System.Attribute"))
{
if (CheckNamedResolveResult(resolveResult, node, AffectedEntity.CustomAttributes, identifier, accessibilty))
{
return;
}
}
else if (type.DirectBaseTypes.Any(t => t.FullName == "System.EventArgs"))
{
if (CheckNamedResolveResult(resolveResult, node, AffectedEntity.CustomEventArgs, identifier, accessibilty))
{
return;
}
}
else if (type.DirectBaseTypes.Any(t => t.FullName == "System.Exception"))
{
if (CheckNamedResolveResult(resolveResult, node, AffectedEntity.CustomExceptions, identifier, accessibilty))
{
return;
}
}
var typeDef = type.GetDefinition();
if (typeDef != null && typeDef.Attributes.Any(attr => attr.AttributeType.FullName == "NUnit.Framework.TestFixtureAttribute"))
{
if (CheckNamedResolveResult(resolveResult, node, AffectedEntity.TestType, identifier, accessibilty))
{
return;
}
}
CheckNamedResolveResult(resolveResult, node, entity, identifier, accessibilty);
}
public Field(TypeDefinition parent, FullNamedExpression type, Modifiers mod, MemberName name, Attributes attrs)
: base(parent, type, mod, AllowedModifiers, name, attrs)
{
}
public void DoControlGroup(World world, WorldRenderer worldRenderer, int group, Modifiers mods, int multiTapCount)
{
var addModifier = Platform.CurrentPlatform == PlatformType.OSX ? Modifiers.Meta : Modifiers.Ctrl;
if (mods.HasModifier(addModifier))
{
if (actors.Count == 0)
{
return;
}
if (!mods.HasModifier(Modifiers.Shift))
{
controlGroups[group].Clear();
}
for (var i = 0; i < 10; i++) /* all control groups */
{
controlGroups[i].RemoveAll(a => actors.Contains(a));
}
controlGroups[group].AddRange(actors.Where(a => a.Owner == world.LocalPlayer));
return;
}
var groupActors = controlGroups[group].Where(a => !a.IsDead);
if (mods.HasModifier(Modifiers.Alt) || multiTapCount >= 2)
{
worldRenderer.Viewport.Center(groupActors);
return;
}
Combine(world, groupActors, mods.HasModifier(Modifiers.Shift), false);
}
