mirror of
https://github.com/gui-cs/Terminal.Gui.git
synced 2025-12-31 02:08:03 +01:00
416 lines
9.5 KiB
C#
416 lines
9.5 KiB
C#
using System;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using Terminal.Gui;
|
|
|
|
namespace UICatalog.Scenarios {
|
|
|
|
[ScenarioMetadata (Name: "Notepad", Description: "Multi-tab text editor using the TabView control.")]
|
|
[ScenarioCategory ("Controls"), ScenarioCategory ("TabView"), ScenarioCategory("TextView")]
|
|
public class Notepad : Scenario {
|
|
TabView tabView;
|
|
|
|
private int numbeOfNewTabs = 1;
|
|
private TabView focusedTabView;
|
|
private StatusItem lenStatusItem;
|
|
|
|
// Don't create a Window, just return the top-level view
|
|
public override void Init ()
|
|
{
|
|
Application.Init ();
|
|
Application.Top.ColorScheme = Colors.Base;
|
|
}
|
|
|
|
public override void Setup ()
|
|
{
|
|
var menu = new MenuBar (new MenuBarItem [] {
|
|
new MenuBarItem ("_File", new MenuItem [] {
|
|
new MenuItem ("_New", "", () => New()),
|
|
new MenuItem ("_Open", "", () => Open()),
|
|
new MenuItem ("_Save", "", () => Save()),
|
|
new MenuItem ("Save _As", "", () => SaveAs()),
|
|
new MenuItem ("_Close", "", () => Close()),
|
|
new MenuItem ("_Quit", "", () => Quit()),
|
|
})
|
|
});
|
|
Application.Top.Add (menu);
|
|
|
|
tabView = CreateNewTabView ();
|
|
|
|
tabView.Style.ShowBorder = true;
|
|
tabView.ApplyStyleChanges ();
|
|
|
|
// Start with only a single view but support splitting to show side by side
|
|
var split = new TileView(1) {
|
|
X = 0,
|
|
Y = 1,
|
|
Width = Dim.Fill (),
|
|
Height = Dim.Fill (1),
|
|
};
|
|
split.Tiles.ElementAt(0).ContentView.Add (tabView);
|
|
split.LineStyle = LineStyle.None;
|
|
|
|
Application.Top.Add (split);
|
|
|
|
lenStatusItem = new StatusItem (Key.CharMask, "Len: ", null);
|
|
var statusBar = new StatusBar (new StatusItem [] {
|
|
new StatusItem(Application.QuitKey, $"{Application.QuitKey} to Quit", () => Quit()),
|
|
|
|
// These shortcut keys don't seem to work correctly in linux
|
|
//new StatusItem(Key.CtrlMask | Key.N, "~^O~ Open", () => Open()),
|
|
//new StatusItem(Key.CtrlMask | Key.N, "~^N~ New", () => New()),
|
|
|
|
new StatusItem(Key.CtrlMask | Key.S, "~^S~ Save", () => Save()),
|
|
new StatusItem(Key.CtrlMask | Key.W, "~^W~ Close", () => Close()),
|
|
lenStatusItem,
|
|
});
|
|
focusedTabView = tabView;
|
|
tabView.SelectedTabChanged += TabView_SelectedTabChanged;
|
|
tabView.Enter += (s, e) => focusedTabView = tabView;
|
|
|
|
Application.Top.Add (statusBar);
|
|
|
|
New ();
|
|
}
|
|
|
|
private void TabView_SelectedTabChanged (object sender, TabChangedEventArgs e)
|
|
{
|
|
lenStatusItem.Title = $"Len:{e.NewTab?.View?.Text?.Length ?? 0}";
|
|
}
|
|
|
|
private void TabView_TabClicked (object sender, TabMouseEventArgs e)
|
|
{
|
|
// we are only interested in right clicks
|
|
if(!e.MouseEvent.Flags.HasFlag(MouseFlags.Button3Clicked)) {
|
|
return;
|
|
}
|
|
|
|
MenuBarItem items;
|
|
|
|
if (e.Tab == null) {
|
|
items = new MenuBarItem (new MenuItem [] {
|
|
new MenuItem ($"Open", "", () => Open()),
|
|
});
|
|
|
|
} else {
|
|
|
|
var tv = (TabView)sender;
|
|
var t = (OpenedFile)e.Tab;
|
|
|
|
items = new MenuBarItem (new MenuItem [] {
|
|
new MenuItem ($"Save", "", () => Save(focusedTabView, e.Tab)),
|
|
new MenuItem ($"Close", "", () => Close(tv, e.Tab)),
|
|
null,
|
|
new MenuItem ($"Split Up", "", () => SplitUp(tv,t)),
|
|
new MenuItem ($"Split Down", "", () => SplitDown(tv,t)),
|
|
new MenuItem ($"Split Right", "", () => SplitRight(tv,t)),
|
|
new MenuItem ($"Split Left", "", () => SplitLeft(tv,t)),
|
|
});
|
|
}
|
|
|
|
((View)sender).ViewToScreen (e.MouseEvent.X, e.MouseEvent.Y, out int screenX, out int screenY,true);
|
|
|
|
var contextMenu = new ContextMenu (screenX,screenY, items);
|
|
|
|
contextMenu.Show ();
|
|
e.MouseEvent.Handled = true;
|
|
}
|
|
|
|
private void SplitUp (TabView sender, OpenedFile tab)
|
|
{
|
|
Split(0, Orientation.Horizontal,sender,tab);
|
|
}
|
|
private void SplitDown (TabView sender, OpenedFile tab)
|
|
{
|
|
Split(1, Orientation.Horizontal,sender,tab);
|
|
|
|
}
|
|
private void SplitLeft (TabView sender, OpenedFile tab)
|
|
{
|
|
Split(0, Orientation.Vertical,sender,tab);
|
|
}
|
|
private void SplitRight (TabView sender, OpenedFile tab)
|
|
{
|
|
Split(1, Orientation.Vertical,sender,tab);
|
|
}
|
|
|
|
private void Split (int offset, Orientation orientation,TabView sender, OpenedFile tab)
|
|
{
|
|
|
|
var split = (TileView)sender.SuperView.SuperView;
|
|
var tileIndex = split.IndexOf(sender);
|
|
|
|
if(tileIndex == -1)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if(orientation != split.Orientation)
|
|
{
|
|
split.TrySplitTile(tileIndex,1,out split);
|
|
split.Orientation = orientation;
|
|
tileIndex = 0;
|
|
}
|
|
|
|
var newTile = split.InsertTile(tileIndex + offset);
|
|
var newTabView = CreateNewTabView ();
|
|
tab.CloneTo (newTabView);
|
|
newTile.ContentView.Add(newTabView);
|
|
|
|
newTabView.EnsureFocus();
|
|
newTabView.FocusFirst();
|
|
newTabView.FocusNext();
|
|
}
|
|
|
|
private TabView CreateNewTabView ()
|
|
{
|
|
var tv = new TabView () {
|
|
X = 0,
|
|
Y = 0,
|
|
Width = Dim.Fill (),
|
|
Height = Dim.Fill (),
|
|
};
|
|
|
|
tv.TabClicked += TabView_TabClicked;
|
|
tv.SelectedTabChanged += TabView_SelectedTabChanged;
|
|
tv.Enter += (s, e) => focusedTabView = tv;
|
|
return tv;
|
|
}
|
|
|
|
private void New ()
|
|
{
|
|
Open (null, $"new {numbeOfNewTabs++}");
|
|
}
|
|
|
|
private void Close ()
|
|
{
|
|
Close (focusedTabView, focusedTabView.SelectedTab);
|
|
}
|
|
private void Close (TabView tv, Tab tabToClose)
|
|
{
|
|
var tab = tabToClose as OpenedFile;
|
|
|
|
if (tab == null) {
|
|
return;
|
|
}
|
|
|
|
focusedTabView = tv;
|
|
|
|
if (tab.UnsavedChanges) {
|
|
|
|
int result = MessageBox.Query ("Save Changes", $"Save changes to {tab.Text.TrimEnd ('*')}", "Yes", "No", "Cancel");
|
|
|
|
if (result == -1 || result == 2) {
|
|
|
|
// user cancelled
|
|
return;
|
|
}
|
|
|
|
if (result == 0) {
|
|
if(tab.File == null) {
|
|
SaveAs ();
|
|
} else {
|
|
tab.Save ();
|
|
}
|
|
}
|
|
}
|
|
|
|
// close and dispose the tab
|
|
tv.RemoveTab (tab);
|
|
tab.View.Dispose ();
|
|
focusedTabView = tv;
|
|
|
|
if(tv.Tabs.Count == 0) {
|
|
|
|
var split = (TileView)tv.SuperView.SuperView;
|
|
|
|
// if it is the last TabView on screen don't drop it or we will
|
|
// be unable to open new docs!
|
|
if(split.IsRootTileView() && split.Tiles.Count == 1) {
|
|
return;
|
|
}
|
|
|
|
var tileIndex = split.IndexOf (tv);
|
|
split.RemoveTile (tileIndex);
|
|
|
|
if(split.Tiles.Count == 0) {
|
|
var parent = split.GetParentTileView ();
|
|
|
|
if (parent == null) {
|
|
return;
|
|
}
|
|
|
|
var idx = parent.IndexOf (split);
|
|
|
|
if (idx == -1) {
|
|
return;
|
|
}
|
|
|
|
parent.RemoveTile (idx);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void Open ()
|
|
{
|
|
var open = new OpenDialog ("Open") { AllowsMultipleSelection = true };
|
|
|
|
Application.Run (open);
|
|
|
|
if (!open.Canceled) {
|
|
|
|
foreach (var path in open.FilePaths) {
|
|
|
|
if (string.IsNullOrEmpty (path) || !File.Exists (path)) {
|
|
return;
|
|
}
|
|
|
|
// TODO should open in focused TabView
|
|
Open (new FileInfo (path), Path.GetFileName (path));
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Creates a new tab with initial text
|
|
/// </summary>
|
|
/// <param name="fileInfo">File that was read or null if a new blank document</param>
|
|
private void Open (FileInfo fileInfo, string tabName)
|
|
{
|
|
var tab = new OpenedFile (focusedTabView, tabName, fileInfo);
|
|
focusedTabView.AddTab (tab, true);
|
|
}
|
|
|
|
public void Save ()
|
|
{
|
|
Save (focusedTabView, focusedTabView.SelectedTab);
|
|
}
|
|
public void Save (TabView tabViewToSave, Tab tabToSave)
|
|
{
|
|
var tab = tabToSave as OpenedFile;
|
|
|
|
if (tab == null) {
|
|
return;
|
|
}
|
|
|
|
if (tab.File == null) {
|
|
SaveAs ();
|
|
}
|
|
|
|
tab.Save ();
|
|
tabViewToSave.SetNeedsDisplay ();
|
|
}
|
|
|
|
public bool SaveAs ()
|
|
{
|
|
var tab = focusedTabView.SelectedTab as OpenedFile;
|
|
|
|
if (tab == null) {
|
|
return false;
|
|
}
|
|
|
|
var fd = new SaveDialog ();
|
|
Application.Run (fd);
|
|
|
|
if (string.IsNullOrWhiteSpace (fd.Path)) {
|
|
return false;
|
|
}
|
|
|
|
if(fd.Canceled) {
|
|
return false;
|
|
}
|
|
|
|
tab.File = new FileInfo (fd.Path);
|
|
tab.Text = fd.FileName;
|
|
tab.Save ();
|
|
|
|
return true;
|
|
}
|
|
|
|
private class OpenedFile : Tab {
|
|
public FileInfo File { get; set; }
|
|
|
|
/// <summary>
|
|
/// The text of the tab the last time it was saved
|
|
/// </summary>
|
|
/// <value></value>
|
|
public string SavedText { get; set; }
|
|
|
|
public bool UnsavedChanges => !string.Equals (SavedText, View.Text);
|
|
|
|
public OpenedFile (TabView parent, string name, FileInfo file)
|
|
: base (name, CreateTextView(file))
|
|
{
|
|
|
|
File = file;
|
|
SavedText = View.Text;
|
|
RegisterTextViewEvents (parent);
|
|
}
|
|
|
|
private void RegisterTextViewEvents (TabView parent)
|
|
{
|
|
var textView = (TextView)View;
|
|
// when user makes changes rename tab to indicate unsaved
|
|
textView.KeyUp += (s, k) => {
|
|
|
|
// if current text doesn't match saved text
|
|
var areDiff = this.UnsavedChanges;
|
|
|
|
if (areDiff) {
|
|
if (!this.Text.EndsWith ('*')) {
|
|
|
|
this.Text = this.Text + '*';
|
|
parent.SetNeedsDisplay ();
|
|
}
|
|
} else {
|
|
|
|
if (Text.EndsWith ('*')) {
|
|
|
|
Text = Text.TrimEnd ('*');
|
|
parent.SetNeedsDisplay ();
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
private static View CreateTextView (FileInfo file)
|
|
{
|
|
string initialText = string.Empty;
|
|
if(file != null && file.Exists) {
|
|
|
|
initialText = System.IO.File.ReadAllText (file.FullName);
|
|
}
|
|
|
|
return new TextView () {
|
|
X = 0,
|
|
Y = 0,
|
|
Width = Dim.Fill (),
|
|
Height = Dim.Fill (),
|
|
Text = initialText,
|
|
AllowsTab = false,
|
|
};
|
|
}
|
|
public OpenedFile CloneTo(TabView other)
|
|
{
|
|
var newTab = new OpenedFile (other, base.Text.ToString(), File);
|
|
other.AddTab (newTab, true);
|
|
return newTab;
|
|
}
|
|
internal void Save ()
|
|
{
|
|
var newText = View.Text;
|
|
|
|
System.IO.File.WriteAllText (File.FullName, newText);
|
|
SavedText = newText;
|
|
|
|
Text = Text.TrimEnd ('*');
|
|
}
|
|
}
|
|
|
|
private void Quit ()
|
|
{
|
|
Application.RequestStop ();
|
|
}
|
|
}
|
|
}
|