Beispiel #1
0
        public WatchVariableControlPrecursor(
            string name,
            WatchVariable watchVar,
            WatchVariableSubclass subclass,
            Color?backgroundColor,
            Type displayType,
            int?roundingLimit,
            bool?useHex,
            bool?invertBool,
            bool?isYaw,
            Coordinate?coordinate,
            List <VariableGroup> groupList,
            List <uint> fixedAddresses = null)
        {
            Name            = name;
            WatchVar        = watchVar;
            Subclass        = subclass;
            BackgroundColor = backgroundColor;
            DisplayType     = displayType;
            RoundingLimit   = roundingLimit;
            UseHex          = useHex;
            InvertBool      = invertBool;
            IsYaw           = isYaw;
            Coordinate      = coordinate;
            GroupList       = groupList;
            FixedAddresses  = fixedAddresses;

            VerifyState();
        }
        public WatchVariableNumberWrapper(
            WatchVariable watchVar,
            WatchVariableControl watchVarControl,
            int?roundingLimit = DEFAULT_ROUNDING_LIMIT,
            bool?displayAsHex = DEFAULT_DISPLAY_AS_HEX,
            bool useCheckbox  = DEFAULT_USE_CHECKBOX,
            WatchVariableCoordinate?coordinate = null)
            : base(watchVar, watchVarControl, useCheckbox)
        {
            if (roundingLimit.HasValue)
            {
                roundingLimit = MoreMath.Clamp(roundingLimit.Value, 0, MAX_ROUNDING_LIMIT);
            }

            _roundingLimit    = roundingLimit;
            _displayAsHex     = displayAsHex ?? DEFAULT_DISPLAY_AS_HEX;
            _displayAsNegated = false;

            AddCoordinateContextMenuStripItems();
            AddNumberContextMenuStripItems();

            if (coordinate != null)
            {
                WatchVariableCoordinateManager.NotifyCoordinate(coordinate.Value, this);
            }
        }
Beispiel #3
0
        public WatchVariableControlPrecursor(XElement element)
        {
            /// Watchvariable params
            string typeName    = (element.Attribute(XName.Get("type"))?.Value);
            string specialType = element.Attribute(XName.Get("specialType"))?.Value;
            BaseAddressTypeEnum baseAddressType = WatchVariableUtilities.GetBaseAddressType(element.Attribute(XName.Get("base")).Value);
            uint?offsetUS      = ParsingUtilities.ParseHexNullable(element.Attribute(XName.Get("offsetUS"))?.Value);
            uint?offsetJP      = ParsingUtilities.ParseHexNullable(element.Attribute(XName.Get("offsetJP"))?.Value);
            uint?offsetSH      = ParsingUtilities.ParseHexNullable(element.Attribute(XName.Get("offsetSH"))?.Value);
            uint?offsetEU      = ParsingUtilities.ParseHexNullable(element.Attribute(XName.Get("offsetEU"))?.Value);
            uint?offsetDefault = ParsingUtilities.ParseHexNullable(element.Attribute(XName.Get("offset"))?.Value);
            uint?mask          = element.Attribute(XName.Get("mask")) != null ?
                                 (uint?)ParsingUtilities.ParseHex(element.Attribute(XName.Get("mask")).Value) : null;
            int?shift = element.Attribute(XName.Get("shift")) != null?
                        int.Parse(element.Attribute(XName.Get("shift")).Value) : (int?)null;

            bool handleMapping = (element.Attribute(XName.Get("handleMapping")) != null) ?
                                 bool.Parse(element.Attribute(XName.Get("handleMapping")).Value) : true;
            string name = element.Value;

            WatchVar =
                new WatchVariable(
                    name,
                    typeName,
                    specialType,
                    baseAddressType,
                    offsetUS,
                    offsetJP,
                    offsetSH,
                    offsetEU,
                    offsetDefault,
                    mask,
                    shift,
                    handleMapping);

            Name            = name;
            Subclass        = WatchVariableUtilities.GetSubclass(element.Attribute(XName.Get("subclass"))?.Value);
            GroupList       = WatchVariableUtilities.ParseVariableGroupList(element.Attribute(XName.Get("groupList"))?.Value);
            BackgroundColor = (element.Attribute(XName.Get("color")) != null) ?
                              ColorUtilities.GetColorFromString(element.Attribute(XName.Get("color")).Value) : (Color?)null;
            string displayTypeName = (element.Attribute(XName.Get("display"))?.Value);

            DisplayType   = displayTypeName != null ? TypeUtilities.StringToType[displayTypeName] : null;
            RoundingLimit = (element.Attribute(XName.Get("round")) != null) ?
                            ParsingUtilities.ParseInt(element.Attribute(XName.Get("round")).Value) : (int?)null;
            UseHex = (element.Attribute(XName.Get("useHex")) != null) ?
                     bool.Parse(element.Attribute(XName.Get("useHex")).Value) : (bool?)null;
            InvertBool = element.Attribute(XName.Get("invertBool")) != null?
                         bool.Parse(element.Attribute(XName.Get("invertBool")).Value) : (bool?)null;

            IsYaw = (element.Attribute(XName.Get("yaw")) != null) ?
                    bool.Parse(element.Attribute(XName.Get("yaw")).Value) : (bool?)null;
            Coordinate = element.Attribute(XName.Get("coord")) != null?
                         WatchVariableUtilities.GetCoordinate(element.Attribute(XName.Get("coord")).Value) : (Coordinate?)null;

            FixedAddresses = element.Attribute(XName.Get("fixed")) != null?
                             ParsingUtilities.ParseHexList(element.Attribute(XName.Get("fixed")).Value) : null;

            VerifyState();
        }
Beispiel #4
0
 public WatchVariableTriangleWrapper(
     WatchVariable watchVar,
     WatchVariableControl watchVarControl)
     : base(watchVar, watchVarControl)
 {
     AddTriangleContextMenuStripItems();
 }
Beispiel #5
0
        public WatchVariableAngleWrapper(
            WatchVariable watchVar,
            WatchVariableControl watchVarControl,
            Type displayType,
            bool?isYaw)
            : base(watchVar, watchVarControl, displayType, 0)
        {
            _baseType             = WatchVar.MemoryType ?? displayType;
            _defaultEffectiveType = displayType ?? WatchVar.MemoryType;
            if (_baseType == null || _defaultEffectiveType == null)
            {
                throw new ArgumentOutOfRangeException();
            }

            _defaultSigned = TypeUtilities.TypeSign[_defaultEffectiveType];
            _signed        = _defaultSigned;

            _defaultAngleUnitType = AngleUnitType.InGameUnits;
            _angleUnitType        = _defaultAngleUnitType;

            _defaultTruncateToMultipleOf16 = false;
            _truncateToMultipleOf16        = _defaultTruncateToMultipleOf16;

            _defaultConstrainToOneRevolution =
                displayType != null && TypeUtilities.TypeSize[displayType] == 2 &&
                watchVar.MemoryType != null && TypeUtilities.TypeSize[watchVar.MemoryType] == 4;
            _constrainToOneRevolution = _defaultConstrainToOneRevolution;

            _defaultReverse = false;
            _reverse        = _defaultReverse;

            _isYaw = isYaw ?? DEFAULT_IS_YAW;

            AddAngleContextMenuStripItems();
        }
 public WatchVariableAddressWrapper(
     WatchVariable watchVar,
     WatchVariableControl watchVarControl)
     : base(watchVar, watchVarControl, DEFAULT_DISPLAY_TYPE, DEFAULT_ROUNDING_LIMIT, true)
 {
     AddAddressContextMenuStripItems();
 }
 public WatchVariableStringWrapper(
     WatchVariable watchVar,
     WatchVariableControl watchVarControl)
     : base(watchVar, watchVarControl, DEFAULT_USE_CHECKBOX)
 {
     AddStringContextMenuStripItems(watchVar.SpecialType);
 }
        public static WatchVariableWrapper CreateWatchVariableWrapper(
            WatchVariable watchVar,
            WatchVariableControl watchVarControl,
            WatchVariableSubclass subclass,
            bool?useHex,
            bool?invertBool,
            WatchVariableCoordinate?coordinate)
        {
            switch (subclass)
            {
            case WatchVariableSubclass.String:
                return(new WatchVariableWrapper(watchVar, watchVarControl));

            case WatchVariableSubclass.Number:
                return(new WatchVariableNumberWrapper(
                           watchVar,
                           watchVarControl,
                           DEFAULT_ROUNDING_LIMIT,
                           useHex,
                           DEFAULT_USE_CHECKBOX,
                           coordinate));

            case WatchVariableSubclass.Angle:
                return(new WatchVariableAngleWrapper(watchVar, watchVarControl));

            case WatchVariableSubclass.Object:
                return(new WatchVariableObjectWrapper(watchVar, watchVarControl));

            case WatchVariableSubclass.Boolean:
                return(new WatchVariableBooleanWrapper(watchVar, watchVarControl, invertBool));

            default:
                throw new ArgumentOutOfRangeException();
            }
        }
        public WatchVariableNumberWrapper(
            WatchVariable watchVar,
            WatchVariableControl watchVarControl,
            Type displayType      = DEFAULT_DISPLAY_TYPE,
            int?roundingLimit     = DEFAULT_ROUNDING_LIMIT,
            bool?displayAsHex     = DEFAULT_DISPLAY_AS_HEX,
            bool useCheckbox      = DEFAULT_USE_CHECKBOX,
            Coordinate?coordinate = null)
            : base(watchVar, watchVarControl, useCheckbox)
        {
            _displayType = displayType;

            _defaultRoundingLimit = roundingLimit ?? DEFAULT_ROUNDING_LIMIT;
            _roundingLimit        = _defaultRoundingLimit;
            if (_roundingLimit < -1 || _roundingLimit > MAX_ROUNDING_LIMIT)
            {
                throw new ArgumentOutOfRangeException();
            }

            _defaultDisplayAsHex = displayAsHex ?? DEFAULT_DISPLAY_AS_HEX;
            _displayAsHex        = _defaultDisplayAsHex;

            AddCoordinateContextMenuStripItems();
            AddNumberContextMenuStripItems();

            if (coordinate != null)
            {
                WatchVariableCoordinateManager.NotifyCoordinate(coordinate.Value, this);
            }
        }
Beispiel #10
0
        public WatchVariableObjectWrapper(
            WatchVariable watchVar,
            WatchVariableControl watchVarControl)
            : base(watchVar, watchVarControl, DEFAULT_ROUNDING_LIMIT, true)
        {
            _displayAsObject = true;

            AddObjectContextMenuStripItems();
        }
        public WatchVariableObjectWrapper(
            WatchVariable watchVar,
            WatchVariableControl watchVarControl)
            : base(watchVar, watchVarControl)
        {
            _displayAsObject = true;

            AddObjectContextMenuStripItems();
        }
Beispiel #12
0
        public WatchVariableBooleanWrapper(
            WatchVariable watchVar,
            WatchVariableControl watchVarControl,
            bool?displayAsInverted)
            : base(watchVar, watchVarControl, DEFAULT_DISPLAY_TYPE, DEFAULT_ROUNDING_LIMIT, DEFAULT_DISPLAY_AS_HEX, true)
        {
            _displayAsCheckbox = true;
            _displayAsInverted = displayAsInverted ?? false;

            AddBooleanContextMenuStripItems();
        }
Beispiel #13
0
        protected WatchVariableWrapper(WatchVariable watchVar, WatchVariableControl watchVarControl, bool useCheckbox = false)
        {
            _watchVar = watchVar;
            _watchVarControl = watchVarControl;

            _startsAsCheckbox = useCheckbox;
            _contextMenuStrip = new BetterContextMenuStrip();
            AddContextMenuStripItems();
            AddExternalContextMenuStripItems();
            AddCustomContextMenuStripItems();
        }
Beispiel #14
0
        public WatchVariableAngleWrapper(
            WatchVariable watchVar,
            WatchVariableControl watchVarControl)
            : base(watchVar, watchVarControl, 0)
        {
            _signed                   = _watchVar.SignedType.Value;
            _angleUnitType            = AngleUnitType.InGameUnits;
            _truncateToMultipleOf16   = false;
            _constrainToOneRevolution = false;

            AddAngleContextMenuStripItems();
        }
Beispiel #15
0
        public WatchVariableControlPrecursor(
            string typeName    = null,
            string specialType = null,
            BaseAddressTypeEnum baseAddressType = BaseAddressTypeEnum.Relative,
            uint?offsetUS                  = null,
            uint?offsetJP                  = null,
            uint?offsetSH                  = null,
            uint?offsetEU                  = null,
            uint?offsetDefault             = null,
            uint?mask                      = null,
            int?shift                      = null,
            bool handleMapping             = true,
            string name                    = null,
            WatchVariableSubclass subclass = WatchVariableSubclass.Number,
            Color?backgroundColor          = null,
            Type displayType               = null,
            int?roundingLimit              = null,
            bool?useHex                    = null,
            bool?invertBool                = null,
            bool?isYaw                     = null,
            Coordinate?coordinate          = null,
            List <VariableGroup> groupList = null,
            List <uint> fixedAddresses     = null)
        {
            WatchVar =
                new WatchVariable(
                    name,
                    typeName,
                    specialType,
                    baseAddressType,
                    offsetUS,
                    offsetJP,
                    offsetSH,
                    offsetEU,
                    offsetDefault,
                    mask,
                    shift,
                    handleMapping);
            Name            = name;
            Subclass        = subclass;
            BackgroundColor = backgroundColor;
            DisplayType     = displayType;
            RoundingLimit   = roundingLimit;
            UseHex          = useHex;
            InvertBool      = invertBool;
            IsYaw           = isYaw;
            Coordinate      = coordinate;
            GroupList       = groupList;
            FixedAddresses  = fixedAddresses;

            VerifyState();
        }
Beispiel #16
0
        public static WatchVariableWrapper CreateWatchVariableWrapper(
            WatchVariable watchVar,
            WatchVariableControl watchVarControl,
            WatchVariableSubclass subclass,
            Type displayType,
            int?roundingLimit,
            bool?useHex,
            bool?invertBool,
            bool?isYaw,
            Coordinate?coordinate)
        {
            switch (subclass)
            {
            case WatchVariableSubclass.String:
                return(new WatchVariableStringWrapper(watchVar, watchVarControl));

            case WatchVariableSubclass.Number:
                return(new WatchVariableNumberWrapper(
                           watchVar,
                           watchVarControl,
                           displayType,
                           roundingLimit,
                           useHex,
                           DEFAULT_USE_CHECKBOX,
                           coordinate));

            case WatchVariableSubclass.Angle:
                return(new WatchVariableAngleWrapper(watchVar, watchVarControl, displayType, isYaw));

            case WatchVariableSubclass.Object:
                return(new WatchVariableObjectWrapper(watchVar, watchVarControl));

            case WatchVariableSubclass.Triangle:
                return(new WatchVariableTriangleWrapper(watchVar, watchVarControl));

            case WatchVariableSubclass.Address:
                return(new WatchVariableAddressWrapper(watchVar, watchVarControl));

            case WatchVariableSubclass.Boolean:
                return(new WatchVariableBooleanWrapper(watchVar, watchVarControl, invertBool));

            default:
                throw new ArgumentOutOfRangeException();
            }
        }
Beispiel #17
0
 public WatchVariableControlPrecursor(
     string name,
     WatchVariable watchVar,
     WatchVariableSubclass subclass,
     Color?backgroundColor,
     bool?useHex,
     bool?invertBool,
     WatchVariableCoordinate?coordinate,
     List <VariableGroup> groupList)
 {
     _name            = name;
     _watchVar        = watchVar;
     _subclass        = subclass;
     _backgroundColor = backgroundColor;
     _useHex          = useHex;
     _invertBool      = invertBool;
     _coordinate      = coordinate;
     _groupList       = groupList;
 }
Beispiel #18
0
        private void AddItemsToContextMenuStrip()
        {
            ToolStripMenuItem resetVariablesItem = new ToolStripMenuItem("Reset Variables");

            resetVariablesItem.Click += (sender, e) => ResetVariables();

            ToolStripMenuItem clearAllButHighlightedItem = new ToolStripMenuItem("Clear All But Highlighted");

            clearAllButHighlightedItem.Click += (sender, e) => ClearAllButHighlightedVariables();

            ToolStripMenuItem fixVerticalScrollItem = new ToolStripMenuItem("Fix Vertical Scroll");

            fixVerticalScrollItem.Click += (sender, e) => FixVerticalScroll();

            ToolStripMenuItem addCustomVariablesItem = new ToolStripMenuItem("Add Custom Variables");

            addCustomVariablesItem.Click += (sender, e) =>
            {
                VariableCreationForm form = new VariableCreationForm();
                form.Initialize(this);
                form.Show();
            };

            ToolStripMenuItem addMappingVariablesItem = new ToolStripMenuItem("Add Mapping Variables");

            addMappingVariablesItem.Click += (sender, e) => AddVariables(MappingConfig.GetVariables());

            ToolStripMenuItem addDummyVariableItem = new ToolStripMenuItem("Add Dummy Variable...");
            List <string>     types = new List <string>(TypeUtilities.InGameTypeList);

            types.Add("string");
            foreach (string typeString in types)
            {
                ToolStripMenuItem typeItem = new ToolStripMenuItem(typeString);
                addDummyVariableItem.DropDownItems.Add(typeItem);
                typeItem.Click += (sender, e) =>
                {
                    int numEntries = 1;
                    if (KeyboardUtilities.IsCtrlHeld())
                    {
                        string numEntriesString = DialogUtilities.GetStringFromDialog(labelText: "Enter Num Vars:");
                        if (numEntriesString == null)
                        {
                            return;
                        }
                        int parsed = ParsingUtilities.ParseInt(numEntriesString);
                        parsed     = Math.Max(parsed, 0);
                        numEntries = parsed;
                    }

                    List <WatchVariableControl> controls = new List <WatchVariableControl>();
                    for (int i = 0; i < numEntries; i++)
                    {
                        string        specialType   = WatchVariableSpecialUtilities.AddDummyEntry(typeString);
                        WatchVariable watchVariable =
                            new WatchVariable(
                                name: specialType,
                                memoryTypeName: null,
                                specialType: specialType,
                                baseAddressType: BaseAddressTypeEnum.None,
                                offsetUS: null,
                                offsetJP: null,
                                offsetSH: null,
                                offsetEU: null,
                                offsetDefault: null,
                                mask: null,
                                shift: null,
                                handleMapping: true);
                        WatchVariableControlPrecursor precursor =
                            new WatchVariableControlPrecursor(
                                name: specialType,
                                watchVar: watchVariable,
                                subclass: typeString == "string" ? WatchVariableSubclass.String : WatchVariableSubclass.Number,
                                backgroundColor: null,
                                displayType: null,
                                roundingLimit: null,
                                useHex: null,
                                invertBool: null,
                                isYaw: null,
                                coordinate: null,
                                groupList: new List <VariableGroup>()
                        {
                            VariableGroup.Custom
                        });
                        WatchVariableControl control = precursor.CreateWatchVariableControl();
                        controls.Add(control);
                    }
                    AddVariables(controls);
                };
            }

            ToolStripMenuItem openSaveClearItem = new ToolStripMenuItem("Open / Save / Clear ...");

            ControlUtilities.AddDropDownItems(
                openSaveClearItem,
                new List <string>()
            {
                "Open", "Open as Pop Out", "Save in Place", "Save As", "Clear"
            },
                new List <Action>()
            {
                () => OpenVariables(),
                () => OpenVariablesAsPopOut(),
                () => SaveVariablesInPlace(),
                () => SaveVariables(),
                () => ClearVariables(),
            });

            ToolStripMenuItem doToAllVariablesItem = new ToolStripMenuItem("Do to all variables...");

            WatchVariableSelectionUtilities.CreateSelectionToolStripItems(
                () => GetCurrentVariableControls(), this)
            .ForEach(item => doToAllVariablesItem.DropDownItems.Add(item));

            ToolStripMenuItem filterVariablesItem = new ToolStripMenuItem("Filter Variables...");

            _filteringDropDownItems = _allGroups.ConvertAll(varGroup => CreateFilterItem(varGroup));
            UpdateFilterItemCheckedStatuses();
            _filteringDropDownItems.ForEach(item => filterVariablesItem.DropDownItems.Add(item));
            filterVariablesItem.DropDown.MouseEnter += (sender, e) =>
            {
                filterVariablesItem.DropDown.AutoClose = false;
            };
            filterVariablesItem.DropDown.MouseLeave += (sender, e) =>
            {
                filterVariablesItem.DropDown.AutoClose = true;
                filterVariablesItem.DropDown.Close();
            };

            ContextMenuStrip.Items.Add(resetVariablesItem);
            ContextMenuStrip.Items.Add(clearAllButHighlightedItem);
            ContextMenuStrip.Items.Add(fixVerticalScrollItem);
            ContextMenuStrip.Items.Add(addCustomVariablesItem);
            ContextMenuStrip.Items.Add(addMappingVariablesItem);
            ContextMenuStrip.Items.Add(addDummyVariableItem);
            ContextMenuStrip.Items.Add(openSaveClearItem);
            ContextMenuStrip.Items.Add(doToAllVariablesItem);
            ContextMenuStrip.Items.Add(filterVariablesItem);
        }
 public WatchVariableStringWrapper(
     WatchVariable watchVar,
     WatchVariableControl watchVarControl)
     : base(watchVar, watchVarControl, DEFAULT_USE_CHECKBOX)
 {
 }
Beispiel #20
0
        public WatchVariableControl(
            WatchVariableControlPrecursor watchVarPrecursor,
            string name,
            WatchVariable watchVar,
            WatchVariableSubclass subclass,
            Color?backgroundColor,
            bool?useHex,
            bool?invertBool,
            WatchVariableCoordinate?coordinate,
            List <VariableGroup> groupList)
        {
            // Store the precursor
            _watchVarPrecursor = watchVarPrecursor;

            // Initialize main fields
            _varName         = name;
            GroupList        = groupList;
            _showBorder      = false;
            _editMode        = false;
            _renameMode      = false;
            FixedAddressList = null;

            // Initialize color fields
            _baseColor      = backgroundColor ?? DEFAULT_COLOR;
            _currentColor   = _baseColor;
            _isFlashing     = false;
            _flashStartTime = DateTime.Now;

            // Initialize size fields
            _variableNameWidth  = VariableNameWidth;
            _variableValueWidth = VariableValueWidth;
            _variableHeight     = VariableHeight;

            // Create controls
            InitializeBase();
            _namePanel      = CreateNamePanel();
            _nameTextBox    = CreateNameTextBox();
            _lockPictureBox = CreateLockPictureBox();
            _pinPictureBox  = CreatePinPictureBox();
            _valueTextBox   = CreateValueTextBox();
            _valueCheckBox  = CreateValueCheckBox();

            // Add controls to their containers
            base.Controls.Add(_valueTextBox, 1, 0);
            base.Controls.Add(_valueCheckBox, 1, 0);
            base.Controls.Add(_namePanel, 0, 0);
            _namePanel.Controls.Add(_pinPictureBox);
            _namePanel.Controls.Add(_lockPictureBox);
            _namePanel.Controls.Add(_nameTextBox);

            // Create var x
            _watchVarWrapper = WatchVariableWrapper.CreateWatchVariableWrapper(
                watchVar, this, subclass, useHex, invertBool, coordinate);

            // Initialize context menu strip
            _valueTextboxOriginalContextMenuStrip = _valueTextBox.ContextMenuStrip;
            _nameTextboxOriginalContextMenuStrip  = _nameTextBox.ContextMenuStrip;
            ContextMenuStrip = _watchVarWrapper.GetContextMenuStrip();
            _nameTextBox.ContextMenuStrip  = ContextMenuStrip;
            _valueTextBox.ContextMenuStrip = ContextMenuStrip;

            // Set whether to start as a checkbox
            SetUseCheckbox(_watchVarWrapper.StartsAsCheckbox());

            // Add functions
            _namePanel.Click          += (sender, e) => OnNameTextBoxClick();
            _nameTextBox.Click        += (sender, e) => OnNameTextBoxClick();
            _nameTextBox.Leave        += (sender, e) => { RenameMode = false; };
            _nameTextBox.KeyDown      += (sender, e) => OnNameTextValueKeyDown(e);
            _valueTextBox.DoubleClick += (sender, e) => { EditMode = true; };
            _valueTextBox.KeyDown     += (sender, e) => OnValueTextValueKeyDown(e);
            _valueTextBox.Leave       += (sender, e) => { EditMode = false; };
            _valueCheckBox.Click      += (sender, e) => OnCheckboxClick();
        }
        public WatchVariableControl(
            WatchVariableControlPrecursor watchVarPrecursor,
            string name,
            WatchVariable watchVar,
            WatchVariableSubclass subclass,
            Color?backgroundColor,
            Type displayType,
            int?roundingLimit,
            bool?useHex,
            bool?invertBool,
            bool?isYaw,
            Coordinate?coordinate,
            List <VariableGroup> groupList,
            List <uint> fixedAddresses)
        {
            // Initialize controls
            InitializeComponent();

            _tableLayoutPanel.BorderColor = Color.Red;
            _tableLayoutPanel.BorderWidth = 3;
            _nameTextBox.Text             = name;

            // Store the precursor
            WatchVarPrecursor = watchVarPrecursor;

            // Initialize main fields
            _varName    = name;
            GroupList   = groupList;
            _editMode   = false;
            _renameMode = false;
            IsSelected  = false;

            List <uint> copy1 = fixedAddresses == null ? null : new List <uint>(fixedAddresses);

            _defaultFixedAddressListGetter = () => copy1;
            List <uint> copy2 = fixedAddresses == null ? null : new List <uint>(fixedAddresses);

            FixedAddressListGetter = () => copy2;

            // Initialize color fields
            _initialBaseColor = backgroundColor ?? DEFAULT_COLOR;
            _baseColor        = _initialBaseColor;
            _currentColor     = _baseColor;
            _isFlashing       = false;
            _flashStartTime   = DateTime.Now;

            // Initialize flush/size fields
            _rightFlush         = true;
            _variableNameWidth  = 0;
            _variableValueWidth = 0;
            _variableHeight     = 0;
            _variableTextSize   = 0;
            _variableOffset     = 0;

            // Create watch var wrapper
            WatchVarWrapper = WatchVariableWrapper.CreateWatchVariableWrapper(
                watchVar, this, subclass, displayType, roundingLimit, useHex, invertBool, isYaw, coordinate);

            // Set whether to start as a checkbox
            SetUseCheckbox(WatchVarWrapper.StartsAsCheckbox());

            // Add functions
            _namePanel.Click       += (sender, e) => OnVariableClick();
            _namePanel.DoubleClick += (sender, e) => OnNameTextBoxDoubleClick();

            _nameTextBox.Click       += (sender, e) => OnVariableClick();
            _nameTextBox.DoubleClick += (sender, e) => OnNameTextBoxDoubleClick();
            _nameTextBox.Leave       += (sender, e) => { RenameMode = false; };
            _nameTextBox.KeyDown     += (sender, e) => OnNameTextValueKeyDown(e);

            _valueTextBox.Click       += (sender, e) => _watchVariablePanel.UnselectAllVariables();
            _valueTextBox.DoubleClick += (sender, e) => { EditMode = true; };
            _valueTextBox.KeyDown     += (sender, e) => OnValueTextValueKeyDown(e);
            _valueTextBox.Leave       += (sender, e) => { EditMode = false; };

            _valueCheckBox.Click += (sender, e) => OnCheckboxClick();

            MouseDown += ShowMainContextMenu;
            _valueTextBox.MouseDown += ShowMainContextMenu;
            _namePanel.MouseDown    += ShowMainContextMenu;
            _valuePanel.MouseDown   += ShowMainContextMenu;

            _nameTextBox.MouseDown += (sender, e) =>
            {
                if (e.Button == MouseButtons.Right)
                {
                    if (RenameMode)
                    {
                        ShowRenameContextMenu();
                    }
                    else
                    {
                        ShowContextMenu();
                    }
                }
            };

            _valueTextBox.ContextMenu = _nameTextBox.ContextMenu = DummyContextMenu;
        }