Grammar Composition System

/src/branch/20110407-thread-priority/agree-wpf/command.cs

using System;
using System.IO;
using System.Windows;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Diagnostics;
using System.Globalization;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;

using ActiproSoftware.Windows.Controls.Docking;
using ActiproSoftware.Windows.Controls.Ribbon.Input;

using agree;
using SysType = System.Type;

namespace WpfClient
{

	abstract public class CommandBase : RoutedUICommand
	{
		protected MainWindow w;
		public CommandBase(MainWindow w, String text, String name, SysType t)
			: base(text, name, t)
		{
			this.w = w;
			Debug.Assert(t == this.GetType());
		}
		CommandBinding _b = null;
		public CommandBinding CommandBinding
		{
			get { return _b = (_b ?? new CommandBinding(this, OnExecute, OnCanExecute)); }
		}

		protected abstract void OnExecute(object target, ExecutedRoutedEventArgs args);
		protected virtual void OnCanExecute(object target, CanExecuteRoutedEventArgs args)
		{
			args.Handled = true;
			args.CanExecute = true;
		}
	};


	public class ShowCommand : CommandBase
	{
		public ShowCommand(MainWindow w)
			: base(w, "Show", "Show", typeof(ShowCommand))
		{
		}

		protected override void OnExecute(object target, ExecutedRoutedEventArgs args)
		{
			args.Handled = true;
		}

#if false
		private void CanExecute(object target, CanExecuteRoutedEventArgs args)
		{
			args.Handled = true;
			args.CanExecute = true;
		}
#endif
	};


	public class ShowItemCommand : CommandBase
	{
		public ShowItemCommand(MainWindow w)
			: base(w, "Show Item", "ShowItem", typeof(ShowItemCommand))
		{
		}

		public static void BetterExecute(Object parent, Object arg)
		{
			MyDockSite mds = MyDockSite.g_docksite;
			if (arg is Instance)
			{
				Instance inst = arg as Instance;

				ExpandedWindow etw = mds.DocumentWindows.OfType<ExpandedWindow>().FirstOrDefault(d => d.Inst == inst);
				if (etw == null)
				{
					etw = new ExpandedWindow(inst);
					mds.wksp.tmc.Items.Add(etw);
				}
				//etw.Open();
				//wksp.tmc.SelectedItem = etw;
				etw.Activate();
			}
			else if (arg is TfsEdge)
			{
				TfsEdge tfs = (TfsEdge)arg;

				var etw = new ExpandedWindow(tfs);
				mds.wksp.tmc.Items.Add(etw);
				etw.Activate();
			}
			else if (arg is ParseChart)
			{
				ParseChart pc = arg as ParseChart;
				AgreeGrammarDocument etw = mds.DocumentWindows.OfType<ParseChartWindow>().FirstOrDefault(d => d.ParseChart == pc);
				if (etw == null)
				{
					etw = new ParseChartWindow(pc,null);
			//		etw = new MultiParseTreeWindow(pc);
					mds.wksp.tmc.Items.Add(etw);
				}
				etw.Activate();
			}
			else if (arg is ParseChart.CompletedParse)
			{
				ParseChart pc = parent as ParseChart;
				ParseChart.CompletedParse cp = arg as ParseChart.CompletedParse;
				ParseTreeWindow etw = mds.DocumentWindows.OfType<ParseTreeWindow>().FirstOrDefault(d => d.ParseTree == cp);
				if (etw == null)
				{
					etw = new ParseTreeWindow(pc, cp);
					mds.wksp.tmc.Items.Add(etw);
				}
				etw.Activate();
			}
		}

		protected override void OnExecute(object target, ExecutedRoutedEventArgs args)
		{
			BetterExecute(target, args.Parameter);
			args.Handled = true;
		}

#if false
		private void CanExecute(object target, CanExecuteRoutedEventArgs args)
		{
			args.Handled = true;
			args.CanExecute = true;
		}
#endif
	};


	public class ShowHighlightedItemCommand : CommandBase
	{
		ISysObj o1;
		ISysObj o_hl;
		public ShowHighlightedItemCommand(MainWindow w, ISysObj o1, ISysObj o_hl)
			: base(w, "Show Highlighted Item", "ShowHighlightedItem", typeof(ShowHighlightedItemCommand))
		{
			this.o1 = o1;
			this.o_hl = o_hl;
		}

		protected override void OnExecute(object target, ExecutedRoutedEventArgs args)
		{
			MyDockSite mds = MyDockSite.g_docksite;
			var etw = new ExpandedWindow((TfsEdge)o1, (TfsEdge)o_hl);
			mds.wksp.tmc.Items.Add(etw);
			etw.Activate();

			args.Handled = true;
		}

#if false
		private void CanExecute(object target, CanExecuteRoutedEventArgs args)
		{
			args.Handled = true;
			args.CanExecute = true;
		}
#endif
	};

#if false
	public class OpenEdgeWindow : CommandBase
	{
		public OpenEdgeWindow(MainWindow w)
			: base(w, "Show Edge Type", "ShowEdgeType", typeof(OpenEdgeWindow))
		{
		}

		public class CommandArgs
		{
			public TfsEdge e;
			public String title;
		}

		protected override void OnExecute(object target, ExecutedRoutedEventArgs args)
		{
			CommandArgs ca = args.Parameter as CommandArgs;
			if (ca != null)
			{
				MyDockSite mds = MyDockSite.g_docksite;
				EdgeWindow etw = mds.DocumentWindows.OfType<EdgeWindow>().FirstOrDefault(d => d.Edge == ca.e);
				if (etw == null)
				{
					etw = new EdgeWindow(ca.e, ca.title);
					mds.wksp.tmc.Items.Add(etw);
				}
				//etw.Open();
				//wksp.tmc.SelectedItem = etw;
				etw.Activate();

			}
			args.Handled = true;
		}

#if false
		private void CanExecute(object target, CanExecuteRoutedEventArgs args)
		{
			args.Handled = true;
			args.CanExecute = true;
		}
#endif
	};
#endif


	public class Open3dWindow : CommandBase
	{
		public Open3dWindow(MainWindow w)
			: base(w, "Show 3d Window", "Show3dWindow", typeof(Open3dWindow))
		{
		}

		protected override void OnExecute(object target, ExecutedRoutedEventArgs args)
		{
			agree.Type t = args.Parameter as agree.Type;
			if (t != null)
			{
				MyDockSite mds = MyDockSite.g_docksite;
				T3dWindow etw = mds.DocumentWindows.OfType<T3dWindow>().FirstOrDefault(d => d.Type == t);
				if (etw == null)
				{
					etw = new T3dWindow(t);
					mds.wksp.tmc.Items.Add(etw);
				}
				//etw.Open();
				//wksp.tmc.SelectedItem = etw;
				etw.Activate();

			}
			args.Handled = true;
		}

#if false
		private void CanExecute(object target, CanExecuteRoutedEventArgs args)
		{
			args.Handled = true;
			args.CanExecute = true;
		}
#endif
	};



}