2019-04-29 23:34:09 +00:00
|
|
|
|
/*
|
|
|
|
|
* Copyright 2019 faddenSoft
|
|
|
|
|
*
|
|
|
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
|
|
* you may not use this file except in compliance with the License.
|
|
|
|
|
* You may obtain a copy of the License at
|
|
|
|
|
*
|
|
|
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
|
*
|
|
|
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
|
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
|
|
* See the License for the specific language governing permissions and
|
|
|
|
|
* limitations under the License.
|
|
|
|
|
*/
|
|
|
|
|
using System;
|
2019-06-12 21:17:24 +00:00
|
|
|
|
using System.Collections;
|
2019-04-29 23:34:09 +00:00
|
|
|
|
using System.Collections.Generic;
|
2019-06-10 01:09:00 +00:00
|
|
|
|
using System.Collections.ObjectModel;
|
2019-05-09 23:13:20 +00:00
|
|
|
|
using System.ComponentModel;
|
2019-04-29 23:34:09 +00:00
|
|
|
|
using System.Diagnostics;
|
2019-06-22 21:41:09 +00:00
|
|
|
|
using System.IO;
|
2019-05-28 21:23:17 +00:00
|
|
|
|
using System.Reflection;
|
2019-05-09 23:13:20 +00:00
|
|
|
|
using System.Runtime.CompilerServices;
|
2019-04-29 23:34:09 +00:00
|
|
|
|
using System.Windows;
|
|
|
|
|
using System.Windows.Controls;
|
2019-07-14 22:11:27 +00:00
|
|
|
|
using System.Windows.Controls.Primitives;
|
2019-04-29 23:34:09 +00:00
|
|
|
|
using System.Windows.Data;
|
|
|
|
|
using System.Windows.Input;
|
|
|
|
|
using System.Windows.Media;
|
2021-10-15 22:36:56 +00:00
|
|
|
|
using System.Windows.Media.Imaging;
|
2019-04-29 23:34:09 +00:00
|
|
|
|
|
2019-06-20 22:10:35 +00:00
|
|
|
|
using CommonUtil;
|
2019-06-04 23:07:04 +00:00
|
|
|
|
using CommonWPF;
|
|
|
|
|
|
2019-07-20 20:28:10 +00:00
|
|
|
|
namespace SourceGen.WpfGui {
|
2019-04-29 23:34:09 +00:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Interaction logic for MainWindow.xaml
|
|
|
|
|
/// </summary>
|
2019-05-09 23:13:20 +00:00
|
|
|
|
public partial class MainWindow : Window, INotifyPropertyChanged {
|
|
|
|
|
/// <summary>
|
2019-05-28 01:46:09 +00:00
|
|
|
|
/// Disassembled code display list provided to XAML.
|
|
|
|
|
/// </summary>
|
|
|
|
|
public DisplayList CodeDisplayList { get; private set; }
|
|
|
|
|
|
2019-07-06 22:51:57 +00:00
|
|
|
|
/// <summary>
|
2019-06-09 21:24:46 +00:00
|
|
|
|
/// Version string, for display.
|
|
|
|
|
/// </summary>
|
|
|
|
|
public string ProgramVersionString {
|
|
|
|
|
get { return App.ProgramVersion.ToString(); }
|
|
|
|
|
}
|
2019-06-08 00:25:04 +00:00
|
|
|
|
|
2019-07-19 18:41:18 +00:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Text for status bar at bottom of window.
|
|
|
|
|
/// </summary>
|
|
|
|
|
public string StatusBarText {
|
|
|
|
|
get { return mStatusBarText; }
|
|
|
|
|
set { mStatusBarText = value; OnPropertyChanged(); }
|
|
|
|
|
}
|
|
|
|
|
private string mStatusBarText;
|
|
|
|
|
|
2019-11-20 02:18:41 +00:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Text for code/data breakdown string.
|
|
|
|
|
/// </summary>
|
|
|
|
|
public string ByteCountText {
|
|
|
|
|
get { return mByteCountText; }
|
|
|
|
|
set { mByteCountText = value; OnPropertyChanged(); }
|
|
|
|
|
}
|
|
|
|
|
private string mByteCountText;
|
|
|
|
|
|
2019-07-07 00:24:42 +00:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Width of long comment fields.
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <remarks>
|
|
|
|
|
/// We need this to be the sum of the leftmost four columns. If we don't set it, the
|
|
|
|
|
/// text may be cut off, or -- worse -- extend off the side of the window. If it
|
|
|
|
|
/// extends off the end, a scrollbar appears that will scroll the GridView contents
|
|
|
|
|
/// without scrolling the GridView headers, which looks terrible.
|
|
|
|
|
///
|
|
|
|
|
/// XAML doesn't do math, so we need to do it here, whenever the column widths change.
|
|
|
|
|
/// </remarks>
|
|
|
|
|
public double LongCommentWidth {
|
|
|
|
|
get { return mLongCommentWidth; }
|
2019-07-16 21:52:08 +00:00
|
|
|
|
set { mLongCommentWidth = value; OnPropertyChanged(); }
|
2019-07-07 00:24:42 +00:00
|
|
|
|
}
|
|
|
|
|
private double mLongCommentWidth;
|
|
|
|
|
|
2020-09-05 00:49:28 +00:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Property backing the "show cycle counts" button in the toolbar.
|
|
|
|
|
/// </summary>
|
|
|
|
|
public bool DoShowCycleCounts {
|
|
|
|
|
get { return AppSettings.Global.GetBool(AppSettings.FMT_SHOW_CYCLE_COUNTS, false); }
|
|
|
|
|
set {
|
|
|
|
|
// We get called when app settings change, so we have to be a little careful to
|
|
|
|
|
// avoid an infinite loop. We need to be called to keep the toolbar in sync.
|
|
|
|
|
bool curVal = AppSettings.Global.GetBool(AppSettings.FMT_SHOW_CYCLE_COUNTS, false);
|
|
|
|
|
if (curVal != value) {
|
2021-06-03 22:03:22 +00:00
|
|
|
|
// TODO: this works around a bug where, if you change the column widths and
|
|
|
|
|
// then click the toolbar button, the widths revert. The basic problem is
|
|
|
|
|
// that we don't pull the widths into the settings object until we try to
|
|
|
|
|
// save the settings file, so ApplyAppSettings() is restoring the values from
|
|
|
|
|
// the AppSettings object. Need to fix this more robustly.
|
|
|
|
|
CaptureColumnWidths();
|
|
|
|
|
|
2020-09-05 00:49:28 +00:00
|
|
|
|
AppSettings.Global.SetBool(AppSettings.FMT_SHOW_CYCLE_COUNTS, value);
|
|
|
|
|
mMainCtrl.ApplyAppSettings();
|
|
|
|
|
}
|
|
|
|
|
OnPropertyChanged();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2019-07-15 22:32:27 +00:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Set to true if the DEBUG menu should be visible on the main menu strip.
|
|
|
|
|
/// </summary>
|
|
|
|
|
public bool ShowDebugMenu {
|
|
|
|
|
get { return mShowDebugMenu; }
|
2019-07-16 21:52:08 +00:00
|
|
|
|
set { mShowDebugMenu = value; OnPropertyChanged(); }
|
|
|
|
|
}
|
|
|
|
|
bool mShowDebugMenu;
|
|
|
|
|
|
|
|
|
|
|
2019-07-15 22:32:27 +00:00
|
|
|
|
|
2019-05-28 01:46:09 +00:00
|
|
|
|
/// <summary>
|
2019-06-08 00:25:04 +00:00
|
|
|
|
/// Reference to controller object.
|
2019-05-28 01:46:09 +00:00
|
|
|
|
/// </summary>
|
|
|
|
|
private MainController mMainCtrl;
|
|
|
|
|
|
2019-06-08 00:25:04 +00:00
|
|
|
|
// Handle to protected ListView.SetSelectedItems() method
|
2019-05-28 21:23:17 +00:00
|
|
|
|
private MethodInfo listViewSetSelectedItems;
|
2019-05-05 23:50:28 +00:00
|
|
|
|
|
2019-10-13 00:23:32 +00:00
|
|
|
|
// Color theme.
|
|
|
|
|
public enum ColorScheme { Unknown = 0, Light, Dark };
|
|
|
|
|
private ColorScheme mColorScheme;
|
|
|
|
|
private ResourceDictionary mLightTheme;
|
|
|
|
|
private ResourceDictionary mDarkTheme;
|
|
|
|
|
|
2021-10-15 22:36:56 +00:00
|
|
|
|
// Daily tips.
|
|
|
|
|
private DailyTips mDailyTips;
|
|
|
|
|
|
2019-06-08 22:48:44 +00:00
|
|
|
|
|
2019-04-29 23:34:09 +00:00
|
|
|
|
public MainWindow() {
|
2019-07-21 00:27:39 +00:00
|
|
|
|
Debug.WriteLine("START at " + DateTime.Now.ToLocalTime());
|
2019-04-29 23:34:09 +00:00
|
|
|
|
InitializeComponent();
|
2019-05-05 23:50:28 +00:00
|
|
|
|
|
Allow explicit widths in project/platform symbols, part 3
Implement multi-byte project/platform symbols by filling out a table
of addresses. Each symbol is "painted" into the table, replacing
an existing entry if the new entry has higher priority. This allows
us to handle overlapping entries, giving boosted priority to platform
symbols that are defined in .sym65 files loaded later.
The bounds on project/platform symbols are now rigidly defined. If
the "nearby" feature is enabled, references to SYM-1 will be picked
up, but we won't go hunting for SYM+1 unless the symbol is at least
two bytes wide.
The cost of adding a symbol to the symbol table is about the same,
but we don't have a quick way to remove a symbol.
Previously, if two platform symbols had the same value, the symbol
with the alphabetically lowest label would win. Now, the symbol
defined in the most-recently-loaded file wins. (If you define two
symbols with the same value in the same file, it's still resolved
alphabetically.) This allows the user to pick the winner by
arranging the load order of the platform symbol files.
Platform symbols now keep a reference to the file ident of the
symbol file that defined them, so we can show the symbols's source
in the Info panel.
These changes altered the behavior of test 2008-address-changes,
which includes some tests on external addresses that are close to
labeled internal addresses. The previous behavior essentially
treated user labels as being 3 bytes wide and extending outside the
file bounds, which was mildly convenient on occasion but felt a
little skanky. (We could do with a way to define external symbols
relative to internal symbols, for things like the source address of
code that gets relocated.)
Also, re-enabled some unit tests.
Also, added a bit of identifying stuff to CrashLog.txt.
2019-10-02 23:26:05 +00:00
|
|
|
|
// Prep the crash handler.
|
|
|
|
|
Misc.AppIdent = "6502bench SourceGen v" + App.ProgramVersion.ToString();
|
2019-07-21 00:27:39 +00:00
|
|
|
|
AppDomain.CurrentDomain.UnhandledException +=
|
Allow explicit widths in project/platform symbols, part 3
Implement multi-byte project/platform symbols by filling out a table
of addresses. Each symbol is "painted" into the table, replacing
an existing entry if the new entry has higher priority. This allows
us to handle overlapping entries, giving boosted priority to platform
symbols that are defined in .sym65 files loaded later.
The bounds on project/platform symbols are now rigidly defined. If
the "nearby" feature is enabled, references to SYM-1 will be picked
up, but we won't go hunting for SYM+1 unless the symbol is at least
two bytes wide.
The cost of adding a symbol to the symbol table is about the same,
but we don't have a quick way to remove a symbol.
Previously, if two platform symbols had the same value, the symbol
with the alphabetically lowest label would win. Now, the symbol
defined in the most-recently-loaded file wins. (If you define two
symbols with the same value in the same file, it's still resolved
alphabetically.) This allows the user to pick the winner by
arranging the load order of the platform symbol files.
Platform symbols now keep a reference to the file ident of the
symbol file that defined them, so we can show the symbols's source
in the Info panel.
These changes altered the behavior of test 2008-address-changes,
which includes some tests on external addresses that are close to
labeled internal addresses. The previous behavior essentially
treated user labels as being 3 bytes wide and extending outside the
file bounds, which was mildly convenient on occasion but felt a
little skanky. (We could do with a way to define external symbols
relative to internal symbols, for things like the source address of
code that gets relocated.)
Also, re-enabled some unit tests.
Also, added a bit of identifying stuff to CrashLog.txt.
2019-10-02 23:26:05 +00:00
|
|
|
|
new UnhandledExceptionEventHandler(Misc.CrashReporter);
|
2019-07-21 00:27:39 +00:00
|
|
|
|
|
2019-05-28 21:23:17 +00:00
|
|
|
|
listViewSetSelectedItems = codeListView.GetType().GetMethod("SetSelectedItems",
|
|
|
|
|
BindingFlags.NonPublic | BindingFlags.Instance);
|
|
|
|
|
Debug.Assert(listViewSetSelectedItems != null);
|
|
|
|
|
|
2019-05-09 23:13:20 +00:00
|
|
|
|
this.DataContext = this;
|
2019-05-11 17:16:54 +00:00
|
|
|
|
|
2019-10-13 00:23:32 +00:00
|
|
|
|
mLightTheme = new ResourceDictionary() {
|
|
|
|
|
Source = new Uri("/Res/Theme_Light.xaml", UriKind.Relative)
|
|
|
|
|
};
|
|
|
|
|
mDarkTheme = new ResourceDictionary() {
|
|
|
|
|
Source = new Uri("/Res/Theme_Dark.xaml", UriKind.Relative)
|
|
|
|
|
};
|
|
|
|
|
Resources.MergedDictionaries.Add(mLightTheme);
|
|
|
|
|
mColorScheme = ColorScheme.Light;
|
|
|
|
|
|
|
|
|
|
|
2019-05-28 01:46:09 +00:00
|
|
|
|
CodeDisplayList = new DisplayList();
|
|
|
|
|
codeListView.ItemsSource = CodeDisplayList;
|
2019-06-20 22:10:35 +00:00
|
|
|
|
// https://dlaa.me/blog/post/9425496 to re-auto-size after data added (this may
|
|
|
|
|
// not work with virtual items)
|
2019-05-28 01:46:09 +00:00
|
|
|
|
|
2019-07-14 22:11:27 +00:00
|
|
|
|
// Obscure tweak to make the arrow keys work right after a change.
|
|
|
|
|
codeListView.ItemContainerGenerator.StatusChanged +=
|
|
|
|
|
ItemContainerGenerator_StatusChanged;
|
|
|
|
|
|
2019-05-28 01:46:09 +00:00
|
|
|
|
mMainCtrl = new MainController(this);
|
2019-05-12 00:36:50 +00:00
|
|
|
|
|
2019-07-19 18:41:18 +00:00
|
|
|
|
StatusBarText = Res.Strings.STATUS_READY;
|
|
|
|
|
|
2019-06-04 23:07:04 +00:00
|
|
|
|
AddMultiKeyGestures();
|
|
|
|
|
|
2019-06-19 23:31:56 +00:00
|
|
|
|
// Get an event when the splitters move. Because of the way things are set up, it's
|
|
|
|
|
// actually best to get an event when the grid row/column sizes change.
|
|
|
|
|
// https://stackoverflow.com/a/22495586/294248
|
|
|
|
|
DependencyPropertyDescriptor widthDesc = DependencyPropertyDescriptor.FromProperty(
|
|
|
|
|
ColumnDefinition.WidthProperty, typeof(ItemsControl));
|
|
|
|
|
DependencyPropertyDescriptor heightDesc = DependencyPropertyDescriptor.FromProperty(
|
|
|
|
|
RowDefinition.HeightProperty, typeof(ItemsControl));
|
|
|
|
|
// main window, left/right panels
|
|
|
|
|
widthDesc.AddValueChanged(triptychGrid.ColumnDefinitions[0], GridSizeChanged);
|
|
|
|
|
widthDesc.AddValueChanged(triptychGrid.ColumnDefinitions[4], GridSizeChanged);
|
|
|
|
|
// references vs. notes
|
|
|
|
|
heightDesc.AddValueChanged(leftPanel.RowDefinitions[0], GridSizeChanged);
|
|
|
|
|
heightDesc.AddValueChanged(rightPanel.RowDefinitions[0], GridSizeChanged);
|
|
|
|
|
|
2021-06-03 22:03:22 +00:00
|
|
|
|
// Add events that fire when column headers change size. Set this up for
|
|
|
|
|
// the DataGrids in the side windows.
|
2019-06-20 22:10:35 +00:00
|
|
|
|
PropertyDescriptor pd = DependencyPropertyDescriptor.FromProperty(
|
|
|
|
|
DataGridColumn.ActualWidthProperty, typeof(DataGridColumn));
|
|
|
|
|
AddColumnWidthChangeCallback(pd, referencesGrid);
|
|
|
|
|
AddColumnWidthChangeCallback(pd, notesGrid);
|
|
|
|
|
AddColumnWidthChangeCallback(pd, symbolsGrid);
|
|
|
|
|
|
2021-06-03 22:03:22 +00:00
|
|
|
|
// Also set this up for the column headers in the main ListView.
|
|
|
|
|
// cf. https://stackoverflow.com/a/56694219/294248
|
2019-06-20 22:10:35 +00:00
|
|
|
|
pd = DependencyPropertyDescriptor.FromProperty(
|
|
|
|
|
GridViewColumn.WidthProperty, typeof(GridViewColumn));
|
|
|
|
|
AddColumnWidthChangeCallback(pd, (GridView)codeListView.View);
|
2019-07-07 00:24:42 +00:00
|
|
|
|
|
|
|
|
|
UpdateLongCommentWidth();
|
2019-06-20 22:10:35 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private void AddColumnWidthChangeCallback(PropertyDescriptor pd, DataGrid dg) {
|
|
|
|
|
foreach (DataGridColumn col in dg.Columns) {
|
|
|
|
|
pd.AddValueChanged(col, ColumnWidthChanged);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
private void AddColumnWidthChangeCallback(PropertyDescriptor pd, GridView gv) {
|
|
|
|
|
foreach (GridViewColumn col in gv.Columns) {
|
|
|
|
|
pd.AddValueChanged(col, ColumnWidthChanged);
|
|
|
|
|
}
|
2019-05-09 23:13:20 +00:00
|
|
|
|
}
|
|
|
|
|
|
2019-06-04 23:07:04 +00:00
|
|
|
|
private void AddMultiKeyGestures() {
|
|
|
|
|
RoutedUICommand ruic;
|
|
|
|
|
|
2020-10-14 22:02:53 +00:00
|
|
|
|
ruic = (RoutedUICommand)FindResource("TagAsCodeStartPointCmd");
|
2019-06-04 23:07:04 +00:00
|
|
|
|
ruic.InputGestures.Add(
|
|
|
|
|
new MultiKeyInputGesture(new KeyGesture[] {
|
|
|
|
|
new KeyGesture(Key.H, ModifierKeys.Control, "Ctrl+H"),
|
|
|
|
|
new KeyGesture(Key.C, ModifierKeys.Control, "Ctrl+C")
|
|
|
|
|
}));
|
2020-10-14 22:02:53 +00:00
|
|
|
|
ruic = (RoutedUICommand)FindResource("TagAsCodeStopPointCmd");
|
2019-06-04 23:07:04 +00:00
|
|
|
|
ruic.InputGestures.Add(
|
|
|
|
|
new MultiKeyInputGesture(new KeyGesture[] {
|
|
|
|
|
new KeyGesture(Key.H, ModifierKeys.Control, "Ctrl+H"),
|
|
|
|
|
new KeyGesture(Key.D, ModifierKeys.Control, "Ctrl+D")
|
|
|
|
|
}));
|
2020-10-14 22:02:53 +00:00
|
|
|
|
ruic = (RoutedUICommand)FindResource("TagAsInlineDataCmd");
|
2019-06-04 23:07:04 +00:00
|
|
|
|
ruic.InputGestures.Add(
|
|
|
|
|
new MultiKeyInputGesture(new KeyGesture[] {
|
|
|
|
|
new KeyGesture(Key.H, ModifierKeys.Control, "Ctrl+H"),
|
|
|
|
|
new KeyGesture(Key.I, ModifierKeys.Control, "Ctrl+I")
|
|
|
|
|
}));
|
2020-10-14 22:02:53 +00:00
|
|
|
|
ruic = (RoutedUICommand)FindResource("RemoveAnalyzerTagsCmd");
|
2019-06-04 23:07:04 +00:00
|
|
|
|
ruic.InputGestures.Add(
|
|
|
|
|
new MultiKeyInputGesture(new KeyGesture[] {
|
|
|
|
|
new KeyGesture(Key.H, ModifierKeys.Control, "Ctrl+H"),
|
|
|
|
|
new KeyGesture(Key.R, ModifierKeys.Control, "Ctrl+R")
|
|
|
|
|
}));
|
|
|
|
|
}
|
2019-05-09 23:13:20 +00:00
|
|
|
|
|
2019-06-07 21:03:34 +00:00
|
|
|
|
private void CreateCodeListContextMenu() {
|
2019-06-22 21:41:09 +00:00
|
|
|
|
//// Find Actions menu.
|
|
|
|
|
//ItemCollection mainItems = this.appMenu.Items;
|
|
|
|
|
//foreach (object obj in mainItems) {
|
|
|
|
|
// if (!(obj is MenuItem)) {
|
|
|
|
|
// continue;
|
|
|
|
|
// }
|
|
|
|
|
// MenuItem mi = (MenuItem)obj;
|
|
|
|
|
// if (mi.Name.Equals("actionsMenu")) {
|
|
|
|
|
// actionsMenu = mi;
|
|
|
|
|
// break;
|
|
|
|
|
// }
|
|
|
|
|
//}
|
|
|
|
|
//Debug.Assert(actionsMenu != null);
|
2019-06-07 21:03:34 +00:00
|
|
|
|
|
|
|
|
|
// Clone the Actions menu into the codeListView context menu.
|
|
|
|
|
ContextMenu ctxt = this.codeListView.ContextMenu;
|
|
|
|
|
foreach (object item in actionsMenu.Items) {
|
|
|
|
|
if (item is MenuItem) {
|
|
|
|
|
MenuItem oldItem = (MenuItem)item;
|
|
|
|
|
MenuItem newItem = new MenuItem();
|
|
|
|
|
// I don't see a "clone" method, so just copy the fields we think we care about
|
|
|
|
|
newItem.Name = oldItem.Name;
|
|
|
|
|
newItem.Header = oldItem.Header;
|
|
|
|
|
newItem.Icon = oldItem.Icon;
|
|
|
|
|
newItem.InputGestureText = oldItem.InputGestureText;
|
|
|
|
|
newItem.Command = oldItem.Command;
|
|
|
|
|
ctxt.Items.Add(newItem);
|
|
|
|
|
} else if (item is Separator) {
|
|
|
|
|
ctxt.Items.Add(new Separator());
|
|
|
|
|
} else {
|
|
|
|
|
Debug.Assert(false, "Found weird thing in menu: " + item);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2019-05-09 23:13:20 +00:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// INotifyPropertyChanged event
|
|
|
|
|
/// </summary>
|
|
|
|
|
public event PropertyChangedEventHandler PropertyChanged;
|
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
|
/// Call this when a notification-worthy property changes value.
|
|
|
|
|
///
|
|
|
|
|
/// The CallerMemberName attribute puts the calling property's name in the first arg.
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <param name="propertyName">Name of property that changed.</param>
|
2019-05-28 21:23:17 +00:00
|
|
|
|
private void OnPropertyChanged([CallerMemberName] string propertyName = "") {
|
2019-05-09 23:13:20 +00:00
|
|
|
|
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
|
/// Which panel are we showing, launchPanel or codeListView?
|
|
|
|
|
/// </summary>
|
|
|
|
|
public bool ShowCodeListView {
|
2019-10-20 21:40:32 +00:00
|
|
|
|
get { return mShowCodeListView; }
|
2019-05-09 23:13:20 +00:00
|
|
|
|
set {
|
|
|
|
|
mShowCodeListView = value;
|
2019-05-28 21:23:17 +00:00
|
|
|
|
OnPropertyChanged("LaunchPanelVisibility");
|
|
|
|
|
OnPropertyChanged("CodeListVisibility");
|
2020-07-25 18:35:27 +00:00
|
|
|
|
if (value) {
|
|
|
|
|
// Put the focus on the list view. Doesn't select anything.
|
|
|
|
|
codeListView.Focus();
|
|
|
|
|
}
|
2019-05-09 23:13:20 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
2019-06-20 22:10:35 +00:00
|
|
|
|
private bool mShowCodeListView;
|
2019-05-09 23:13:20 +00:00
|
|
|
|
|
|
|
|
|
/// <summary>
|
2019-06-08 00:25:04 +00:00
|
|
|
|
/// Returns the visibility status of the launch panel.
|
2019-05-09 23:13:20 +00:00
|
|
|
|
/// (Intended for use from XAML.)
|
|
|
|
|
/// </summary>
|
|
|
|
|
public Visibility LaunchPanelVisibility {
|
2019-10-23 05:23:22 +00:00
|
|
|
|
get { return mShowCodeListView ? Visibility.Collapsed : Visibility.Visible; }
|
2019-05-09 23:13:20 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// <summary>
|
2019-06-08 00:25:04 +00:00
|
|
|
|
/// Returns the visibility status of the code ListView.
|
2019-05-09 23:13:20 +00:00
|
|
|
|
/// (Intended for use from XAML.)
|
|
|
|
|
/// </summary>
|
|
|
|
|
public Visibility CodeListVisibility {
|
2019-10-23 05:23:22 +00:00
|
|
|
|
get { return mShowCodeListView ? Visibility.Visible : Visibility.Collapsed; }
|
2019-05-09 23:13:20 +00:00
|
|
|
|
}
|
|
|
|
|
|
2019-06-27 00:11:58 +00:00
|
|
|
|
public FontFamily CodeListFontFamily {
|
|
|
|
|
get { return codeListView.FontFamily; }
|
|
|
|
|
}
|
|
|
|
|
public double CodeListFontSize {
|
|
|
|
|
get { return codeListView.FontSize; }
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public void SetCodeListFont(string familyName, int size) {
|
|
|
|
|
FontFamily fam = new FontFamily(familyName);
|
|
|
|
|
codeListView.FontFamily = fam;
|
|
|
|
|
codeListView.FontSize = size;
|
|
|
|
|
}
|
|
|
|
|
|
2019-06-19 23:31:56 +00:00
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
|
/// Handles source-initialized event. This happens before Loaded, before the window
|
|
|
|
|
/// is visible, which makes it a good time to set the size and position.
|
|
|
|
|
/// </summary>
|
|
|
|
|
private void Window_SourceInitialized(object sender, EventArgs e) {
|
|
|
|
|
mMainCtrl.WindowSourceInitialized();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
|
/// Handles window-loaded event. Window is ready to go, so we can start doing things
|
|
|
|
|
/// that involve user interaction.
|
|
|
|
|
/// </summary>
|
|
|
|
|
private void Window_Loaded(object sender, RoutedEventArgs e) {
|
|
|
|
|
mMainCtrl.WindowLoaded();
|
|
|
|
|
CreateCodeListContextMenu();
|
|
|
|
|
|
2021-10-15 22:36:56 +00:00
|
|
|
|
InitDailyTip();
|
|
|
|
|
|
2019-06-19 23:31:56 +00:00
|
|
|
|
#if DEBUG
|
|
|
|
|
// Get more info on CollectionChanged events that do not agree with current
|
|
|
|
|
// state of Items collection.
|
|
|
|
|
PresentationTraceSources.SetTraceLevel(codeListView.ItemContainerGenerator,
|
|
|
|
|
PresentationTraceLevel.High);
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
|
/// Handles window-close event. The user has an opportunity to cancel.
|
|
|
|
|
/// </summary>
|
|
|
|
|
private void Window_Closing(object sender, CancelEventArgs e) {
|
|
|
|
|
Debug.WriteLine("Main app window closing");
|
|
|
|
|
if (mMainCtrl == null) {
|
|
|
|
|
// early failure?
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
if (!mMainCtrl.WindowClosing()) {
|
|
|
|
|
e.Cancel = true;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2019-07-19 22:24:51 +00:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Cleans up state when MainController decides to close the project.
|
|
|
|
|
/// </summary>
|
|
|
|
|
public void ProjectClosing() {
|
|
|
|
|
// Clear this to release the memory.
|
|
|
|
|
CodeDisplayList.Clear();
|
|
|
|
|
|
2019-10-22 00:03:13 +00:00
|
|
|
|
// Clear these so we're not still showing them after the project closes.
|
|
|
|
|
SymbolsList.Clear();
|
|
|
|
|
NotesList.Clear();
|
2019-10-23 04:27:49 +00:00
|
|
|
|
ClearInfoPanel();
|
2019-07-19 22:24:51 +00:00
|
|
|
|
|
|
|
|
|
// If you open a new project while one is already open, the ListView apparently
|
|
|
|
|
// doesn't reset certain state, possibly because it's never asked to draw after
|
|
|
|
|
// the list is cleared. This results in the new project being open at the same
|
|
|
|
|
// line as the previous project. This is a little weird, so we reset it here.
|
|
|
|
|
CodeListView_SetTopIndex(0);
|
|
|
|
|
}
|
|
|
|
|
|
2019-06-12 01:45:08 +00:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Catch mouse-down events so we can treat the fourth mouse button as "back".
|
|
|
|
|
/// </summary>
|
|
|
|
|
private void Window_MouseDown(object sender, MouseButtonEventArgs e) {
|
|
|
|
|
if (e.ChangedButton == MouseButton.XButton1) {
|
2019-06-21 22:06:04 +00:00
|
|
|
|
if (mMainCtrl.CanNavigateBackward()) {
|
|
|
|
|
mMainCtrl.NavigateBackward();
|
|
|
|
|
}
|
2019-06-12 01:45:08 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2019-10-13 00:23:32 +00:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Sets the primary color scheme.
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <remarks>
|
|
|
|
|
/// H/T http://www.markodevcic.com/post/changing_wpf_themes_dynamically
|
|
|
|
|
/// </remarks>
|
|
|
|
|
public void SetColorScheme(ColorScheme newScheme) {
|
|
|
|
|
if (mColorScheme == newScheme) {
|
|
|
|
|
// nothing to do
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ResourceDictionary oldDict, newDict;
|
|
|
|
|
|
|
|
|
|
if (mColorScheme == ColorScheme.Light) {
|
|
|
|
|
oldDict = mLightTheme;
|
|
|
|
|
} else {
|
|
|
|
|
oldDict = mDarkTheme;
|
|
|
|
|
}
|
|
|
|
|
if (newScheme == ColorScheme.Light) {
|
|
|
|
|
newDict = mLightTheme;
|
|
|
|
|
} else {
|
|
|
|
|
newDict = mDarkTheme;
|
|
|
|
|
}
|
|
|
|
|
Debug.WriteLine("Changing color scheme from " + mColorScheme + " to " + newScheme +
|
|
|
|
|
" (dict count=" + Resources.MergedDictionaries.Count + ")");
|
|
|
|
|
|
|
|
|
|
Resources.MergedDictionaries.Remove(oldDict);
|
|
|
|
|
Resources.MergedDictionaries.Add(newDict);
|
|
|
|
|
mColorScheme = newScheme;
|
|
|
|
|
}
|
|
|
|
|
|
2019-06-19 23:31:56 +00:00
|
|
|
|
#region Window placement
|
|
|
|
|
|
|
|
|
|
//
|
2019-06-20 22:10:35 +00:00
|
|
|
|
// We record the location and size of the window, the sizes of the panels, and the
|
|
|
|
|
// widths of the various columns. These events may fire rapidly while the user is
|
|
|
|
|
// resizing them, so we just want to set a flag noting that a change has been made.
|
2019-06-19 23:31:56 +00:00
|
|
|
|
//
|
|
|
|
|
private void Window_LocationChanged(object sender, EventArgs e) {
|
2019-06-20 22:10:35 +00:00
|
|
|
|
//Debug.WriteLine("Main window location changed");
|
2019-06-19 23:31:56 +00:00
|
|
|
|
AppSettings.Global.Dirty = true;
|
|
|
|
|
}
|
|
|
|
|
private void Window_SizeChanged(object sender, SizeChangedEventArgs e) {
|
2019-06-20 22:10:35 +00:00
|
|
|
|
//Debug.WriteLine("Main window size changed");
|
2019-06-19 23:31:56 +00:00
|
|
|
|
AppSettings.Global.Dirty = true;
|
|
|
|
|
}
|
|
|
|
|
private void GridSizeChanged(object sender, EventArgs e) {
|
2019-10-23 04:27:49 +00:00
|
|
|
|
//Debug.WriteLine("Grid size change: " + sender);
|
2019-06-20 22:10:35 +00:00
|
|
|
|
AppSettings.Global.Dirty = true;
|
|
|
|
|
}
|
|
|
|
|
private void ColumnWidthChanged(object sender, EventArgs e) {
|
|
|
|
|
//Debug.WriteLine("Column width change " + sender);
|
2019-06-19 23:31:56 +00:00
|
|
|
|
AppSettings.Global.Dirty = true;
|
2019-07-07 00:24:42 +00:00
|
|
|
|
UpdateLongCommentWidth();
|
2019-06-19 23:31:56 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public double LeftPanelWidth {
|
|
|
|
|
get { return triptychGrid.ColumnDefinitions[0].ActualWidth; }
|
|
|
|
|
set { triptychGrid.ColumnDefinitions[0].Width = new GridLength(value); }
|
|
|
|
|
}
|
|
|
|
|
public double RightPanelWidth {
|
|
|
|
|
get { return triptychGrid.ColumnDefinitions[4].ActualWidth; }
|
|
|
|
|
set { triptychGrid.ColumnDefinitions[4].Width = new GridLength(value); }
|
|
|
|
|
}
|
|
|
|
|
public double ReferencesPanelHeight {
|
|
|
|
|
get { return leftPanel.RowDefinitions[0].ActualHeight; }
|
|
|
|
|
set {
|
|
|
|
|
// If you set the height to a pixel value, you lose the auto-sizing behavior,
|
|
|
|
|
// and the splitter will happily shove the bottom panel off the bottom of the
|
|
|
|
|
// main window. The trick is to use "star" units.
|
|
|
|
|
// Thanks: https://stackoverflow.com/q/35000893/294248
|
|
|
|
|
double totalHeight = leftPanel.RowDefinitions[0].ActualHeight +
|
|
|
|
|
leftPanel.RowDefinitions[2].ActualHeight;
|
2021-08-21 14:45:11 +00:00
|
|
|
|
if (totalHeight > value) {
|
|
|
|
|
leftPanel.RowDefinitions[0].Height = new GridLength(value, GridUnitType.Star);
|
|
|
|
|
leftPanel.RowDefinitions[2].Height = new GridLength(totalHeight - value,
|
|
|
|
|
GridUnitType.Star);
|
|
|
|
|
}
|
2019-06-19 23:31:56 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
public double SymbolsPanelHeight {
|
|
|
|
|
get { return rightPanel.RowDefinitions[0].ActualHeight; }
|
|
|
|
|
set {
|
|
|
|
|
double totalHeight = rightPanel.RowDefinitions[0].ActualHeight +
|
|
|
|
|
rightPanel.RowDefinitions[2].ActualHeight;
|
2021-08-21 14:45:11 +00:00
|
|
|
|
if (totalHeight > value) {
|
|
|
|
|
rightPanel.RowDefinitions[0].Height = new GridLength(value, GridUnitType.Star);
|
|
|
|
|
rightPanel.RowDefinitions[2].Height = new GridLength(totalHeight - value,
|
|
|
|
|
GridUnitType.Star);
|
|
|
|
|
}
|
2019-06-19 23:31:56 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2019-07-07 00:24:42 +00:00
|
|
|
|
private void UpdateLongCommentWidth() {
|
|
|
|
|
GridView gv = (GridView)(codeListView.View);
|
|
|
|
|
double totalWidth = 0;
|
|
|
|
|
for (int i = (int)MainController.CodeListColumn.Label; i < gv.Columns.Count; i++) {
|
|
|
|
|
totalWidth += gv.Columns[i].ActualWidth;
|
|
|
|
|
}
|
|
|
|
|
LongCommentWidth = totalWidth;
|
|
|
|
|
//Debug.WriteLine("Long comment width: " + LongCommentWidth);
|
|
|
|
|
}
|
|
|
|
|
|
2019-06-19 23:31:56 +00:00
|
|
|
|
#endregion Window placement
|
|
|
|
|
|
2019-06-22 21:41:09 +00:00
|
|
|
|
#region Column widths
|
|
|
|
|
|
2019-06-20 22:10:35 +00:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Grabs the widths of the columns of the various grids and saves them in the
|
|
|
|
|
/// global AppSettings.
|
|
|
|
|
/// </summary>
|
|
|
|
|
public void CaptureColumnWidths() {
|
|
|
|
|
string widthStr;
|
|
|
|
|
|
|
|
|
|
widthStr = CaptureColumnWidths((GridView)codeListView.View);
|
|
|
|
|
AppSettings.Global.SetString(AppSettings.CDLV_COL_WIDTHS, widthStr);
|
|
|
|
|
|
|
|
|
|
widthStr = CaptureColumnWidths(referencesGrid);
|
|
|
|
|
AppSettings.Global.SetString(AppSettings.REFWIN_COL_WIDTHS, widthStr);
|
|
|
|
|
widthStr = CaptureColumnWidths(notesGrid);
|
|
|
|
|
AppSettings.Global.SetString(AppSettings.NOTEWIN_COL_WIDTHS, widthStr);
|
|
|
|
|
widthStr = CaptureColumnWidths(symbolsGrid);
|
|
|
|
|
AppSettings.Global.SetString(AppSettings.SYMWIN_COL_WIDTHS, widthStr);
|
|
|
|
|
}
|
|
|
|
|
private string CaptureColumnWidths(GridView gv) {
|
|
|
|
|
int[] widths = new int[gv.Columns.Count];
|
|
|
|
|
for (int i = 0; i < gv.Columns.Count; i++) {
|
|
|
|
|
widths[i] = (int)Math.Round(gv.Columns[i].ActualWidth);
|
|
|
|
|
}
|
|
|
|
|
return TextUtil.SerializeIntArray(widths);
|
|
|
|
|
}
|
|
|
|
|
private string CaptureColumnWidths(DataGrid dg) {
|
|
|
|
|
int[] widths = new int[dg.Columns.Count];
|
|
|
|
|
for (int i = 0; i < dg.Columns.Count; i++) {
|
|
|
|
|
widths[i] = (int)Math.Round(dg.Columns[i].ActualWidth);
|
|
|
|
|
}
|
|
|
|
|
return TextUtil.SerializeIntArray(widths);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
|
/// Applies column widths from the global AppSettings to the various grids.
|
|
|
|
|
/// </summary>
|
|
|
|
|
public void RestoreColumnWidths() {
|
|
|
|
|
RestoreColumnWidths((GridView)codeListView.View,
|
|
|
|
|
AppSettings.Global.GetString(AppSettings.CDLV_COL_WIDTHS, null));
|
|
|
|
|
|
|
|
|
|
RestoreColumnWidths(referencesGrid,
|
|
|
|
|
AppSettings.Global.GetString(AppSettings.REFWIN_COL_WIDTHS, null));
|
|
|
|
|
RestoreColumnWidths(notesGrid,
|
|
|
|
|
AppSettings.Global.GetString(AppSettings.NOTEWIN_COL_WIDTHS, null));
|
|
|
|
|
RestoreColumnWidths(symbolsGrid,
|
|
|
|
|
AppSettings.Global.GetString(AppSettings.SYMWIN_COL_WIDTHS, null));
|
|
|
|
|
}
|
|
|
|
|
private void RestoreColumnWidths(GridView gv, string str) {
|
|
|
|
|
int[] widths = null;
|
|
|
|
|
try {
|
|
|
|
|
widths = TextUtil.DeserializeIntArray(str);
|
|
|
|
|
} catch (Exception ex) {
|
2019-06-21 22:17:04 +00:00
|
|
|
|
Debug.WriteLine("Unable to deserialize widths for GridView: " + ex.Message);
|
2019-06-20 22:10:35 +00:00
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
if (widths.Length != gv.Columns.Count) {
|
|
|
|
|
Debug.WriteLine("Incorrect column count for GridView");
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (int i = 0; i < widths.Length; i++) {
|
|
|
|
|
gv.Columns[i].Width = widths[i];
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
private void RestoreColumnWidths(DataGrid dg, string str) {
|
|
|
|
|
int[] widths = null;
|
|
|
|
|
try {
|
|
|
|
|
widths = TextUtil.DeserializeIntArray(str);
|
|
|
|
|
} catch (Exception ex) {
|
2019-06-21 22:17:04 +00:00
|
|
|
|
Debug.WriteLine("Unable to deserialize widths for " + dg.Name + ": " + ex.Message);
|
2019-06-20 22:10:35 +00:00
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
if (widths.Length != dg.Columns.Count) {
|
|
|
|
|
Debug.WriteLine("Incorrect column count for " + dg.Name);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (int i = 0; i < widths.Length; i++) {
|
|
|
|
|
dg.Columns[i].Width = widths[i];
|
|
|
|
|
}
|
|
|
|
|
}
|
2019-06-27 00:11:58 +00:00
|
|
|
|
|
|
|
|
|
private static string[] sSampleStrings = {
|
|
|
|
|
"+000000", // Offset
|
|
|
|
|
"00/0000", // Address
|
|
|
|
|
"00 00 00 00.", // Bytes (optional spaces or ellipsis, but not both)
|
|
|
|
|
"00000000 0", // Flags
|
|
|
|
|
"######", // Attributes
|
|
|
|
|
"MMMMMMMMM", // Label (9 chars)
|
|
|
|
|
"MMMMMMM", // Opcode
|
|
|
|
|
"MMMMMMMMMMMMM", // Operand
|
|
|
|
|
"MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM" // Comment (50 chars)
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
|
/// Computes the default code list column widths, using the currently configured
|
|
|
|
|
/// code list font.
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <returns></returns>
|
|
|
|
|
public int[] GetDefaultCodeListColumnWidths() {
|
|
|
|
|
// Fudge factor, in DIPs. This is necessary because the list view style applies
|
|
|
|
|
// a margin to the column border.
|
|
|
|
|
const double FUDGE = 14.0;
|
|
|
|
|
|
|
|
|
|
GridView gv = (GridView)codeListView.View;
|
|
|
|
|
int[] widths = new int[gv.Columns.Count];
|
|
|
|
|
Debug.Assert(widths.Length == (int)MainController.CodeListColumn.COUNT);
|
|
|
|
|
Debug.Assert(widths.Length == sSampleStrings.Length);
|
|
|
|
|
|
|
|
|
|
Typeface typeface = new Typeface(codeListView.FontFamily, codeListView.FontStyle,
|
|
|
|
|
codeListView.FontWeight, codeListView.FontStretch);
|
2019-07-07 00:24:42 +00:00
|
|
|
|
//Debug.WriteLine("Default column widths (FUDGE=" + FUDGE + "):");
|
2019-06-27 00:11:58 +00:00
|
|
|
|
for (int i = 0; i < widths.Length; i++) {
|
|
|
|
|
double strLen = Helper.MeasureStringWidth(sSampleStrings[i],
|
|
|
|
|
typeface, codeListView.FontSize);
|
|
|
|
|
widths[i] = (int)Math.Round(strLen + FUDGE);
|
2019-07-07 00:24:42 +00:00
|
|
|
|
//Debug.WriteLine(" " + i + ":" + widths[i] + " " + sSampleStrings[i]);
|
2019-06-27 00:11:58 +00:00
|
|
|
|
}
|
|
|
|
|
return widths;
|
|
|
|
|
}
|
2019-06-19 23:31:56 +00:00
|
|
|
|
|
2019-06-22 21:41:09 +00:00
|
|
|
|
#endregion Column widths
|
2019-06-12 01:45:08 +00:00
|
|
|
|
|
|
|
|
|
|
2019-06-10 22:46:35 +00:00
|
|
|
|
#region Selection management
|
2019-04-29 23:34:09 +00:00
|
|
|
|
|
2019-06-08 22:48:44 +00:00
|
|
|
|
private void CodeListView_SelectionChanged(object sender, SelectionChangedEventArgs e) {
|
2019-06-09 00:13:11 +00:00
|
|
|
|
//DateTime startWhen = DateTime.Now;
|
|
|
|
|
|
2019-06-08 22:48:44 +00:00
|
|
|
|
// Update the selected-item bitmap.
|
|
|
|
|
CodeDisplayList.SelectedIndices.SelectionChanged(e);
|
|
|
|
|
|
2019-06-16 23:34:47 +00:00
|
|
|
|
// Notify MainController that the selection has changed.
|
|
|
|
|
mMainCtrl.SelectionChanged();
|
2019-06-08 22:48:44 +00:00
|
|
|
|
|
2019-07-14 22:11:27 +00:00
|
|
|
|
// Don't try to call CodeDisplayList.SelectedIndices.DebugValidateSelectionCount()
|
|
|
|
|
// here. Events arrive while pieces are still moving.
|
2019-06-09 00:13:11 +00:00
|
|
|
|
|
|
|
|
|
//Debug.WriteLine("SelectionChanged took " +
|
|
|
|
|
// (DateTime.Now - startWhen).TotalMilliseconds + " ms");
|
2019-06-08 22:48:44 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
|
/// Returns the number of selected items.
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <returns>
|
|
|
|
|
/// The SelectedItems list appears to hold the full set, so we can just return the count.
|
|
|
|
|
/// </returns>
|
2019-06-15 23:00:31 +00:00
|
|
|
|
public int CodeListView_GetSelectionCount() {
|
2019-06-08 22:48:44 +00:00
|
|
|
|
return codeListView.SelectedItems.Count;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
|
/// Returns the index of the first selected item, or -1 if nothing is selected.
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <remarks>
|
|
|
|
|
/// The ListView.SelectedIndex property returns the index of a selected item, but
|
|
|
|
|
/// doesn't make guarantees about first or last.
|
|
|
|
|
///
|
|
|
|
|
/// This would be easier if the ListView kept SelectedItems in sorted order. However,
|
|
|
|
|
/// if you ctrl+click around you can get to a point where entry[0] is not the first
|
|
|
|
|
/// and entry[count-1] is not the last selected item.
|
|
|
|
|
///
|
|
|
|
|
/// So we either have to walk the SelectedItems list or the DisplayListSelection array.
|
|
|
|
|
/// For short selections the former will be faster than the later. I'm assuming the
|
|
|
|
|
/// common cases will be short selections and select-all, so this should handle both
|
|
|
|
|
/// efficiently.
|
|
|
|
|
/// </remarks>
|
2019-06-15 23:00:31 +00:00
|
|
|
|
public int CodeListView_GetFirstSelectedIndex() {
|
2019-06-08 22:48:44 +00:00
|
|
|
|
int count = codeListView.SelectedItems.Count;
|
|
|
|
|
if (count == 0) {
|
|
|
|
|
return -1;
|
|
|
|
|
} else if (count < 500) {
|
|
|
|
|
int min = CodeDisplayList.Count;
|
|
|
|
|
foreach (DisplayList.FormattedParts parts in codeListView.SelectedItems) {
|
|
|
|
|
if (min > parts.ListIndex) {
|
|
|
|
|
min = parts.ListIndex;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
Debug.Assert(min < CodeDisplayList.Count);
|
|
|
|
|
return min;
|
|
|
|
|
} else {
|
|
|
|
|
return CodeDisplayList.SelectedIndices.GetFirstSelectedIndex();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
|
/// Returns the index of the last selected item, or -1 if nothing is selected.
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <remarks>
|
|
|
|
|
/// Again, the ListView does not provide what we need.
|
|
|
|
|
/// </remarks>
|
2019-06-15 23:00:31 +00:00
|
|
|
|
public int CodeListView_GetLastSelectedIndex() {
|
2019-06-08 22:48:44 +00:00
|
|
|
|
int count = codeListView.SelectedItems.Count;
|
|
|
|
|
if (count == 0) {
|
|
|
|
|
return -1;
|
|
|
|
|
} else if (count < 500) {
|
|
|
|
|
int max = -1;
|
|
|
|
|
foreach (DisplayList.FormattedParts parts in codeListView.SelectedItems) {
|
|
|
|
|
if (max < parts.ListIndex) {
|
|
|
|
|
max = parts.ListIndex;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
Debug.Assert(max >= 0);
|
|
|
|
|
return max;
|
|
|
|
|
} else {
|
|
|
|
|
return CodeDisplayList.SelectedIndices.GetLastSelectedIndex();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2019-06-15 23:00:31 +00:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// De-selects all items.
|
|
|
|
|
/// </summary>
|
|
|
|
|
public void CodeListView_DeselectAll() {
|
|
|
|
|
codeListView.SelectedItems.Clear();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// <summary>
|
2019-10-17 19:45:10 +00:00
|
|
|
|
/// Selects a range of values. Clears the previous selection.
|
2019-06-15 23:00:31 +00:00
|
|
|
|
/// </summary>
|
|
|
|
|
/// <param name="start">First line to select.</param>
|
|
|
|
|
/// <param name="count">Number of lines to select.</param>
|
|
|
|
|
public void CodeListView_SelectRange(int start, int count) {
|
|
|
|
|
Debug.Assert(start >= 0 && start < CodeDisplayList.Count);
|
|
|
|
|
Debug.Assert(count > 0 && start + count <= CodeDisplayList.Count);
|
|
|
|
|
|
2019-10-17 19:45:10 +00:00
|
|
|
|
CodeListView_DeselectAll();
|
|
|
|
|
|
2019-10-10 00:41:44 +00:00
|
|
|
|
if (count == 1) {
|
2019-10-17 19:45:10 +00:00
|
|
|
|
//codeListView.SelectedItems.Add(CodeDisplayList[start]);
|
|
|
|
|
|
|
|
|
|
// Special handling for single-item selection, for the benefit of Shift+F3. If
|
|
|
|
|
// we're in multi-select mode, and we select an item while the shift key is
|
|
|
|
|
// down, the control will do a range select instead (as if you shift-clicked).
|
|
|
|
|
// We work around this by temporarily switching to single-select mode.
|
|
|
|
|
//
|
|
|
|
|
// This could cause problems if we wanted to select multiple single lines.
|
2019-10-30 00:52:59 +00:00
|
|
|
|
//
|
|
|
|
|
// NOTE: this causes a selection-changed event, which can cause problems
|
|
|
|
|
// if something tries to fiddle with SelectedItems (you can only do that
|
|
|
|
|
// when in multi-select mode) instead of SelectedItem. I tried to mitigate this
|
|
|
|
|
// by setting the selection twice, once in multi-select mode, so that the
|
|
|
|
|
// selection is unlikely to change, but that restored the Shift+F3 problem.
|
|
|
|
|
//
|
|
|
|
|
// (To repro problem: double-clicking a line in the message log about
|
|
|
|
|
// a reference to a non-existent symbol associated with a self-referential line
|
|
|
|
|
// blows things up... see test 2010.)
|
2019-10-17 19:45:10 +00:00
|
|
|
|
codeListView.SelectionMode = SelectionMode.Single;
|
|
|
|
|
codeListView.SelectedItem = CodeDisplayList[start];
|
|
|
|
|
codeListView.SelectionMode = SelectionMode.Extended;
|
2019-10-10 00:41:44 +00:00
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2019-06-15 23:00:31 +00:00
|
|
|
|
DisplayList.FormattedParts[] tmpArray = new DisplayList.FormattedParts[count];
|
|
|
|
|
for (int index = 0; index < count; index++) {
|
|
|
|
|
tmpArray[index] = CodeDisplayList[start + index];
|
|
|
|
|
}
|
|
|
|
|
listViewSetSelectedItems.Invoke(codeListView, new object[] { tmpArray });
|
|
|
|
|
}
|
|
|
|
|
|
2019-06-10 22:46:35 +00:00
|
|
|
|
/// <summary>
|
2019-07-07 20:28:45 +00:00
|
|
|
|
/// Sets the code list selection to match the selection bitmap.
|
2019-06-10 22:46:35 +00:00
|
|
|
|
/// </summary>
|
|
|
|
|
/// <param name="sel">Selection bitmap.</param>
|
2019-06-15 23:00:31 +00:00
|
|
|
|
public void CodeListView_SetSelection(DisplayListSelection sel) {
|
2019-07-18 00:42:57 +00:00
|
|
|
|
// Time required increases non-linearly. Quick test:
|
|
|
|
|
// 50K: 10 seconds, 20K: 1.6 sec, 10K: 0.6 sec, 5K: 0.2 sec
|
|
|
|
|
const int MAX_SEL_COUNT = 5000;
|
|
|
|
|
|
2021-08-09 00:39:21 +00:00
|
|
|
|
mCodeViewRefocusNeeded = true;
|
|
|
|
|
|
2019-10-23 20:00:46 +00:00
|
|
|
|
// In the current implementation, a large (500K) list can take a couple of
|
|
|
|
|
// seconds to restore a single-line selection if the selected item is near
|
|
|
|
|
// the bottom of the list.
|
|
|
|
|
|
2019-08-17 23:59:08 +00:00
|
|
|
|
TaskTimer timer = new TaskTimer();
|
|
|
|
|
timer.StartTask("TOTAL");
|
2019-06-10 22:46:35 +00:00
|
|
|
|
|
2019-08-17 23:59:08 +00:00
|
|
|
|
try {
|
|
|
|
|
timer.StartTask("Clear");
|
|
|
|
|
// The caller will clear the DisplayListSelection before calling here, so we
|
|
|
|
|
// need to clear the ListView selection to match, even if we're about to call
|
|
|
|
|
// SelectAll. If we don't, the SelectAll() call won't generate the necessary
|
|
|
|
|
// events, and our DisplayListSelection will get out of sync.
|
|
|
|
|
codeListView.SelectedItems.Clear();
|
|
|
|
|
timer.EndTask("Clear");
|
|
|
|
|
|
|
|
|
|
if (sel.IsAllSelected()) {
|
|
|
|
|
Debug.WriteLine("SetSelection: re-selecting all items");
|
|
|
|
|
timer.StartTask("SelectAll");
|
|
|
|
|
codeListView.SelectAll();
|
|
|
|
|
timer.EndTask("SelectAll");
|
|
|
|
|
return;
|
|
|
|
|
}
|
2019-06-10 22:46:35 +00:00
|
|
|
|
|
2019-08-17 23:59:08 +00:00
|
|
|
|
if (sel.Count > MAX_SEL_COUNT) {
|
|
|
|
|
// Too much for WPF ListView -- only restore the first item.
|
|
|
|
|
Debug.WriteLine("SetSelection: not restoring (" + sel.Count + " items)");
|
|
|
|
|
codeListView.SelectedItems.Add(CodeDisplayList[sel.GetFirstSelectedIndex()]);
|
|
|
|
|
return;
|
|
|
|
|
}
|
2019-06-10 22:46:35 +00:00
|
|
|
|
|
2019-08-17 23:59:08 +00:00
|
|
|
|
Debug.WriteLine("SetSelection: selecting " + sel.Count + " of " +
|
|
|
|
|
CodeDisplayList.Count);
|
2019-07-18 00:42:57 +00:00
|
|
|
|
|
2019-08-17 23:59:08 +00:00
|
|
|
|
// Note: if you refresh the display list with F5, the selection will be lost. This
|
|
|
|
|
// appears to be a consequence of hitting a key -- changing from the built-in
|
|
|
|
|
// "Refresh" command to a locally defined "Re-analyze" command bound to F6 didn't
|
|
|
|
|
// change the behavior. Selecting "re-analyze" from the DEBUG menu doesn't lose
|
|
|
|
|
// the selection.
|
2019-06-10 22:46:35 +00:00
|
|
|
|
|
2019-08-17 23:59:08 +00:00
|
|
|
|
timer.StartTask("tmpArray " + sel.Count);
|
|
|
|
|
DisplayList.FormattedParts[] tmpArray = new DisplayList.FormattedParts[sel.Count];
|
|
|
|
|
int ai = 0;
|
|
|
|
|
foreach (int listIndex in sel) {
|
|
|
|
|
tmpArray[ai++] = CodeDisplayList[listIndex];
|
|
|
|
|
}
|
|
|
|
|
timer.EndTask("tmpArray " + sel.Count);
|
|
|
|
|
|
|
|
|
|
// Use a reflection call to provide the full set. This is much faster than
|
|
|
|
|
// adding the items one at a time to SelectedItems. (For one thing, it only
|
|
|
|
|
// invokes the SelectionChanged method once.)
|
|
|
|
|
timer.StartTask("Invoke");
|
|
|
|
|
listViewSetSelectedItems.Invoke(codeListView, new object[] { tmpArray });
|
|
|
|
|
timer.EndTask("Invoke");
|
|
|
|
|
} finally {
|
|
|
|
|
timer.EndTask("TOTAL");
|
|
|
|
|
//timer.DumpTimes("CodeListView_SetSelection");
|
2019-06-10 22:46:35 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2019-07-14 22:11:27 +00:00
|
|
|
|
public void CodeListView_DebugValidateSelectionCount() {
|
|
|
|
|
Debug.Assert(CodeDisplayList.SelectedIndices.DebugValidateSelectionCount(
|
|
|
|
|
codeListView.SelectedItems.Count));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
|
/// Sets the focus to the ListViewItem identified by SelectedIndex. This must be done
|
2021-08-09 00:39:21 +00:00
|
|
|
|
/// after the ListView contents have changed, when the ItemContainerGenerator's
|
|
|
|
|
/// StatusChanged event fires.
|
2019-07-14 22:11:27 +00:00
|
|
|
|
/// </summary>
|
|
|
|
|
/// <remarks>
|
2019-07-15 22:32:27 +00:00
|
|
|
|
/// Sample steps to reproduce problem:
|
2021-08-09 00:39:21 +00:00
|
|
|
|
/// 1. add or remove a note
|
|
|
|
|
/// 2. hit the down-arrow key
|
|
|
|
|
///
|
|
|
|
|
/// This causes the ListView's contents to change enough that the keyboard position
|
|
|
|
|
/// is reset to zero, so attempting to move cursor up or down with an arrow key causes
|
|
|
|
|
/// the ListView position to jump to the top of the file. The keyboard navigation
|
|
|
|
|
/// appears to be independent of which element(s) are selected.
|
2019-07-14 22:11:27 +00:00
|
|
|
|
///
|
2021-08-09 00:39:21 +00:00
|
|
|
|
/// The workaround for this is to set the focus to the specific item where you want the
|
|
|
|
|
/// keyboard to be after making a change to the list. This isn't quite so simple,
|
|
|
|
|
/// because at the point where we're restoring the selection flags, the UI elements
|
|
|
|
|
/// haven't yet been generated. We need to wait for a "status changed" event to arrive
|
|
|
|
|
/// from the ItemContainerGenerator.
|
2019-07-15 22:32:27 +00:00
|
|
|
|
///
|
2021-08-09 00:39:21 +00:00
|
|
|
|
/// This: http://cytivrat.blogspot.com/2011/05/selecting-first-item-in-wpf-listview.html
|
|
|
|
|
/// formed the basis of my initial solution. The blog post was about a different problem,
|
|
|
|
|
/// where you'd have to hit the down-arrow twice after the control was first created
|
|
|
|
|
/// because the focus is on the control rather than the item. The same approach applies
|
|
|
|
|
/// here as well.
|
2019-07-14 22:11:27 +00:00
|
|
|
|
///
|
2021-08-09 00:39:21 +00:00
|
|
|
|
/// Unfortunately, grabbing focus like this on every update causes problems with the
|
|
|
|
|
/// GridSplitters. As soon as the splitter start to move, the ListView grabs focus and
|
|
|
|
|
/// prevents them from moving more than a few pixels. The workaround was to do nothing
|
|
|
|
|
/// while the splitters are being moved. This didn't solve the problem completely,
|
|
|
|
|
/// e.g. you couldn't move the splitters with the arrow keys by more than one step
|
|
|
|
|
/// because the ListView gets a StatusChanged event and steals focus away, but at least the
|
|
|
|
|
/// mouse worked. (See issue #52 and https://stackoverflow.com/q/58652064/294248.)
|
2019-11-01 18:05:22 +00:00
|
|
|
|
///
|
2021-08-09 00:39:21 +00:00
|
|
|
|
/// Unfortunately, this update didn't solve other problems created by the initial solution,
|
|
|
|
|
/// because setting the item focus clears multi-select. If you held shift down while
|
|
|
|
|
/// hitting down-arrow, things would work fine until you reached the bottom of the
|
|
|
|
|
/// screen, at which point the virtual UI stuff would cause the item container generator
|
|
|
|
|
/// to do work and change state. (See issue #105.)
|
2019-11-01 18:05:22 +00:00
|
|
|
|
///
|
2021-08-09 00:39:21 +00:00
|
|
|
|
/// The current approach is to set an explicit "refocus needed" boolean when we make
|
|
|
|
|
/// changes to the list, and ignore the "status changed" events in other circumstances.
|
|
|
|
|
/// This seems to have the correct behavior (so far).
|
|
|
|
|
/// Hat tip to https://stackoverflow.com/a/53666203/294248
|
2019-07-14 22:11:27 +00:00
|
|
|
|
/// </remarks>
|
|
|
|
|
private void ItemContainerGenerator_StatusChanged(object sender, EventArgs e) {
|
2021-08-09 00:39:21 +00:00
|
|
|
|
if (!mCodeViewRefocusNeeded) {
|
2019-11-01 18:05:22 +00:00
|
|
|
|
return;
|
|
|
|
|
}
|
2019-07-14 22:11:27 +00:00
|
|
|
|
if (codeListView.ItemContainerGenerator.Status == GeneratorStatus.ContainersGenerated) {
|
|
|
|
|
int index = codeListView.SelectedIndex;
|
|
|
|
|
|
|
|
|
|
if (index >= 0) {
|
|
|
|
|
ListViewItem item =
|
|
|
|
|
(ListViewItem)codeListView.ItemContainerGenerator.ContainerFromIndex(index);
|
|
|
|
|
|
|
|
|
|
if (item != null) {
|
|
|
|
|
item.Focus();
|
2021-08-09 00:39:21 +00:00
|
|
|
|
mCodeViewRefocusNeeded = false;
|
2019-07-14 22:11:27 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
2021-08-09 00:39:21 +00:00
|
|
|
|
private bool mCodeViewRefocusNeeded = false;
|
2019-07-14 22:11:27 +00:00
|
|
|
|
|
2021-08-09 00:39:21 +00:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Sets the CodeListView's focus to the selected item.
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <remarks>
|
|
|
|
|
/// This is required after jumping to a new location; otherwise the keyboard focus is
|
|
|
|
|
/// still at the previous location.
|
|
|
|
|
/// </remarks>
|
2020-06-07 23:28:29 +00:00
|
|
|
|
public void CodeListView_SetSelectionFocus() {
|
2021-08-09 00:39:21 +00:00
|
|
|
|
mCodeViewRefocusNeeded = true;
|
2020-06-07 23:28:29 +00:00
|
|
|
|
ItemContainerGenerator_StatusChanged(null, null);
|
|
|
|
|
}
|
|
|
|
|
|
2019-07-18 00:42:57 +00:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Returns the index of the line that's currently at the top of the control.
|
|
|
|
|
/// </summary>
|
2019-07-15 22:32:27 +00:00
|
|
|
|
public int CodeListView_GetTopIndex() {
|
Improve save & restore of top line
Whenever the display list gets regenerated, we need to restore the
code list view scroll position to the previous location in the file.
This gets tricky when multiple lines are appearing or disappearing.
We were saving the file offset of the line, but that works poorly
when there's a multi-line comment associated with that offset,
because we end up scrolling to the top of the comment whenever any
part of the comment is at the top of the screen.
We now track the file offset and the number of lines we were from
the top of that offset's content. This works well unless we remove
a lot of lines. If the adjusted line index would put us into a
different file offset, we punt and just scroll to the top of the item.
Also, fix a crasher in Edit Note.
Also, fix behavior when the list shrinks while a line near the end
of the file is selected.
Also, change a few instances of "Color.FromArgb(0,0,0,0)" to use a
common constant.
2019-07-17 20:47:43 +00:00
|
|
|
|
int index = codeListView.GetTopItemIndex();
|
|
|
|
|
Debug.Assert(index >= 0);
|
|
|
|
|
return index;
|
2019-06-10 22:46:35 +00:00
|
|
|
|
}
|
|
|
|
|
|
2019-07-18 00:42:57 +00:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Scrolls the code list so that the specified index is at the top of the control.
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <param name="index">Line index.</param>
|
2019-06-15 23:00:31 +00:00
|
|
|
|
public void CodeListView_SetTopIndex(int index) {
|
2019-07-18 00:42:57 +00:00
|
|
|
|
//Debug.WriteLine("CodeListView_SetTopIndex(" + index + "): " + CodeDisplayList[index]);
|
|
|
|
|
|
2019-06-10 22:46:35 +00:00
|
|
|
|
// ScrollIntoView does the least amount of scrolling required. This extension
|
|
|
|
|
// method scrolls to the bottom, then scrolls back up to the top item.
|
|
|
|
|
//
|
2019-07-18 00:42:57 +00:00
|
|
|
|
// It looks like scroll-to-bottom (which is done directly on the ScrollViewer)
|
|
|
|
|
// happens immediately, while scroll-to-item (which is done via the ListView)
|
|
|
|
|
// kicks in later. So you can't immediately query the top item to see where
|
|
|
|
|
// we were moved to.
|
|
|
|
|
//codeListView.ScrollToTopItem(CodeDisplayList[index]);
|
|
|
|
|
|
|
|
|
|
// This works much better.
|
|
|
|
|
codeListView.ScrollToIndex(index);
|
2019-06-10 22:46:35 +00:00
|
|
|
|
}
|
|
|
|
|
|
2019-06-16 16:29:54 +00:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Scrolls the code list to ensure that the specified index is visible.
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <param name="index">Line index of item.</param>
|
2019-06-15 23:00:31 +00:00
|
|
|
|
public void CodeListView_EnsureVisible(int index) {
|
|
|
|
|
Debug.Assert(index >= 0 && index < CodeDisplayList.Count);
|
|
|
|
|
codeListView.ScrollIntoView(CodeDisplayList[index]);
|
|
|
|
|
}
|
|
|
|
|
|
2019-06-16 16:29:54 +00:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Adds an address/label selection highlight to the specified line.
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <param name="index">Line index. If < 0, method has no effect.</param>
|
|
|
|
|
public void CodeListView_AddSelectionHighlight(int index) {
|
|
|
|
|
if (index < 0) {
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
CodeListView_ReplaceEntry(index,
|
|
|
|
|
DisplayList.FormattedParts.AddSelectionHighlight(CodeDisplayList[index]));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
|
/// Removes an address/label selection highlight from the specified line.
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <param name="index">Line index. If < 0, method has no effect.</param>
|
|
|
|
|
public void CodeListView_RemoveSelectionHighlight(int index) {
|
|
|
|
|
if (index < 0) {
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
CodeListView_ReplaceEntry(index,
|
|
|
|
|
DisplayList.FormattedParts.RemoveSelectionHighlight(CodeDisplayList[index]));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
|
/// Replaces an entry in the code list. If the item was selected, the selection is
|
|
|
|
|
/// cleared and restored.
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <param name="index">List index.</param>
|
|
|
|
|
/// <param name="newParts">Replacement parts.</param>
|
|
|
|
|
private void CodeListView_ReplaceEntry(int index, DisplayList.FormattedParts newParts) {
|
|
|
|
|
bool isSelected = CodeDisplayList.SelectedIndices[index];
|
2019-10-30 00:52:59 +00:00
|
|
|
|
if (isSelected && codeListView.SelectionMode != SelectionMode.Single) {
|
2021-09-11 17:48:38 +00:00
|
|
|
|
// Remove entry from selected items list in ListView control.
|
|
|
|
|
codeListView.SelectedItems.Remove(CodeDisplayList[index]);
|
2019-06-16 16:29:54 +00:00
|
|
|
|
}
|
|
|
|
|
CodeDisplayList[index] = newParts;
|
|
|
|
|
if (isSelected) {
|
2019-10-30 00:52:59 +00:00
|
|
|
|
if (codeListView.SelectionMode == SelectionMode.Single) {
|
|
|
|
|
codeListView.SelectedIndex = index;
|
|
|
|
|
} else {
|
|
|
|
|
codeListView.SelectedItems.Add(newParts);
|
|
|
|
|
}
|
2019-06-16 16:29:54 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2019-07-07 20:28:45 +00:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Ensures the the code ListView control has input focus.
|
|
|
|
|
/// </summary>
|
2021-08-09 00:39:21 +00:00
|
|
|
|
/// <remarks>
|
|
|
|
|
/// Generally don't call this: it puts the focus on the control, not the items in the
|
|
|
|
|
/// control, so if you use up/down arrows you move to the next control.
|
|
|
|
|
/// </remarks>
|
2021-10-25 22:45:42 +00:00
|
|
|
|
//public void CodeListView_Focus() {
|
|
|
|
|
// codeListView.Focus();
|
|
|
|
|
//}
|
2019-07-07 20:28:45 +00:00
|
|
|
|
|
2019-06-10 22:46:35 +00:00
|
|
|
|
#endregion Selection management
|
2019-06-08 22:48:44 +00:00
|
|
|
|
|
2019-06-22 21:41:09 +00:00
|
|
|
|
|
2019-06-08 22:48:44 +00:00
|
|
|
|
#region Can-execute handlers
|
|
|
|
|
|
2019-07-07 23:18:46 +00:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Returns true if the project is open.
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <returns></returns>
|
|
|
|
|
private bool IsProjectOpen() {
|
2019-10-26 20:07:31 +00:00
|
|
|
|
return mMainCtrl != null && mMainCtrl.IsProjectOpen;
|
2019-07-07 23:18:46 +00:00
|
|
|
|
}
|
|
|
|
|
|
2019-06-07 21:03:34 +00:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Returns true if the project is open. Intended for use in XAML CommandBindings.
|
|
|
|
|
/// </summary>
|
|
|
|
|
private void IsProjectOpen(object sender, CanExecuteRoutedEventArgs e) {
|
2019-07-07 23:18:46 +00:00
|
|
|
|
e.CanExecute = IsProjectOpen();
|
2019-06-07 21:03:34 +00:00
|
|
|
|
}
|
|
|
|
|
|
2019-09-19 22:53:23 +00:00
|
|
|
|
private void CanCreateLocalVariableTable(object sender, CanExecuteRoutedEventArgs e) {
|
|
|
|
|
e.CanExecute = IsProjectOpen() && mMainCtrl.CanCreateLocalVariableTable();
|
|
|
|
|
}
|
|
|
|
|
|
2019-07-14 20:50:15 +00:00
|
|
|
|
private void CanDeleteMlc(object sender, CanExecuteRoutedEventArgs e) {
|
|
|
|
|
e.CanExecute = IsProjectOpen() && mMainCtrl.CanDeleteMlc();
|
|
|
|
|
}
|
|
|
|
|
|
2019-06-16 23:34:47 +00:00
|
|
|
|
private void CanEditAddress(object sender, CanExecuteRoutedEventArgs e) {
|
2019-07-07 23:18:46 +00:00
|
|
|
|
e.CanExecute = IsProjectOpen() && mMainCtrl.CanEditAddress();
|
2019-06-16 23:34:47 +00:00
|
|
|
|
}
|
|
|
|
|
|
2019-07-11 22:55:43 +00:00
|
|
|
|
private void CanEditComment(object sender, CanExecuteRoutedEventArgs e) {
|
|
|
|
|
e.CanExecute = IsProjectOpen() && mMainCtrl.CanEditComment();
|
|
|
|
|
}
|
|
|
|
|
|
2020-07-09 00:56:27 +00:00
|
|
|
|
private void CanEditDataBank(object sender, CanExecuteRoutedEventArgs e) {
|
|
|
|
|
e.CanExecute = IsProjectOpen() && mMainCtrl.CanEditDataBank();
|
|
|
|
|
}
|
|
|
|
|
|
2019-07-07 00:24:42 +00:00
|
|
|
|
private void CanEditLabel(object sender, CanExecuteRoutedEventArgs e) {
|
2019-07-07 23:18:46 +00:00
|
|
|
|
e.CanExecute = IsProjectOpen() && mMainCtrl.CanEditLabel();
|
|
|
|
|
}
|
|
|
|
|
|
2019-08-25 21:14:44 +00:00
|
|
|
|
private void CanEditLocalVariableTable(object sender, CanExecuteRoutedEventArgs e) {
|
|
|
|
|
e.CanExecute = IsProjectOpen() && mMainCtrl.CanEditLocalVariableTable();
|
|
|
|
|
}
|
|
|
|
|
|
2019-07-07 23:18:46 +00:00
|
|
|
|
private void CanEditLongComment(object sender, CanExecuteRoutedEventArgs e) {
|
|
|
|
|
e.CanExecute = IsProjectOpen() && mMainCtrl.CanEditLongComment();
|
2019-07-07 00:24:42 +00:00
|
|
|
|
}
|
|
|
|
|
|
2019-07-14 00:04:47 +00:00
|
|
|
|
private void CanEditNote(object sender, CanExecuteRoutedEventArgs e) {
|
|
|
|
|
e.CanExecute = IsProjectOpen() && mMainCtrl.CanEditNote();
|
|
|
|
|
}
|
|
|
|
|
|
2019-07-08 22:40:30 +00:00
|
|
|
|
private void CanEditOperand(object sender, CanExecuteRoutedEventArgs e) {
|
|
|
|
|
e.CanExecute = IsProjectOpen() && mMainCtrl.CanEditOperand();
|
|
|
|
|
}
|
|
|
|
|
|
2019-07-14 20:18:10 +00:00
|
|
|
|
private void CanEditProjectSymbol(object sender, CanExecuteRoutedEventArgs e) {
|
|
|
|
|
e.CanExecute = IsProjectOpen() && mMainCtrl.CanEditProjectSymbol();
|
|
|
|
|
}
|
|
|
|
|
|
2019-06-21 22:06:04 +00:00
|
|
|
|
private void CanEditStatusFlags(object sender, CanExecuteRoutedEventArgs e) {
|
2019-07-07 23:18:46 +00:00
|
|
|
|
e.CanExecute = IsProjectOpen() && mMainCtrl.CanEditStatusFlags();
|
2019-06-21 22:06:04 +00:00
|
|
|
|
}
|
|
|
|
|
|
2019-11-23 04:45:57 +00:00
|
|
|
|
private void CanEditVisualizationSet(object sender, CanExecuteRoutedEventArgs e) {
|
|
|
|
|
e.CanExecute = IsProjectOpen() && mMainCtrl.CanEditVisualizationSet();
|
|
|
|
|
}
|
|
|
|
|
|
2019-07-14 20:50:15 +00:00
|
|
|
|
private void CanFormatAsWord(object sender, CanExecuteRoutedEventArgs e) {
|
|
|
|
|
e.CanExecute = IsProjectOpen() && mMainCtrl.CanFormatAsWord();
|
|
|
|
|
}
|
|
|
|
|
|
2019-09-15 20:37:38 +00:00
|
|
|
|
private void CanFormatAddressTable(object sender, CanExecuteRoutedEventArgs e) {
|
|
|
|
|
e.CanExecute = IsProjectOpen() && mMainCtrl.CanFormatAddressTable();
|
2019-07-13 20:31:51 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-10-14 22:02:53 +00:00
|
|
|
|
private void CanTagAsCodeStartPoint(object sender, CanExecuteRoutedEventArgs e) {
|
2019-07-07 23:18:46 +00:00
|
|
|
|
if (!IsProjectOpen()) {
|
2019-06-11 23:27:15 +00:00
|
|
|
|
e.CanExecute = false;
|
|
|
|
|
return;
|
|
|
|
|
}
|
2019-06-16 23:34:47 +00:00
|
|
|
|
MainController.EntityCounts counts = mMainCtrl.SelectionAnalysis.mEntityCounts;
|
2019-06-11 23:27:15 +00:00
|
|
|
|
e.CanExecute = (counts.mDataLines > 0 || counts.mCodeLines > 0) &&
|
2020-10-15 21:03:32 +00:00
|
|
|
|
(counts.mCodeStopTags != 0 || counts.mInlineDataTags != 0 || counts.mNoTags != 0);
|
2019-06-08 22:48:44 +00:00
|
|
|
|
}
|
2020-10-14 22:02:53 +00:00
|
|
|
|
private void CanTagAsCodeStopPoint(object sender, CanExecuteRoutedEventArgs e) {
|
2019-07-07 23:18:46 +00:00
|
|
|
|
if (!IsProjectOpen()) {
|
2019-06-11 23:27:15 +00:00
|
|
|
|
e.CanExecute = false;
|
|
|
|
|
return;
|
|
|
|
|
}
|
2019-06-16 23:34:47 +00:00
|
|
|
|
MainController.EntityCounts counts = mMainCtrl.SelectionAnalysis.mEntityCounts;
|
2019-06-11 23:27:15 +00:00
|
|
|
|
e.CanExecute = (counts.mDataLines > 0 || counts.mCodeLines > 0) &&
|
2020-10-15 21:03:32 +00:00
|
|
|
|
(counts.mCodeStartTags != 0 || counts.mInlineDataTags != 0 || counts.mNoTags != 0);
|
2019-06-08 22:48:44 +00:00
|
|
|
|
}
|
2020-10-14 22:02:53 +00:00
|
|
|
|
private void CanTagAsInlineData(object sender, CanExecuteRoutedEventArgs e) {
|
2019-07-07 23:18:46 +00:00
|
|
|
|
if (!IsProjectOpen()) {
|
2019-06-11 23:27:15 +00:00
|
|
|
|
e.CanExecute = false;
|
|
|
|
|
return;
|
|
|
|
|
}
|
2019-06-16 23:34:47 +00:00
|
|
|
|
MainController.EntityCounts counts = mMainCtrl.SelectionAnalysis.mEntityCounts;
|
2019-06-11 23:27:15 +00:00
|
|
|
|
e.CanExecute = (counts.mDataLines > 0 || counts.mCodeLines > 0) &&
|
2020-10-15 21:03:32 +00:00
|
|
|
|
(counts.mCodeStartTags != 0 || counts.mCodeStopTags != 0 || counts.mNoTags != 0);
|
2019-06-08 22:48:44 +00:00
|
|
|
|
}
|
2020-10-14 22:02:53 +00:00
|
|
|
|
private void CanRemoveAnalyzerTags(object sender, CanExecuteRoutedEventArgs e) {
|
2019-07-07 23:18:46 +00:00
|
|
|
|
if (!IsProjectOpen()) {
|
2019-06-11 23:27:15 +00:00
|
|
|
|
e.CanExecute = false;
|
|
|
|
|
return;
|
|
|
|
|
}
|
2019-06-16 23:34:47 +00:00
|
|
|
|
MainController.EntityCounts counts = mMainCtrl.SelectionAnalysis.mEntityCounts;
|
2019-06-11 23:27:15 +00:00
|
|
|
|
e.CanExecute = (counts.mDataLines > 0 || counts.mCodeLines > 0) &&
|
2020-10-15 21:03:32 +00:00
|
|
|
|
(counts.mCodeStartTags != 0 || counts.mCodeStopTags != 0 || counts.mInlineDataTags != 0);
|
2019-06-08 22:48:44 +00:00
|
|
|
|
}
|
|
|
|
|
|
2021-10-12 18:16:50 +00:00
|
|
|
|
private void CanRemoveFormatting(object sender, CanExecuteRoutedEventArgs e) {
|
|
|
|
|
e.CanExecute = IsProjectOpen() && mMainCtrl.CanRemoveFormatting();
|
|
|
|
|
}
|
|
|
|
|
|
2020-06-07 23:28:29 +00:00
|
|
|
|
private void CanJumpToOperand(object sender, CanExecuteRoutedEventArgs e) {
|
|
|
|
|
e.CanExecute = IsProjectOpen() && mMainCtrl.CanJumpToOperand();
|
|
|
|
|
}
|
|
|
|
|
|
2019-10-26 20:07:31 +00:00
|
|
|
|
private void CanSaveProject(object sender, CanExecuteRoutedEventArgs e) {
|
2020-06-07 23:28:29 +00:00
|
|
|
|
e.CanExecute = IsProjectOpen() && !mMainCtrl.IsProjectReadOnly;
|
2019-10-26 20:07:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
2019-07-14 20:50:15 +00:00
|
|
|
|
private void CanToggleSingleByteFormat(object sender, CanExecuteRoutedEventArgs e) {
|
|
|
|
|
e.CanExecute = IsProjectOpen() && mMainCtrl.CanToggleSingleByteFormat();
|
|
|
|
|
}
|
|
|
|
|
|
2019-06-15 23:00:31 +00:00
|
|
|
|
private void CanNavigateBackward(object sender, CanExecuteRoutedEventArgs e) {
|
2019-07-07 23:18:46 +00:00
|
|
|
|
e.CanExecute = IsProjectOpen() && mMainCtrl.CanNavigateBackward();
|
2019-06-15 23:00:31 +00:00
|
|
|
|
}
|
|
|
|
|
private void CanNavigateForward(object sender, CanExecuteRoutedEventArgs e) {
|
2019-07-07 23:18:46 +00:00
|
|
|
|
e.CanExecute = IsProjectOpen() && mMainCtrl.CanNavigateForward();
|
2019-06-11 23:27:15 +00:00
|
|
|
|
}
|
|
|
|
|
|
2019-06-21 23:27:58 +00:00
|
|
|
|
private void CanRedo(object sender, CanExecuteRoutedEventArgs e) {
|
2019-07-07 23:18:46 +00:00
|
|
|
|
e.CanExecute = IsProjectOpen() && mMainCtrl.CanRedo();
|
2019-06-21 23:27:58 +00:00
|
|
|
|
}
|
|
|
|
|
private void CanUndo(object sender, CanExecuteRoutedEventArgs e) {
|
2019-07-07 23:18:46 +00:00
|
|
|
|
e.CanExecute = IsProjectOpen() && mMainCtrl.CanUndo();
|
2019-06-21 23:27:58 +00:00
|
|
|
|
}
|
|
|
|
|
|
2019-06-08 22:48:44 +00:00
|
|
|
|
#endregion Can-execute handlers
|
|
|
|
|
|
|
|
|
|
|
2019-06-08 00:25:04 +00:00
|
|
|
|
#region Command handlers
|
|
|
|
|
|
2019-07-06 22:51:57 +00:00
|
|
|
|
private void AboutCmd_Executed(object sender, ExecutedRoutedEventArgs e) {
|
|
|
|
|
mMainCtrl.ShowAboutBox();
|
2019-06-24 22:48:11 +00:00
|
|
|
|
}
|
|
|
|
|
|
2019-04-29 23:34:09 +00:00
|
|
|
|
private void AssembleCmd_Executed(object sender, ExecutedRoutedEventArgs e) {
|
2019-06-24 00:24:51 +00:00
|
|
|
|
mMainCtrl.AssembleProject();
|
2019-04-29 23:34:09 +00:00
|
|
|
|
}
|
2019-05-05 23:50:28 +00:00
|
|
|
|
|
2019-06-07 21:03:34 +00:00
|
|
|
|
private void CloseCmd_Executed(object sender, ExecutedRoutedEventArgs e) {
|
|
|
|
|
if (!mMainCtrl.CloseProject()) {
|
|
|
|
|
Debug.WriteLine("Close canceled");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2019-12-29 01:14:29 +00:00
|
|
|
|
private void ConcatenateFilesCmd_Executed(object sender, ExecutedRoutedEventArgs e) {
|
|
|
|
|
mMainCtrl.ConcatenateFiles();
|
|
|
|
|
}
|
|
|
|
|
|
2020-06-24 00:21:18 +00:00
|
|
|
|
private void ConvertOmfCmd_Executed(object sender, ExecutedRoutedEventArgs e) {
|
|
|
|
|
mMainCtrl.ConvertOmf();
|
|
|
|
|
}
|
|
|
|
|
|
2019-09-19 22:53:23 +00:00
|
|
|
|
private void CreateLocalVariableTableCmd_Executed(object sender, ExecutedRoutedEventArgs e) {
|
|
|
|
|
mMainCtrl.CreateLocalVariableTable();
|
|
|
|
|
}
|
|
|
|
|
|
2019-07-11 18:36:07 +00:00
|
|
|
|
private void CopyCmd_Executed(object sender, ExecutedRoutedEventArgs e) {
|
|
|
|
|
mMainCtrl.CopyToClipboard();
|
|
|
|
|
}
|
|
|
|
|
|
2019-07-14 20:50:15 +00:00
|
|
|
|
private void DeleteMlcCmd_Executed(object sender, ExecutedRoutedEventArgs e) {
|
|
|
|
|
mMainCtrl.DeleteMlc();
|
|
|
|
|
}
|
|
|
|
|
|
2019-06-16 23:34:47 +00:00
|
|
|
|
private void EditAddressCmd_Executed(object sender, ExecutedRoutedEventArgs e) {
|
|
|
|
|
mMainCtrl.EditAddress();
|
|
|
|
|
}
|
|
|
|
|
|
2019-07-06 22:51:57 +00:00
|
|
|
|
private void EditAppSettingsCmd_Executed(object sender, ExecutedRoutedEventArgs e) {
|
2019-07-07 00:24:42 +00:00
|
|
|
|
mMainCtrl.EditAppSettings();
|
|
|
|
|
}
|
|
|
|
|
|
2019-07-11 22:55:43 +00:00
|
|
|
|
private void EditCommentCmd_Executed(object sender, ExecutedRoutedEventArgs e) {
|
|
|
|
|
mMainCtrl.EditComment();
|
|
|
|
|
}
|
|
|
|
|
|
2020-07-09 00:56:27 +00:00
|
|
|
|
private void EditDataBankCmd_Executed(object sender, ExecutedRoutedEventArgs e) {
|
|
|
|
|
mMainCtrl.EditDataBank();
|
|
|
|
|
}
|
|
|
|
|
|
2019-07-07 23:18:46 +00:00
|
|
|
|
private void EditHeaderCommentCmd_Executed(object sender, ExecutedRoutedEventArgs e) {
|
|
|
|
|
mMainCtrl.EditHeaderComment();
|
|
|
|
|
}
|
|
|
|
|
|
2019-07-07 00:24:42 +00:00
|
|
|
|
private void EditLabelCmd_Executed(object sender, ExecutedRoutedEventArgs e) {
|
|
|
|
|
mMainCtrl.EditLabel();
|
2019-07-06 22:51:57 +00:00
|
|
|
|
}
|
|
|
|
|
|
2019-08-25 21:14:44 +00:00
|
|
|
|
private void EditLocalVariableTableCmd_Executed(object sender, ExecutedRoutedEventArgs e) {
|
|
|
|
|
mMainCtrl.EditLocalVariableTable();
|
|
|
|
|
}
|
|
|
|
|
|
2019-07-07 23:18:46 +00:00
|
|
|
|
private void EditLongCommentCmd_Executed(object sender, ExecutedRoutedEventArgs e) {
|
|
|
|
|
mMainCtrl.EditLongComment();
|
|
|
|
|
}
|
|
|
|
|
|
2019-07-14 00:04:47 +00:00
|
|
|
|
private void EditNoteCmd_Executed(object sender, ExecutedRoutedEventArgs e) {
|
|
|
|
|
mMainCtrl.EditNote();
|
|
|
|
|
}
|
|
|
|
|
|
2019-07-08 22:40:30 +00:00
|
|
|
|
private void EditOperandCmd_Executed(object sender, ExecutedRoutedEventArgs e) {
|
|
|
|
|
mMainCtrl.EditOperand();
|
|
|
|
|
}
|
|
|
|
|
|
2019-09-11 00:43:31 +00:00
|
|
|
|
private void EditProjectPropertiesCmd_Executed(object sender, ExecutedRoutedEventArgs e) {
|
2019-12-13 19:29:37 +00:00
|
|
|
|
mMainCtrl.EditProjectProperties(WpfGui.EditProjectProperties.Tab.Unknown);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private void EditProjectPropertiesSymbolsCmd_Executed(object sender, ExecutedRoutedEventArgs e) {
|
|
|
|
|
mMainCtrl.EditProjectProperties(WpfGui.EditProjectProperties.Tab.ProjectSymbols);
|
2019-09-11 00:43:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
2019-07-14 20:18:10 +00:00
|
|
|
|
private void EditProjectSymbolCmd_Executed(object sender, ExecutedRoutedEventArgs e) {
|
2020-04-23 17:42:54 +00:00
|
|
|
|
mMainCtrl.EditProjectSymbol(MainController.CodeListColumn.Label);
|
2019-07-14 20:18:10 +00:00
|
|
|
|
}
|
|
|
|
|
|
2019-06-22 20:20:31 +00:00
|
|
|
|
private void EditStatusFlagsCmd_Executed(object sender, ExecutedRoutedEventArgs e) {
|
2019-06-21 22:06:04 +00:00
|
|
|
|
mMainCtrl.EditStatusFlags();
|
|
|
|
|
}
|
|
|
|
|
|
2019-11-23 04:45:57 +00:00
|
|
|
|
private void EditVisualizationSetCmd_Executed(object sender, ExecutedRoutedEventArgs e) {
|
|
|
|
|
mMainCtrl.EditVisualizationSet();
|
|
|
|
|
}
|
|
|
|
|
|
2019-06-22 20:20:31 +00:00
|
|
|
|
private void ExitCmd_Executed(object sender, ExecutedRoutedEventArgs e) {
|
|
|
|
|
Close();
|
|
|
|
|
}
|
|
|
|
|
|
2019-09-11 00:43:31 +00:00
|
|
|
|
private void ExportCmd_Executed(object sender, ExecutedRoutedEventArgs e) {
|
|
|
|
|
mMainCtrl.Export();
|
|
|
|
|
}
|
|
|
|
|
|
2019-07-07 20:28:45 +00:00
|
|
|
|
private void FindCmd_Executed(object sender, ExecutedRoutedEventArgs e) {
|
|
|
|
|
mMainCtrl.Find();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private void FindNextCmd_Executed(object sender, ExecutedRoutedEventArgs e) {
|
|
|
|
|
mMainCtrl.FindNext();
|
|
|
|
|
}
|
|
|
|
|
|
2019-10-10 00:41:44 +00:00
|
|
|
|
private void FindPreviousCmd_Executed(object sender, ExecutedRoutedEventArgs e) {
|
|
|
|
|
mMainCtrl.FindPrevious();
|
|
|
|
|
}
|
|
|
|
|
|
2019-07-14 20:50:15 +00:00
|
|
|
|
private void FormatAsWordCmd_Executed(object sender, ExecutedRoutedEventArgs e) {
|
|
|
|
|
mMainCtrl.FormatAsWord();
|
|
|
|
|
}
|
|
|
|
|
|
2019-09-15 20:37:38 +00:00
|
|
|
|
private void FormatAddressTableCmd_Executed(object sender, ExecutedRoutedEventArgs e) {
|
|
|
|
|
mMainCtrl.FormatAddressTable();
|
2019-07-13 20:31:51 +00:00
|
|
|
|
}
|
|
|
|
|
|
2019-07-07 21:28:35 +00:00
|
|
|
|
private void GotoCmd_Executed(object sender, ExecutedRoutedEventArgs e) {
|
|
|
|
|
mMainCtrl.Goto();
|
|
|
|
|
}
|
|
|
|
|
|
2019-11-02 01:44:22 +00:00
|
|
|
|
private void GotoLastChangeCmd_Executed(object sender, ExecutedRoutedEventArgs e) {
|
|
|
|
|
mMainCtrl.GotoLastChange();
|
|
|
|
|
}
|
|
|
|
|
|
2019-06-11 23:27:15 +00:00
|
|
|
|
private void HelpCmd_Executed(object sender, ExecutedRoutedEventArgs e) {
|
|
|
|
|
mMainCtrl.ShowHelp();
|
|
|
|
|
}
|
|
|
|
|
|
2020-10-14 22:02:53 +00:00
|
|
|
|
private void TagAsCodeStartPointCmd_Executed(object sender, ExecutedRoutedEventArgs e) {
|
|
|
|
|
Debug.WriteLine("tag as code start point");
|
2020-10-15 21:03:32 +00:00
|
|
|
|
mMainCtrl.MarkAsType(CodeAnalysis.AnalyzerTag.Code, true);
|
2019-06-04 23:07:04 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-10-14 22:02:53 +00:00
|
|
|
|
private void TagAsCodeStopPointCmd_Executed(object sender, ExecutedRoutedEventArgs e) {
|
|
|
|
|
Debug.WriteLine("tag as code stop point");
|
2020-10-15 21:03:32 +00:00
|
|
|
|
mMainCtrl.MarkAsType(CodeAnalysis.AnalyzerTag.Data, true);
|
2019-06-04 23:07:04 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-10-14 22:02:53 +00:00
|
|
|
|
private void TagAsInlineDataCmd_Executed(object sender, ExecutedRoutedEventArgs e) {
|
|
|
|
|
Debug.WriteLine("tag as inline data");
|
2020-10-15 21:03:32 +00:00
|
|
|
|
mMainCtrl.MarkAsType(CodeAnalysis.AnalyzerTag.InlineData, false);
|
2019-06-04 23:07:04 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-06-07 23:28:29 +00:00
|
|
|
|
private void JumpToOperandCmd_Executed(object sender, ExecutedRoutedEventArgs e) {
|
|
|
|
|
mMainCtrl.JumpToOperand();
|
|
|
|
|
}
|
|
|
|
|
|
2019-06-15 23:00:31 +00:00
|
|
|
|
private void NavigateBackwardCmd_Executed(object sender, ExecutedRoutedEventArgs e) {
|
|
|
|
|
mMainCtrl.NavigateBackward();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private void NavigateForwardCmd_Executed(object sender, ExecutedRoutedEventArgs e) {
|
|
|
|
|
mMainCtrl.NavigateForward();
|
|
|
|
|
}
|
|
|
|
|
|
2019-06-23 00:38:07 +00:00
|
|
|
|
private void NewProjectCmd_Executed(object sender, ExecutedRoutedEventArgs e) {
|
|
|
|
|
mMainCtrl.NewProject();
|
|
|
|
|
}
|
|
|
|
|
|
2019-06-21 23:27:58 +00:00
|
|
|
|
private void OpenCmd_Executed(object sender, ExecutedRoutedEventArgs e) {
|
|
|
|
|
mMainCtrl.OpenProject();
|
|
|
|
|
}
|
|
|
|
|
|
2019-07-13 00:04:14 +00:00
|
|
|
|
private void RecentProjectCmd_Executed(object sender, ExecutedRoutedEventArgs e) {
|
|
|
|
|
int recentIndex;
|
|
|
|
|
if (e.Parameter is int) {
|
|
|
|
|
recentIndex = (int)e.Parameter;
|
|
|
|
|
} else if (e.Parameter is string) {
|
|
|
|
|
recentIndex = int.Parse((string)e.Parameter);
|
|
|
|
|
} else {
|
|
|
|
|
throw new Exception("Bad parameter: " + e.Parameter);
|
|
|
|
|
}
|
|
|
|
|
if (recentIndex < 0 || recentIndex >= MainController.MAX_RECENT_PROJECTS) {
|
|
|
|
|
throw new Exception("Bad parameter: " + e.Parameter);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
Debug.WriteLine("Recent project #" + recentIndex);
|
|
|
|
|
mMainCtrl.OpenRecentProject(recentIndex);
|
|
|
|
|
}
|
|
|
|
|
|
2020-07-19 23:55:36 +00:00
|
|
|
|
private void RedoCmd_Executed(object sender, ExecutedRoutedEventArgs e) {
|
|
|
|
|
mMainCtrl.RedoChanges();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private void ReloadExternalFilesCmd_Executed(object sender, ExecutedRoutedEventArgs e) {
|
|
|
|
|
mMainCtrl.ReloadExternalFiles();
|
|
|
|
|
}
|
|
|
|
|
|
2020-10-14 22:02:53 +00:00
|
|
|
|
private void RemoveAnalyzerTagsCmd_Executed(object sender, ExecutedRoutedEventArgs e) {
|
2020-10-15 21:03:32 +00:00
|
|
|
|
mMainCtrl.MarkAsType(CodeAnalysis.AnalyzerTag.None, false);
|
2019-06-04 23:07:04 +00:00
|
|
|
|
}
|
|
|
|
|
|
2021-10-12 18:16:50 +00:00
|
|
|
|
private void RemoveFormattingCmd_Executed(object sender, ExecutedRoutedEventArgs e) {
|
|
|
|
|
mMainCtrl.RemoveFormatting();
|
|
|
|
|
}
|
|
|
|
|
|
2019-06-21 23:27:58 +00:00
|
|
|
|
private void SaveCmd_Executed(object sender, ExecutedRoutedEventArgs e) {
|
|
|
|
|
mMainCtrl.SaveProject();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private void SaveAsCmd_Executed(object sender, ExecutedRoutedEventArgs e) {
|
|
|
|
|
mMainCtrl.SaveProjectAs();
|
|
|
|
|
}
|
|
|
|
|
|
2019-05-28 21:23:17 +00:00
|
|
|
|
private void SelectAllCmd_Executed(object sender, ExecutedRoutedEventArgs e) {
|
|
|
|
|
DateTime start = DateTime.Now;
|
|
|
|
|
|
|
|
|
|
codeListView.SelectAll();
|
|
|
|
|
|
|
|
|
|
//codeListView.SelectedItems.Clear();
|
|
|
|
|
//foreach (var item in codeListView.Items) {
|
|
|
|
|
// codeListView.SelectedItems.Add(item);
|
|
|
|
|
//}
|
|
|
|
|
|
|
|
|
|
// This seems to be faster than setting items individually (10x), but is still O(n^2)
|
|
|
|
|
// or worse, and hence unsuitable for very large lists.
|
|
|
|
|
//codeListView.SelectedItems.Clear();
|
|
|
|
|
//listViewSetSelectedItems.Invoke(codeListView, new object[] { codeListView.Items });
|
|
|
|
|
|
2019-05-30 23:30:59 +00:00
|
|
|
|
Debug.WriteLine("Select All cmd: " + (DateTime.Now - start).TotalMilliseconds + " ms");
|
2019-05-28 21:23:17 +00:00
|
|
|
|
}
|
|
|
|
|
|
2019-07-13 00:46:37 +00:00
|
|
|
|
private void ShowFileHexDumpCmd_Executed(object sender, ExecutedRoutedEventArgs e) {
|
|
|
|
|
mMainCtrl.ShowFileHexDump();
|
|
|
|
|
}
|
|
|
|
|
|
2019-07-13 00:04:14 +00:00
|
|
|
|
private void ShowHexDumpCmd_Executed(object sender, ExecutedRoutedEventArgs e) {
|
|
|
|
|
mMainCtrl.ShowHexDump();
|
2019-05-05 23:50:28 +00:00
|
|
|
|
}
|
2019-05-12 23:27:28 +00:00
|
|
|
|
|
2019-12-30 01:59:35 +00:00
|
|
|
|
private void SliceFilesCmd_Executed(object sender, ExecutedRoutedEventArgs e) {
|
|
|
|
|
mMainCtrl.SliceFiles();
|
|
|
|
|
}
|
|
|
|
|
|
2020-08-20 20:18:46 +00:00
|
|
|
|
private void ToggleApple2ScreenChartCmd_Executed(object sender, ExecutedRoutedEventArgs e) {
|
|
|
|
|
mMainCtrl.ToggleApple2ScreenChart();
|
|
|
|
|
}
|
|
|
|
|
|
2019-07-15 01:12:03 +00:00
|
|
|
|
private void ToggleAsciiChartCmd_Executed(object sender, ExecutedRoutedEventArgs e) {
|
|
|
|
|
mMainCtrl.ToggleAsciiChart();
|
|
|
|
|
}
|
|
|
|
|
|
2019-07-08 00:17:48 +00:00
|
|
|
|
private void ToggleDataScanCmd_Executed(object sender, ExecutedRoutedEventArgs e) {
|
|
|
|
|
mMainCtrl.ToggleDataScan();
|
|
|
|
|
}
|
|
|
|
|
|
2019-10-21 22:15:09 +00:00
|
|
|
|
private void ToggleInstructionChartCmd_Executed(object sender, ExecutedRoutedEventArgs e) {
|
|
|
|
|
mMainCtrl.ToggleInstructionChart();
|
|
|
|
|
}
|
|
|
|
|
|
2019-07-14 20:50:15 +00:00
|
|
|
|
private void ToggleSingleByteFormatCmd_Executed(object sender, ExecutedRoutedEventArgs e) {
|
|
|
|
|
mMainCtrl.ToggleSingleByteFormat();
|
|
|
|
|
}
|
|
|
|
|
|
2019-06-11 23:27:15 +00:00
|
|
|
|
private void UndoCmd_Executed(object sender, ExecutedRoutedEventArgs e) {
|
|
|
|
|
mMainCtrl.UndoChanges();
|
|
|
|
|
}
|
|
|
|
|
|
ORG rework, part 5
Updated project file format to save the new map entries.
Tweaked appearance of .arend directives to show the .arstart address
in the operand field. This makes it easier to match them up on screen.
Also, add a synthetic comment on auto-generated .arstart entries.
Added .arstart/.arend to the things that respond to Jump to Operand
(Ctrl+J). Selecting one jumps to the other end. (Well, it jumps
to the code nearest the other, which will do for now.)
Added a menu item to display a text rendering of the address map.
Helpful when things get complicated.
Modified the linear map iterator to return .arend items with the offset
of the last byte in the region, rather than the first byte of the
following region. While the "exclusive end" approach is pretty
common, it caused problems when updating the line list, because it
meant that the .arend directives were outside the range of offsets
being updated (and, for directives at the end of the file, outside
the file itself). This was painful to deal with for partial updates.
Changing this required some relatively subtle changes and annoyed some
of the debug assertions, such as the one where all Line items have
offsets that match the start of a line, but it's the cleaner approach.
2021-09-28 00:02:18 +00:00
|
|
|
|
private void ViewAddressMapCmd_Executed(object sender, ExecutedRoutedEventArgs e) {
|
|
|
|
|
mMainCtrl.ViewAddressMap();
|
|
|
|
|
}
|
|
|
|
|
|
2019-10-24 00:49:59 +00:00
|
|
|
|
private void Debug_ApplesoftToHtmlCmd_Executed(object sender, ExecutedRoutedEventArgs e) {
|
|
|
|
|
mMainCtrl.Debug_ApplesoftToHtml();
|
|
|
|
|
}
|
|
|
|
|
|
2020-04-14 00:33:34 +00:00
|
|
|
|
private void Debug_ApplyEditCommandsCmd_Executed(object sender,
|
|
|
|
|
ExecutedRoutedEventArgs e) {
|
|
|
|
|
mMainCtrl.Debug_ApplyEditCommands();
|
|
|
|
|
}
|
|
|
|
|
|
2020-07-28 17:56:07 +00:00
|
|
|
|
private void Debug_ApplyExternalSymbolsCmd_Executed(object sender,
|
2019-11-19 21:31:04 +00:00
|
|
|
|
ExecutedRoutedEventArgs e) {
|
2020-07-28 17:56:07 +00:00
|
|
|
|
mMainCtrl.Debug_ApplyExternalSymbols();
|
2019-11-19 21:31:04 +00:00
|
|
|
|
}
|
|
|
|
|
|
2020-07-15 23:18:02 +00:00
|
|
|
|
private void Debug_ExportEditCommandsCmd_Executed(object sender,
|
|
|
|
|
ExecutedRoutedEventArgs e) {
|
|
|
|
|
mMainCtrl.Debug_ExportEditCommands();
|
|
|
|
|
}
|
|
|
|
|
|
2019-10-24 00:49:59 +00:00
|
|
|
|
private void Debug_ExtensionScriptInfoCmd_Executed(object sender,
|
|
|
|
|
ExecutedRoutedEventArgs e) {
|
2019-07-15 23:50:54 +00:00
|
|
|
|
mMainCtrl.Debug_ExtensionScriptInfo();
|
|
|
|
|
}
|
|
|
|
|
|
Reboot sandbox when required
Another chapter in the never-ending AppDomain security saga.
If a computer goes to sleep while SourceGen is running with a project
open, life gets confusing when the system wakes up. The keep-alive
timer fires and a ping is sent to the remote AppDomain, successfully.
At the same time, the lease expires on the remote side, and the objects
are discarded (apparently without bothering to query the ILease object).
This failure mode is 100% repeatable.
Since we can't prevent sandbox objects from disappearing, we have to
detect and recover from the problem. Fortunately we don't keep any
necessary state on the plugin side, so we can just tear the whole
thing down and recreate it.
The various methods in ScriptManager now do a "health check" before
making calls into the plugin AppDomain. If the ping attempt fails,
the AppDomain is "rebooted" by destroying it and creating a new one,
reloading all plugins that were in there before. The plugin binaries
*should* still be in the PluginDllCache directory since the ping failure
was due to objects being discarded, not AppDomain shutdown, and Windows
doesn't let you mess with files that hold executable code.
A new "reboot security sandbox" option has been added to the DEBUG
menu to facilitate testing.
The PluginManager's Ping() method gets called more often, but not to
the extent that performance will be affected.
This change also adds a finalizer to DisasmProject, since we're relying
on it to shut down the ScriptManager, and it's relying on callers to
invoke its cleanup function. The finalizer throws an assertion if the
cleanup function doesn't get called.
(Issue #82)
2020-07-19 20:20:18 +00:00
|
|
|
|
private void Debug_RebootSecuritySandboxCmd_Executed(object sender,
|
|
|
|
|
ExecutedRoutedEventArgs e) {
|
|
|
|
|
mMainCtrl.Debug_RebootSecuritySandbox();
|
|
|
|
|
}
|
|
|
|
|
|
2019-07-15 22:32:27 +00:00
|
|
|
|
private void Debug_RefreshCmd_Executed(object sender, ExecutedRoutedEventArgs e) {
|
|
|
|
|
mMainCtrl.Debug_Refresh();
|
|
|
|
|
}
|
|
|
|
|
|
2019-07-16 00:18:28 +00:00
|
|
|
|
private void Debug_ShowAnalysisTimersCmd_Executed(object sender,
|
|
|
|
|
ExecutedRoutedEventArgs e) {
|
|
|
|
|
mMainCtrl.Debug_ShowAnalysisTimers();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private void Debug_ShowAnalyzerOutputCmd_Executed(object sender,
|
|
|
|
|
ExecutedRoutedEventArgs e) {
|
|
|
|
|
mMainCtrl.Debug_ShowAnalyzerOutput();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private void Debug_ShowUndoRedoHistoryCmd_Executed(object sender,
|
|
|
|
|
ExecutedRoutedEventArgs e) {
|
|
|
|
|
mMainCtrl.Debug_ShowUndoRedoHistory();
|
|
|
|
|
}
|
|
|
|
|
|
2019-07-15 23:50:54 +00:00
|
|
|
|
private void Debug_SourceGenerationTestsCmd_Executed(object sender,
|
|
|
|
|
ExecutedRoutedEventArgs e) {
|
|
|
|
|
mMainCtrl.Debug_RunSourceGenerationTests();
|
|
|
|
|
}
|
|
|
|
|
|
2019-07-15 22:32:27 +00:00
|
|
|
|
private void Debug_ToggleCommentRulersCmd_Executed(object sender, ExecutedRoutedEventArgs e) {
|
|
|
|
|
mMainCtrl.Debug_ToggleCommentRulers();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private void Debug_ToggleKeepAliveHackCmd_Executed(object sender, ExecutedRoutedEventArgs e) {
|
|
|
|
|
mMainCtrl.Debug_ToggleKeepAliveHack();
|
|
|
|
|
}
|
|
|
|
|
|
2020-07-18 20:47:01 +00:00
|
|
|
|
private void Debug_ToggleSecuritySandboxCmd_Executed(object sender, ExecutedRoutedEventArgs e) {
|
|
|
|
|
mMainCtrl.Debug_ToggleSecuritySandbox();
|
|
|
|
|
}
|
|
|
|
|
|
2019-06-08 00:25:04 +00:00
|
|
|
|
#endregion Command handlers
|
2019-06-10 01:09:00 +00:00
|
|
|
|
|
2019-06-22 21:41:09 +00:00
|
|
|
|
#region Misc
|
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
|
/// Handles a double-click on the code list. We have to figure out which row and
|
|
|
|
|
/// column were clicked, which is not easy in WPF.
|
|
|
|
|
/// </summary>
|
|
|
|
|
private void CodeListView_MouseDoubleClick(object sender, MouseButtonEventArgs e) {
|
|
|
|
|
Debug.Assert(sender == codeListView);
|
|
|
|
|
|
|
|
|
|
ListViewItem lvi = codeListView.GetClickedItem(e);
|
|
|
|
|
if (lvi == null) {
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
DisplayList.FormattedParts parts = (DisplayList.FormattedParts)lvi.Content;
|
|
|
|
|
int row = parts.ListIndex;
|
|
|
|
|
int col = codeListView.GetClickEventColumn(e);
|
|
|
|
|
if (col < 0) {
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
mMainCtrl.HandleCodeListDoubleClick(row, col);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private void RecentProjectsMenu_SubmenuOpened(object sender, RoutedEventArgs e) {
|
|
|
|
|
MenuItem recents = (MenuItem)sender;
|
|
|
|
|
recents.Items.Clear();
|
|
|
|
|
|
2019-07-08 20:40:28 +00:00
|
|
|
|
//Debug.WriteLine("COUNT is " + mMainCtrl.RecentProjectPaths.Count);
|
2019-06-22 21:41:09 +00:00
|
|
|
|
if (mMainCtrl.RecentProjectPaths.Count == 0) {
|
|
|
|
|
MenuItem mi = new MenuItem();
|
2019-06-27 22:15:45 +00:00
|
|
|
|
mi.Header = Res.Strings.PARENTHETICAL_NONE;
|
2019-06-22 21:41:09 +00:00
|
|
|
|
recents.Items.Add(mi);
|
|
|
|
|
} else {
|
|
|
|
|
for (int i = 0; i < mMainCtrl.RecentProjectPaths.Count; i++) {
|
|
|
|
|
MenuItem mi = new MenuItem();
|
|
|
|
|
mi.Header = string.Format("{0}: {1}", i + 1, mMainCtrl.RecentProjectPaths[i]);
|
|
|
|
|
mi.Command = recentProjectCmd.Command;
|
|
|
|
|
mi.CommandParameter = i;
|
|
|
|
|
recents.Items.Add(mi);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2019-12-07 21:55:11 +00:00
|
|
|
|
public Visibility RecentProjectVisibility1 {
|
|
|
|
|
get { return mRecentProjectVisibility1; }
|
|
|
|
|
set { mRecentProjectVisibility1 = value; OnPropertyChanged(); }
|
|
|
|
|
}
|
|
|
|
|
private Visibility mRecentProjectVisibility1;
|
|
|
|
|
|
|
|
|
|
public string RecentProjectName1 {
|
|
|
|
|
get { return mRecentProjectName1; }
|
|
|
|
|
set { mRecentProjectName1 = value; OnPropertyChanged(); }
|
|
|
|
|
}
|
|
|
|
|
private string mRecentProjectName1;
|
|
|
|
|
|
|
|
|
|
public string RecentProjectPath1 {
|
|
|
|
|
get { return mRecentProjectPath1; }
|
|
|
|
|
set { mRecentProjectPath1 = value; OnPropertyChanged(); }
|
|
|
|
|
}
|
|
|
|
|
private string mRecentProjectPath1;
|
|
|
|
|
|
|
|
|
|
public Visibility RecentProjectVisibility2 {
|
|
|
|
|
get { return mRecentProjectVisibility2; }
|
|
|
|
|
set { mRecentProjectVisibility2 = value; OnPropertyChanged(); }
|
|
|
|
|
}
|
|
|
|
|
private Visibility mRecentProjectVisibility2;
|
|
|
|
|
|
|
|
|
|
public string RecentProjectName2 {
|
|
|
|
|
get { return mRecentProjectName2; }
|
|
|
|
|
set { mRecentProjectName2 = value; OnPropertyChanged(); }
|
|
|
|
|
}
|
|
|
|
|
private string mRecentProjectName2;
|
|
|
|
|
|
|
|
|
|
public string RecentProjectPath2 {
|
|
|
|
|
get { return mRecentProjectPath2; }
|
|
|
|
|
set { mRecentProjectPath2 = value; OnPropertyChanged(); }
|
|
|
|
|
}
|
|
|
|
|
private string mRecentProjectPath2;
|
|
|
|
|
|
2019-06-22 21:41:09 +00:00
|
|
|
|
public void UpdateRecentLinks() {
|
|
|
|
|
List<string> pathList = mMainCtrl.RecentProjectPaths;
|
|
|
|
|
|
|
|
|
|
if (pathList.Count >= 1) {
|
2019-12-07 21:55:11 +00:00
|
|
|
|
RecentProjectPath1 = pathList[0];
|
|
|
|
|
RecentProjectName1 = Path.GetFileName(pathList[0]);
|
|
|
|
|
RecentProjectVisibility1 = Visibility.Visible;
|
2019-06-22 21:41:09 +00:00
|
|
|
|
} else {
|
2019-12-07 21:55:11 +00:00
|
|
|
|
RecentProjectVisibility1 = Visibility.Collapsed;
|
2019-06-22 21:41:09 +00:00
|
|
|
|
}
|
|
|
|
|
if (pathList.Count >= 2) {
|
2019-12-07 21:55:11 +00:00
|
|
|
|
RecentProjectPath2 = pathList[1];
|
|
|
|
|
RecentProjectName2 = Path.GetFileName(pathList[1]);
|
|
|
|
|
RecentProjectVisibility2 = Visibility.Visible;
|
2019-06-22 21:41:09 +00:00
|
|
|
|
} else {
|
2019-12-07 21:55:11 +00:00
|
|
|
|
RecentProjectVisibility2 = Visibility.Collapsed;
|
2019-06-22 21:41:09 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2019-07-08 00:17:48 +00:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Update menu items when the "edit" menu is opened.
|
|
|
|
|
/// </summary>
|
|
|
|
|
private void EditMenu_SubmenuOpened(object sender, RoutedEventArgs e) {
|
|
|
|
|
// Set the checkbox on the "Toggle Data Scan" item.
|
|
|
|
|
//
|
|
|
|
|
// I initially bound a property to the menu item's IsChecked, but that caused
|
|
|
|
|
// us to get "set" calls when the menu was selected. I want to get activity
|
|
|
|
|
// through ICommand, not property set, so things are consistent for menus and
|
|
|
|
|
// keyboard shortcuts. So we just drive the checkbox manually. I don't know
|
|
|
|
|
// if there's a better way.
|
|
|
|
|
//
|
|
|
|
|
// The project's AnalyzeUncategorizedData property can be set in various ways
|
|
|
|
|
// (project property dialog, undo, redo), so we want to query it when we need
|
|
|
|
|
// it rather than try to push changes around.
|
|
|
|
|
toggleDataScanMenuItem.IsChecked = mMainCtrl.IsAnalyzeUncategorizedDataEnabled;
|
|
|
|
|
}
|
2019-07-15 01:12:03 +00:00
|
|
|
|
private void ToolsMenu_SubmenuOpened(object sender, RoutedEventArgs e) {
|
2020-08-20 20:18:46 +00:00
|
|
|
|
toggleApple2ScreenChartMenuItem.IsChecked = mMainCtrl.IsApple2ScreenChartOpen;
|
2019-07-15 01:12:03 +00:00
|
|
|
|
toggleAsciiChartMenuItem.IsChecked = mMainCtrl.IsAsciiChartOpen;
|
2019-10-21 22:15:09 +00:00
|
|
|
|
toggleInstructionChartMenuItem.IsChecked = mMainCtrl.IsInstructionChartOpen;
|
2019-07-15 01:12:03 +00:00
|
|
|
|
}
|
2019-07-15 22:32:27 +00:00
|
|
|
|
private void DebugMenu_SubmenuOpened(object sender, RoutedEventArgs e) {
|
|
|
|
|
debugCommentRulersMenuItem.IsChecked = MultiLineComment.DebugShowRuler;
|
2020-07-18 20:47:01 +00:00
|
|
|
|
debugKeepAliveHackMenuItem.IsChecked = !Sandbox.ScriptManager.UseKeepAliveHack;
|
|
|
|
|
debugSecuritySandboxMenuItem.IsChecked = mMainCtrl.UseMainAppDomainForPlugins;
|
2019-07-16 00:18:28 +00:00
|
|
|
|
debugAnalysisTimersMenuItem.IsChecked = mMainCtrl.IsDebugAnalysisTimersOpen;
|
|
|
|
|
debugAnalyzerOutputMenuItem.IsChecked = mMainCtrl.IsDebugAnalyzerOutputOpen;
|
|
|
|
|
debugUndoRedoHistoryMenuItem.IsChecked = mMainCtrl.IsDebugUndoRedoHistoryOpen;
|
2019-07-15 22:32:27 +00:00
|
|
|
|
}
|
2019-07-08 00:17:48 +00:00
|
|
|
|
|
2019-06-22 21:41:09 +00:00
|
|
|
|
#endregion Misc
|
|
|
|
|
|
2019-06-10 01:09:00 +00:00
|
|
|
|
#region References panel
|
|
|
|
|
|
|
|
|
|
public class ReferencesListItem {
|
2019-06-15 23:00:31 +00:00
|
|
|
|
public int OffsetValue { get; private set; }
|
2019-06-10 01:09:00 +00:00
|
|
|
|
public string Offset { get; private set; }
|
|
|
|
|
public string Addr { get; private set; }
|
|
|
|
|
public string Type { get; private set; }
|
|
|
|
|
|
2019-06-15 23:00:31 +00:00
|
|
|
|
public ReferencesListItem(int offsetValue, string offset, string addr, string type) {
|
|
|
|
|
OffsetValue = offsetValue;
|
2019-06-10 01:09:00 +00:00
|
|
|
|
Offset = offset;
|
|
|
|
|
Addr = addr;
|
|
|
|
|
Type = type;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public override string ToString() {
|
|
|
|
|
return "[ReferencesListItem: off=" + Offset + " addr=" + Addr + " type=" +
|
|
|
|
|
Type + "]";
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public ObservableCollection<ReferencesListItem> ReferencesList { get; private set; } =
|
|
|
|
|
new ObservableCollection<ReferencesListItem>();
|
|
|
|
|
|
2019-06-15 23:00:31 +00:00
|
|
|
|
private void ReferencesList_MouseDoubleClick(object sender, MouseButtonEventArgs e) {
|
2019-10-02 01:20:51 +00:00
|
|
|
|
if (!referencesGrid.GetClickRowColItem(e, out int unusedRow, out int unusedCol,
|
2019-06-15 23:00:31 +00:00
|
|
|
|
out object item)) {
|
|
|
|
|
// Header or empty area; ignore.
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
ReferencesListItem rli = (ReferencesListItem)item;
|
|
|
|
|
|
|
|
|
|
// Jump to the offset, then shift the focus back to the code list.
|
2021-10-07 19:39:08 +00:00
|
|
|
|
mMainCtrl.GoToLocation(new NavStack.Location(rli.OffsetValue, 0,
|
|
|
|
|
NavStack.GoToMode.JumpToCodeData), true);
|
2021-10-25 22:45:42 +00:00
|
|
|
|
//codeListView.Focus();
|
2019-06-15 23:00:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
2019-06-10 01:09:00 +00:00
|
|
|
|
#endregion References panel
|
2019-06-12 21:17:24 +00:00
|
|
|
|
|
|
|
|
|
#region Notes panel
|
2019-06-12 22:54:22 +00:00
|
|
|
|
|
|
|
|
|
public class NotesListItem {
|
2019-06-15 23:00:31 +00:00
|
|
|
|
public int OffsetValue { get; private set; }
|
2019-06-12 22:54:22 +00:00
|
|
|
|
public string Offset { get; private set; }
|
|
|
|
|
public string Note { get; private set; }
|
|
|
|
|
public SolidColorBrush BackBrush { get; private set; }
|
|
|
|
|
|
2019-06-15 23:00:31 +00:00
|
|
|
|
public NotesListItem(int offsetValue, string offset, string note, Color backColor) {
|
|
|
|
|
OffsetValue = offsetValue;
|
2019-06-12 22:54:22 +00:00
|
|
|
|
Offset = offset;
|
|
|
|
|
Note = note;
|
2019-10-09 18:06:45 +00:00
|
|
|
|
if (backColor == CommonWPF.Helper.ZeroColor) {
|
|
|
|
|
// Force this to white, so we can always use black text. This is not ideal.
|
|
|
|
|
backColor = Colors.White;
|
|
|
|
|
}
|
2019-06-12 22:54:22 +00:00
|
|
|
|
BackBrush = new SolidColorBrush(backColor);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public override string ToString() {
|
|
|
|
|
return "[NotesListItem: off=" + Offset + " note=" + Note + " brush=" +
|
|
|
|
|
BackBrush + "]";
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public ObservableCollection<NotesListItem> NotesList { get; private set; } =
|
|
|
|
|
new ObservableCollection<NotesListItem>();
|
|
|
|
|
|
2019-06-15 23:00:31 +00:00
|
|
|
|
private void NotesList_MouseDoubleClick(object sender, MouseButtonEventArgs e) {
|
2019-10-02 01:20:51 +00:00
|
|
|
|
if (!notesGrid.GetClickRowColItem(e, out int unusedRow, out int unusedCol,
|
2019-06-15 23:00:31 +00:00
|
|
|
|
out object item)) {
|
|
|
|
|
// Header or empty area; ignore.
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
NotesListItem nli = (NotesListItem)item;
|
|
|
|
|
|
|
|
|
|
// Jump to the offset, then shift the focus back to the code list.
|
2021-10-07 19:39:08 +00:00
|
|
|
|
mMainCtrl.GoToLocation(new NavStack.Location(nli.OffsetValue, 0,
|
|
|
|
|
NavStack.GoToMode.JumpToNote), true);
|
2021-10-25 22:45:42 +00:00
|
|
|
|
//codeListView.Focus();
|
2019-06-15 23:00:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
2019-06-12 21:17:24 +00:00
|
|
|
|
#endregion Notes panel
|
|
|
|
|
|
|
|
|
|
#region Symbols panel
|
|
|
|
|
|
2019-10-20 21:40:32 +00:00
|
|
|
|
//
|
|
|
|
|
// Symbols list filter options.
|
|
|
|
|
//
|
2019-11-16 04:40:14 +00:00
|
|
|
|
|
|
|
|
|
private bool mSymFilterUserLabels;
|
2019-10-20 21:40:32 +00:00
|
|
|
|
public bool SymFilterUserLabels {
|
|
|
|
|
get { return mSymFilterUserLabels; }
|
|
|
|
|
set {
|
|
|
|
|
mSymFilterUserLabels = value;
|
|
|
|
|
AppSettings.Global.SetBool(AppSettings.SYMWIN_SHOW_USER, value);
|
|
|
|
|
SymbolsListFilterChanged();
|
|
|
|
|
OnPropertyChanged();
|
|
|
|
|
}
|
|
|
|
|
}
|
2019-11-16 04:40:14 +00:00
|
|
|
|
private bool mSymFilterNonUniqueLabels;
|
|
|
|
|
public bool SymFilterNonUniqueLabels {
|
|
|
|
|
get { return mSymFilterNonUniqueLabels; }
|
|
|
|
|
set {
|
|
|
|
|
mSymFilterNonUniqueLabels = value;
|
|
|
|
|
AppSettings.Global.SetBool(AppSettings.SYMWIN_SHOW_NON_UNIQUE, value);
|
|
|
|
|
SymbolsListFilterChanged();
|
|
|
|
|
OnPropertyChanged();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
private bool mSymFilterProjectSymbols;
|
2019-10-20 21:40:32 +00:00
|
|
|
|
public bool SymFilterProjectSymbols {
|
|
|
|
|
get { return mSymFilterProjectSymbols; }
|
|
|
|
|
set {
|
|
|
|
|
mSymFilterProjectSymbols = value;
|
|
|
|
|
AppSettings.Global.SetBool(AppSettings.SYMWIN_SHOW_PROJECT, value);
|
|
|
|
|
SymbolsListFilterChanged();
|
|
|
|
|
OnPropertyChanged();
|
|
|
|
|
}
|
|
|
|
|
}
|
2019-11-16 04:40:14 +00:00
|
|
|
|
private bool mSymFilterPlatformSymbols;
|
2019-10-20 21:40:32 +00:00
|
|
|
|
public bool SymFilterPlatformSymbols {
|
|
|
|
|
get { return mSymFilterPlatformSymbols; }
|
|
|
|
|
set {
|
|
|
|
|
mSymFilterPlatformSymbols = value;
|
|
|
|
|
AppSettings.Global.SetBool(AppSettings.SYMWIN_SHOW_PLATFORM, value);
|
|
|
|
|
SymbolsListFilterChanged();
|
|
|
|
|
OnPropertyChanged();
|
|
|
|
|
}
|
|
|
|
|
}
|
2021-10-05 03:41:19 +00:00
|
|
|
|
private bool mSymFilterAddrPreLabels;
|
|
|
|
|
public bool SymFilterAddrPreLabels {
|
|
|
|
|
get { return mSymFilterAddrPreLabels; }
|
|
|
|
|
set {
|
|
|
|
|
mSymFilterAddrPreLabels = value;
|
|
|
|
|
AppSettings.Global.SetBool(AppSettings.SYMWIN_SHOW_ADDR_PRE_LABELS, value);
|
|
|
|
|
SymbolsListFilterChanged();
|
|
|
|
|
OnPropertyChanged();
|
|
|
|
|
}
|
|
|
|
|
}
|
2019-11-16 04:40:14 +00:00
|
|
|
|
private bool mSymFilterAutoLabels;
|
2019-10-20 21:40:32 +00:00
|
|
|
|
public bool SymFilterAutoLabels {
|
|
|
|
|
get { return mSymFilterAutoLabels; }
|
|
|
|
|
set {
|
|
|
|
|
mSymFilterAutoLabels = value;
|
|
|
|
|
AppSettings.Global.SetBool(AppSettings.SYMWIN_SHOW_AUTO, value);
|
|
|
|
|
SymbolsListFilterChanged();
|
|
|
|
|
OnPropertyChanged();
|
|
|
|
|
}
|
|
|
|
|
}
|
2019-11-16 04:40:14 +00:00
|
|
|
|
private bool mSymFilterAddresses;
|
2019-10-20 21:40:32 +00:00
|
|
|
|
public bool SymFilterAddresses {
|
|
|
|
|
get { return mSymFilterAddresses; }
|
|
|
|
|
set {
|
|
|
|
|
mSymFilterAddresses = value;
|
|
|
|
|
AppSettings.Global.SetBool(AppSettings.SYMWIN_SHOW_ADDR, value);
|
|
|
|
|
SymbolsListFilterChanged();
|
|
|
|
|
OnPropertyChanged();
|
|
|
|
|
}
|
|
|
|
|
}
|
2019-11-16 04:40:14 +00:00
|
|
|
|
private bool mSymFilterConstants;
|
2019-10-20 21:40:32 +00:00
|
|
|
|
public bool SymFilterConstants {
|
|
|
|
|
get { return mSymFilterConstants; }
|
|
|
|
|
set {
|
|
|
|
|
mSymFilterConstants = value;
|
|
|
|
|
AppSettings.Global.SetBool(AppSettings.SYMWIN_SHOW_CONST, value);
|
|
|
|
|
SymbolsListFilterChanged();
|
|
|
|
|
OnPropertyChanged();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
|
/// Symbols list DataGrid item.
|
|
|
|
|
/// </summary>
|
2019-06-12 21:17:24 +00:00
|
|
|
|
public class SymbolsListItem {
|
|
|
|
|
public Symbol Sym { get; private set; }
|
|
|
|
|
public string Type { get; private set; }
|
|
|
|
|
public string Value { get; private set; }
|
|
|
|
|
public string Name { get; private set; }
|
|
|
|
|
|
|
|
|
|
public SymbolsListItem(Symbol sym, string type, string value, string name) {
|
|
|
|
|
Sym = sym;
|
|
|
|
|
|
|
|
|
|
Type = type;
|
|
|
|
|
Value = value;
|
|
|
|
|
Name = name;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public override string ToString() {
|
|
|
|
|
return "[SymbolsListItem: type=" + Type + " value=" + Value + " name=" +
|
|
|
|
|
Name + "]";
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public ObservableCollection<SymbolsListItem> SymbolsList { get; private set; } =
|
|
|
|
|
new ObservableCollection<SymbolsListItem>();
|
|
|
|
|
|
2019-06-15 23:00:31 +00:00
|
|
|
|
private void SymbolsList_MouseDoubleClick(object sender, MouseButtonEventArgs e) {
|
2019-10-02 01:20:51 +00:00
|
|
|
|
if (!symbolsGrid.GetClickRowColItem(e, out int unusedRow, out int unusedCol,
|
2019-06-15 23:00:31 +00:00
|
|
|
|
out object item)) {
|
|
|
|
|
// Header or empty area; ignore.
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
SymbolsListItem sli = (SymbolsListItem)item;
|
|
|
|
|
|
2021-10-05 03:41:19 +00:00
|
|
|
|
// TODO: this should also work for project/platform symbols that have EQU directives
|
2019-06-15 23:00:31 +00:00
|
|
|
|
mMainCtrl.GoToLabel(sli.Sym);
|
2021-10-25 22:45:42 +00:00
|
|
|
|
//codeListView.Focus();
|
2019-06-15 23:00:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
2019-06-12 21:17:24 +00:00
|
|
|
|
private void SymbolsList_Filter(object sender, FilterEventArgs e) {
|
|
|
|
|
SymbolsListItem sli = (SymbolsListItem)e.Item;
|
|
|
|
|
if (sli == null) {
|
|
|
|
|
return;
|
|
|
|
|
}
|
2019-07-16 21:52:08 +00:00
|
|
|
|
if ((SymFilterUserLabels != true && sli.Sym.SymbolSource == Symbol.Source.User) ||
|
2019-11-16 04:40:14 +00:00
|
|
|
|
(SymFilterNonUniqueLabels != true && sli.Sym.IsNonUnique) ||
|
2019-07-16 21:52:08 +00:00
|
|
|
|
(SymFilterProjectSymbols != true && sli.Sym.SymbolSource == Symbol.Source.Project) ||
|
|
|
|
|
(SymFilterPlatformSymbols != true && sli.Sym.SymbolSource == Symbol.Source.Platform) ||
|
2021-10-05 03:41:19 +00:00
|
|
|
|
(SymFilterAddrPreLabels != true && sli.Sym.SymbolSource == Symbol.Source.AddrPreLabel) ||
|
2019-07-16 21:52:08 +00:00
|
|
|
|
(SymFilterAutoLabels != true && sli.Sym.SymbolSource == Symbol.Source.Auto) ||
|
2019-10-23 04:27:49 +00:00
|
|
|
|
(SymFilterAddresses != true && !sli.Sym.IsConstant) ||
|
|
|
|
|
(SymFilterConstants != true && sli.Sym.IsConstant) ||
|
2019-08-31 01:33:05 +00:00
|
|
|
|
sli.Sym.IsVariable)
|
2019-06-12 21:17:24 +00:00
|
|
|
|
{
|
|
|
|
|
e.Accepted = false;
|
|
|
|
|
} else {
|
|
|
|
|
e.Accepted = true;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// <summary>
|
2019-07-16 21:52:08 +00:00
|
|
|
|
/// Refreshes the symbols list when a filter option changes.
|
2019-06-12 21:17:24 +00:00
|
|
|
|
/// </summary>
|
2019-07-16 21:52:08 +00:00
|
|
|
|
private void SymbolsListFilterChanged() {
|
2019-06-12 21:17:24 +00:00
|
|
|
|
// This delightfully obscure call causes the list to refresh. See
|
|
|
|
|
// https://docs.microsoft.com/en-us/dotnet/framework/wpf/controls/how-to-group-sort-and-filter-data-in-the-datagrid-control
|
2019-06-15 23:00:31 +00:00
|
|
|
|
CollectionViewSource.GetDefaultView(symbolsGrid.ItemsSource).Refresh();
|
2019-06-12 21:17:24 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
|
/// Handles a Sorting event. We want to do a secondary sort on Name when one of the
|
|
|
|
|
/// other columns is the primary sort key.
|
|
|
|
|
/// </summary>
|
2019-10-02 01:20:51 +00:00
|
|
|
|
/// <remarks>
|
|
|
|
|
/// https://stackoverflow.com/a/2130557/294248
|
|
|
|
|
/// </remarks>
|
2019-06-12 21:17:24 +00:00
|
|
|
|
private void SymbolsList_Sorting(object sender, DataGridSortingEventArgs e) {
|
|
|
|
|
DataGridColumn col = e.Column;
|
|
|
|
|
|
|
|
|
|
// Set the SortDirection to a specific value. If we don't do this, SortDirection
|
|
|
|
|
// remains un-set, and the column header doesn't show up/down arrows or change
|
|
|
|
|
// direction when clicked twice.
|
|
|
|
|
ListSortDirection direction = (col.SortDirection != ListSortDirection.Ascending) ?
|
|
|
|
|
ListSortDirection.Ascending : ListSortDirection.Descending;
|
|
|
|
|
col.SortDirection = direction;
|
|
|
|
|
|
|
|
|
|
bool isAscending = direction != ListSortDirection.Descending;
|
|
|
|
|
|
|
|
|
|
IComparer comparer;
|
|
|
|
|
|
|
|
|
|
switch (col.Header) {
|
|
|
|
|
case "Type":
|
2019-06-17 19:44:02 +00:00
|
|
|
|
comparer = new SymTabSortComparer(Symbol.SymbolSortField.CombinedType,
|
|
|
|
|
isAscending);
|
2019-06-12 21:17:24 +00:00
|
|
|
|
break;
|
|
|
|
|
case "Value":
|
2019-06-17 19:44:02 +00:00
|
|
|
|
comparer = new SymTabSortComparer(Symbol.SymbolSortField.Value, isAscending);
|
2019-06-12 21:17:24 +00:00
|
|
|
|
break;
|
|
|
|
|
case "Name":
|
2019-06-17 19:44:02 +00:00
|
|
|
|
comparer = new SymTabSortComparer(Symbol.SymbolSortField.Name, isAscending);
|
2019-06-12 21:17:24 +00:00
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
comparer = null;
|
|
|
|
|
Debug.Assert(false);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ListCollectionView lcv =
|
2019-06-15 23:00:31 +00:00
|
|
|
|
(ListCollectionView)CollectionViewSource.GetDefaultView(symbolsGrid.ItemsSource);
|
2019-06-12 21:17:24 +00:00
|
|
|
|
lcv.CustomSort = comparer;
|
|
|
|
|
e.Handled = true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Symbol table sort comparison helper.
|
|
|
|
|
private class SymTabSortComparer : IComparer {
|
2019-06-17 19:44:02 +00:00
|
|
|
|
private Symbol.SymbolSortField mSortField;
|
2019-06-12 21:17:24 +00:00
|
|
|
|
private bool mIsAscending;
|
|
|
|
|
|
2019-06-17 19:44:02 +00:00
|
|
|
|
public SymTabSortComparer(Symbol.SymbolSortField prim, bool isAscending) {
|
2019-06-12 21:17:24 +00:00
|
|
|
|
mSortField = prim;
|
|
|
|
|
mIsAscending = isAscending;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// IComparer interface
|
|
|
|
|
public int Compare(object oa, object ob) {
|
|
|
|
|
Symbol a = ((SymbolsListItem)oa).Sym;
|
|
|
|
|
Symbol b = ((SymbolsListItem)ob).Sym;
|
|
|
|
|
|
2019-06-17 19:44:02 +00:00
|
|
|
|
return Symbol.Compare(mSortField, mIsAscending, a, b);
|
2019-06-12 21:17:24 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#endregion Symbols panel
|
|
|
|
|
|
|
|
|
|
#region Info panel
|
|
|
|
|
|
|
|
|
|
/// <summary>
|
2019-10-23 04:27:49 +00:00
|
|
|
|
/// Text for the line number / description section.
|
2019-06-12 21:17:24 +00:00
|
|
|
|
/// </summary>
|
2019-10-23 04:27:49 +00:00
|
|
|
|
public string InfoLineDescrText {
|
|
|
|
|
get { return mInfoLineDescrText; }
|
|
|
|
|
set { mInfoLineDescrText = value; OnPropertyChanged(); }
|
|
|
|
|
}
|
|
|
|
|
private string mInfoLineDescrText;
|
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
|
/// Text for the offset, shown only in debug builds.
|
|
|
|
|
/// </summary>
|
|
|
|
|
public string InfoOffsetText {
|
|
|
|
|
get { return mInfoOffsetText; }
|
|
|
|
|
set { mInfoOffsetText = value; OnPropertyChanged(); }
|
|
|
|
|
}
|
|
|
|
|
private string mInfoOffsetText;
|
|
|
|
|
|
Label rework, part 6
Correct handling of local variables. We now correctly uniquify them
with regard to non-unique labels. Because local vars can effectively
have global scope we mostly want to treat them as global, but they're
uniquified relative to other globals very late in the process, so we
can't just throw them in the symbol table and be done. Fortunately
local variables exist in a separate namespace, so we just need to
uniquify the variables relative to the post-localization symbol table.
In other words, we take the symbol table, apply the label map, and
rename any variable that clashes.
This also fixes an older problem where we weren't masking the
leading '_' on variable labels when generating 64tass output.
The code list now makes non-unique labels obvious, but you can't tell
the difference between unique global and unique local. What's more,
the default type value in Edit Label is now adjusted to Global for
unique locals that were auto-generated. To make it a bit easier to
figure out what's what, the Info panel now has a "label type" line
that reports the type.
The 2023-non-unique-labels test had some additional tests added to
exercise conflicts with local variables. The 2019-local-variables
test output changed slightly because the de-duplicated variable
naming convention was simplified.
2019-11-18 21:26:03 +00:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Text for the label description.
|
|
|
|
|
/// </summary>
|
|
|
|
|
public string InfoLabelDescrText {
|
|
|
|
|
get { return mInfoLabelDescrText; }
|
|
|
|
|
set { mInfoLabelDescrText = value; OnPropertyChanged(); }
|
|
|
|
|
}
|
|
|
|
|
private string mInfoLabelDescrText;
|
|
|
|
|
|
2019-10-23 04:27:49 +00:00
|
|
|
|
public SolidColorBrush InfoFormatBoxBrush {
|
|
|
|
|
get { return mInfoFormatBoxBrush; }
|
|
|
|
|
set { mInfoFormatBoxBrush = value; OnPropertyChanged(); }
|
|
|
|
|
}
|
|
|
|
|
private SolidColorBrush mInfoFormatBoxBrush = Brushes.Green;
|
|
|
|
|
|
|
|
|
|
public bool InfoFormatShowDashes {
|
|
|
|
|
get { return mInfoFormatShowDashes; }
|
|
|
|
|
set { mInfoFormatShowDashes = value; OnPropertyChanged(); }
|
|
|
|
|
}
|
|
|
|
|
private bool mInfoFormatShowDashes;
|
|
|
|
|
|
|
|
|
|
public bool InfoFormatShowSolid {
|
|
|
|
|
get { return mInfoFormatShowSolid; }
|
|
|
|
|
set { mInfoFormatShowSolid = value; OnPropertyChanged(); }
|
|
|
|
|
}
|
|
|
|
|
private bool mInfoFormatShowSolid;
|
|
|
|
|
|
|
|
|
|
public string InfoFormatText {
|
|
|
|
|
get { return mInfoFormatText; }
|
|
|
|
|
set { mInfoFormatText = value; OnPropertyChanged(); }
|
|
|
|
|
}
|
|
|
|
|
private string mInfoFormatText;
|
|
|
|
|
|
|
|
|
|
public string InfoPanelDetail1 {
|
|
|
|
|
get { return mInfoPanelDetail1; }
|
|
|
|
|
set { mInfoPanelDetail1 = value; OnPropertyChanged(); }
|
|
|
|
|
}
|
|
|
|
|
private string mInfoPanelDetail1;
|
|
|
|
|
|
2019-10-30 21:30:03 +00:00
|
|
|
|
public bool InfoShowDebug {
|
|
|
|
|
get {
|
|
|
|
|
#if DEBUG
|
|
|
|
|
return true;
|
|
|
|
|
#else
|
|
|
|
|
return false;
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2019-10-23 04:27:49 +00:00
|
|
|
|
//public string InfoPanelMonoContents {
|
|
|
|
|
// get { return mInfoPanelMonoContents; }
|
|
|
|
|
// set { mInfoPanelMonoContents = value; OnPropertyChanged(); }
|
|
|
|
|
//}
|
|
|
|
|
//private string mInfoPanelMonoContents;
|
|
|
|
|
|
|
|
|
|
|
Label rework, part 6
Correct handling of local variables. We now correctly uniquify them
with regard to non-unique labels. Because local vars can effectively
have global scope we mostly want to treat them as global, but they're
uniquified relative to other globals very late in the process, so we
can't just throw them in the symbol table and be done. Fortunately
local variables exist in a separate namespace, so we just need to
uniquify the variables relative to the post-localization symbol table.
In other words, we take the symbol table, apply the label map, and
rename any variable that clashes.
This also fixes an older problem where we weren't masking the
leading '_' on variable labels when generating 64tass output.
The code list now makes non-unique labels obvious, but you can't tell
the difference between unique global and unique local. What's more,
the default type value in Edit Label is now adjusted to Global for
unique locals that were auto-generated. To make it a bit easier to
figure out what's what, the Info panel now has a "label type" line
that reports the type.
The 2023-non-unique-labels test had some additional tests added to
exercise conflicts with local variables. The 2019-local-variables
test output changed slightly because the de-duplicated variable
naming convention was simplified.
2019-11-18 21:26:03 +00:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Clears the contents of the info panel. Call this whenever the contents have
|
|
|
|
|
/// been updated.
|
|
|
|
|
/// </summary>
|
2019-10-23 04:27:49 +00:00
|
|
|
|
public void ClearInfoPanel() {
|
Label rework, part 6
Correct handling of local variables. We now correctly uniquify them
with regard to non-unique labels. Because local vars can effectively
have global scope we mostly want to treat them as global, but they're
uniquified relative to other globals very late in the process, so we
can't just throw them in the symbol table and be done. Fortunately
local variables exist in a separate namespace, so we just need to
uniquify the variables relative to the post-localization symbol table.
In other words, we take the symbol table, apply the label map, and
rename any variable that clashes.
This also fixes an older problem where we weren't masking the
leading '_' on variable labels when generating 64tass output.
The code list now makes non-unique labels obvious, but you can't tell
the difference between unique global and unique local. What's more,
the default type value in Edit Label is now adjusted to Global for
unique locals that were auto-generated. To make it a bit easier to
figure out what's what, the Info panel now has a "label type" line
that reports the type.
The 2023-non-unique-labels test had some additional tests added to
exercise conflicts with local variables. The 2019-local-variables
test output changed slightly because the de-duplicated variable
naming convention was simplified.
2019-11-18 21:26:03 +00:00
|
|
|
|
InfoLineDescrText = InfoOffsetText = InfoLabelDescrText = InfoFormatText =
|
|
|
|
|
InfoPanelDetail1 = string.Empty;
|
2019-10-23 04:27:49 +00:00
|
|
|
|
InfoFormatShowDashes = InfoFormatShowSolid = false;
|
2019-06-12 21:17:24 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#endregion Info panel
|
2019-10-20 21:40:32 +00:00
|
|
|
|
|
|
|
|
|
#region Message list panel
|
|
|
|
|
|
|
|
|
|
public class MessageListItem {
|
|
|
|
|
public string Severity { get; private set; }
|
|
|
|
|
public string Offset { get; private set; }
|
|
|
|
|
public string Type { get; private set; }
|
|
|
|
|
public string Context { get; private set; }
|
|
|
|
|
public string Resolution { get; private set; }
|
|
|
|
|
|
2019-10-21 01:02:23 +00:00
|
|
|
|
public int OffsetValue { get; private set; }
|
|
|
|
|
|
|
|
|
|
public MessageListItem(string severity, int offsetValue, string offset, string type,
|
|
|
|
|
string context, string resolution) {
|
2019-10-20 21:40:32 +00:00
|
|
|
|
Severity = severity;
|
2019-10-21 01:02:23 +00:00
|
|
|
|
OffsetValue = offsetValue;
|
2019-10-20 21:40:32 +00:00
|
|
|
|
Offset = offset;
|
|
|
|
|
Type = type;
|
|
|
|
|
Context = context;
|
|
|
|
|
Resolution = resolution;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2019-10-21 01:02:23 +00:00
|
|
|
|
public Visibility MessageListVisibility {
|
|
|
|
|
get {
|
|
|
|
|
bool visible = !HideMessageList && FormattedMessages.Count > 0;
|
|
|
|
|
return visible ? Visibility.Visible : Visibility.Collapsed;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private bool HideMessageList {
|
|
|
|
|
get { return AppSettings.Global.GetBool(AppSettings.MAIN_HIDE_MESSAGE_WINDOW, false); }
|
|
|
|
|
set {
|
|
|
|
|
AppSettings.Global.SetBool(AppSettings.MAIN_HIDE_MESSAGE_WINDOW, value);
|
|
|
|
|
OnPropertyChanged("MessageListVisibility");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private string mMessageStatusText;
|
|
|
|
|
public string MessageStatusText {
|
|
|
|
|
get { return mMessageStatusText; }
|
|
|
|
|
set { mMessageStatusText = value; OnPropertyChanged(); }
|
|
|
|
|
}
|
|
|
|
|
|
2019-10-20 21:40:32 +00:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// ItemsSource for DataGrid.
|
|
|
|
|
/// </summary>
|
|
|
|
|
public ObservableCollection<MessageListItem> FormattedMessages { get; private set; } =
|
|
|
|
|
new ObservableCollection<MessageListItem>();
|
|
|
|
|
|
2019-10-21 01:02:23 +00:00
|
|
|
|
private void MessageStatusButton_Click(object sender, RoutedEventArgs e) {
|
|
|
|
|
HideMessageList = false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private void HideMessageList_Click(object sender, RoutedEventArgs e) {
|
|
|
|
|
HideMessageList = true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private void MessageGrid_MouseDoubleClick(object sender, MouseButtonEventArgs e) {
|
|
|
|
|
if (!messageGrid.GetClickRowColItem(e, out int unusedRow, out int unusedCol,
|
|
|
|
|
out object item)) {
|
|
|
|
|
// Header or empty area; ignore.
|
|
|
|
|
return;
|
2019-10-20 21:40:32 +00:00
|
|
|
|
}
|
2019-10-21 01:02:23 +00:00
|
|
|
|
MessageListItem mli = (MessageListItem)item;
|
2019-10-20 21:40:32 +00:00
|
|
|
|
|
2019-10-21 01:02:23 +00:00
|
|
|
|
// Jump to the offset, then shift the focus back to the code list.
|
2021-10-07 19:39:08 +00:00
|
|
|
|
mMainCtrl.GoToLocation(new NavStack.Location(mli.OffsetValue, 0,
|
|
|
|
|
NavStack.GoToMode.JumpToCodeData), true);
|
2021-10-25 22:45:42 +00:00
|
|
|
|
//codeListView.Focus();
|
2019-10-20 21:40:32 +00:00
|
|
|
|
}
|
|
|
|
|
|
2019-10-21 01:02:23 +00:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Regenerates the contents of the message list.
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <param name="list">Message list.</param>
|
|
|
|
|
/// <param name="formatter">Format object.</param>
|
|
|
|
|
public void UpdateMessageList(MessageList list, Asm65.Formatter formatter) {
|
|
|
|
|
FormattedMessages.Clear();
|
|
|
|
|
list.Sort();
|
|
|
|
|
|
|
|
|
|
int warnErrCount = 0;
|
|
|
|
|
foreach (MessageList.MessageEntry entry in list) {
|
|
|
|
|
FormattedMessages.Add(MessageList.FormatMessage(entry, formatter));
|
|
|
|
|
if (entry.Severity != MessageList.MessageEntry.SeverityLevel.Info) {
|
|
|
|
|
warnErrCount++;
|
|
|
|
|
}
|
2019-10-20 21:40:32 +00:00
|
|
|
|
}
|
2019-10-21 01:02:23 +00:00
|
|
|
|
|
|
|
|
|
if (warnErrCount == 0) {
|
|
|
|
|
if (FormattedMessages.Count == 1) {
|
|
|
|
|
string fmt = (string)FindResource("str_MessageSingularFmt");
|
|
|
|
|
MessageStatusText = string.Format(fmt, FormattedMessages.Count);
|
|
|
|
|
} else {
|
|
|
|
|
string fmt = (string)FindResource("str_MessagePluralFmt");
|
|
|
|
|
MessageStatusText = string.Format(fmt, FormattedMessages.Count);
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
if (FormattedMessages.Count == 1) {
|
|
|
|
|
string fmt = (string)FindResource("str_MessageSingularWarningFmt");
|
|
|
|
|
MessageStatusText = string.Format(fmt, FormattedMessages.Count, warnErrCount);
|
|
|
|
|
} else {
|
|
|
|
|
string fmt = (string)FindResource("str_MessagePluralWarningFmt");
|
|
|
|
|
MessageStatusText = string.Format(fmt, FormattedMessages.Count, warnErrCount);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
OnPropertyChanged("MessageListVisibility");
|
2019-10-20 21:40:32 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#endregion Message list panel
|
2021-10-15 22:36:56 +00:00
|
|
|
|
|
|
|
|
|
#region Daily tips
|
|
|
|
|
|
|
|
|
|
private int mDailyTipCurrent = 0;
|
|
|
|
|
private int mDailyTipMax = 0;
|
|
|
|
|
|
|
|
|
|
public Visibility DailyTipVisibility {
|
|
|
|
|
get { return mDailyTipVisibility; }
|
|
|
|
|
set { mDailyTipVisibility = value; OnPropertyChanged(); }
|
|
|
|
|
}
|
|
|
|
|
private Visibility mDailyTipVisibility = Visibility.Collapsed;
|
|
|
|
|
|
|
|
|
|
public string DailyTipText {
|
|
|
|
|
get {
|
|
|
|
|
if (mDailyTipText == null) {
|
|
|
|
|
return Res.Strings.TIPS_LOADING;
|
|
|
|
|
}
|
|
|
|
|
return mDailyTipText;
|
|
|
|
|
}
|
|
|
|
|
set { mDailyTipText = value; OnPropertyChanged(); }
|
|
|
|
|
}
|
|
|
|
|
private string mDailyTipText;
|
|
|
|
|
|
|
|
|
|
public BitmapSource DailyTipImage {
|
|
|
|
|
get { return mDailyTipImage; }
|
|
|
|
|
set { mDailyTipImage = value; OnPropertyChanged(); }
|
|
|
|
|
}
|
|
|
|
|
private BitmapSource mDailyTipImage;
|
|
|
|
|
|
|
|
|
|
public bool IsEnabledDailyTipPrev {
|
|
|
|
|
get { return mIsEnabledDailyTipPrev; }
|
|
|
|
|
set { mIsEnabledDailyTipPrev = value; OnPropertyChanged(); }
|
|
|
|
|
}
|
|
|
|
|
private bool mIsEnabledDailyTipPrev;
|
|
|
|
|
|
|
|
|
|
public bool IsEnabledDailyTipNext {
|
|
|
|
|
get { return mIsEnabledDailyTipNext; }
|
|
|
|
|
set { mIsEnabledDailyTipNext = value; OnPropertyChanged(); }
|
|
|
|
|
}
|
|
|
|
|
private bool mIsEnabledDailyTipNext;
|
|
|
|
|
|
|
|
|
|
public string DailyTipPosStr {
|
|
|
|
|
get { return mDailyTipPosStr; }
|
|
|
|
|
set { mDailyTipPosStr = value; OnPropertyChanged(); }
|
|
|
|
|
}
|
|
|
|
|
private string mDailyTipPosStr;
|
|
|
|
|
|
|
|
|
|
private void DailyTipPrevious_Click(object sender, RoutedEventArgs e) {
|
|
|
|
|
if (mDailyTipCurrent > 0) {
|
|
|
|
|
mDailyTipCurrent--;
|
|
|
|
|
UpdateDailyTip();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
private void DailyTipNext_Click(object sender, RoutedEventArgs e) {
|
|
|
|
|
if (mDailyTipCurrent < mDailyTipMax - 1) {
|
|
|
|
|
mDailyTipCurrent++;
|
|
|
|
|
UpdateDailyTip();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public void InitDailyTip() {
|
|
|
|
|
mDailyTips = new DailyTips();
|
|
|
|
|
if (mDailyTips.Load()) {
|
|
|
|
|
DailyTipVisibility = Visibility.Visible;
|
|
|
|
|
}
|
|
|
|
|
mDailyTipCurrent = mDailyTips.DailyNumber;
|
|
|
|
|
mDailyTipMax = mDailyTips.Count;
|
|
|
|
|
UpdateDailyTip();
|
|
|
|
|
}
|
|
|
|
|
private void UpdateDailyTip() {
|
|
|
|
|
DailyTips.Tip tip = mDailyTips.Get(mDailyTipCurrent);
|
|
|
|
|
DailyTipText = tip.Text;
|
|
|
|
|
DailyTipImage = tip.Bitmap;
|
|
|
|
|
|
|
|
|
|
IsEnabledDailyTipPrev = (mDailyTipCurrent > 0);
|
|
|
|
|
IsEnabledDailyTipNext = (mDailyTipCurrent < mDailyTipMax - 1);
|
|
|
|
|
DailyTipPosStr = string.Format("{0}/{1}", mDailyTipCurrent + 1, mDailyTipMax);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#endregion Daily tips
|
|
|
|
|
|
2019-04-29 23:34:09 +00:00
|
|
|
|
}
|
|
|
|
|
}
|