You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

1716 lines
56 KiB
C#

1 year ago
using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System.Windows.Forms;
using System.Drawing;
using System.Xml;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.IO;
using ICSharpCode.Core;
using Mesnac.Gui.Workbench;
using Mesnac.Controls.Default;
using Mesnac.Gui.Common;
using Mesnac.Gui.Edit.Global;
using Mesnac.Gui.Edit.Common;
using Mesnac.Gui.Edit.Dialog;
using Mesnac.Gui.Edit.Pad;
using Mesnac.Gui.Edit.ViewContent;
using Mesnac.Core.Service;
using Mesnac.Basic;
using Host;
using System.Reflection;
namespace Mesnac.Gui.Edit.ViewContent
{
#region 显示辅助类
/// <summary>
/// 显示辅助类,保存通用方法和变量
/// </summary>
/// <typeparam name="T"></typeparam>
public class DisplayUtil<T>
{
#region 面板处理辅助方法
/// <summary>
/// 获取面板实例
/// </summary>
public static T PadInstance
{
get{
Mesnac.PlugIn.Pad.PadDescriptor pd = WorkbenchSingleton.Workbench.GetPad(typeof(T));
object pad = pd == null ? null : pd.PadContent;
return (T)pad;
}
}
#endregion
#region 工程处理辅助方法
/// <summary>
/// 清除工程
/// </summary>
public static void ClearProject()
{
//清除仿真画面
Mesnac.Gui.Common.RunEngine.Instance.CloseAllForms();
ProjectWindow projectWindow = DisplayUtil<ProjectWindow>.PadInstance;
PropertyWindow propertyWindow = DisplayUtil<PropertyWindow>.PadInstance;
ActionWindow actionWindow = DisplayUtil<ActionWindow>.PadInstance;
EventWindow eventWindow = DisplayUtil<EventWindow>.PadInstance;
//保存工程处理
if (projectWindow != null && projectWindow.Tree != null && projectWindow.Tree.Nodes.Count > 0)
{
string msgContent = StringParser.Parse(ResourceService.GetString("Mesnac_Dialog_CloseProject")); //正在关闭工程{0},需要保存吗?
string caption = StringParser.Parse(ResourceService.GetString("Mesnac_Dialog_Caption"));
msgContent = String.Format(msgContent, projectWindow.Tree.Nodes[0].Text);
DialogResult result = MessageBox.Show(msgContent, caption, MessageBoxButtons.YesNo, MessageBoxIcon.Question);
if (result == DialogResult.Yes)
{
new SaveProjectCommand().Run();
}
}
//0、清除事件属性
if (eventWindow != null)
{
eventWindow.PropertyGrid.SelectedObject = null;
eventWindow.CmbControls.Items.Clear();
}
//1、清除动画属性
if (actionWindow != null)
{
actionWindow.PropertyGrid.SelectedObject = null;
actionWindow.CmbControls.Items.Clear();
}
//2、清除属性窗口
if (propertyWindow != null)
{
propertyWindow.PropertyGrid.SelectedObject = null;
propertyWindow.CmbControls.Items.Clear();
}
//3、关闭所有打开的设计画面并清除画面集合
//foreach(Mesnac.PlugIn.View.IViewContent vc in WorkbenchSingleton.Workbench.ViewContentCollection)
//{
// vc.IsRealClose = true;
//}
WorkbenchSingleton.Workbench.CloseAllViews();
//4、清除工程树
if (projectWindow != null)
{
projectWindow.Tree.Nodes.Clear();
}
//5、清除设备集合
//6、清除工程路径
AppConfigHandler.Instance.FullFileName = String.Empty;
}
/// <summaryre
/// 创建form的名称根据类型决定
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
public static string CreateFormName(CreateType type)
{
int count = 1;
string text = String.Empty;
ProjectWindow projectWindow = null;
switch (type)
{
case CreateType.Form:
text = "Form" + count.ToString();
projectWindow = DisplayUtil<ProjectWindow>.PadInstance;
if (projectWindow != null)
{
TreeNode nodeForm = projectWindow.Tree.GetFirstNodeByNodeName(FixNodeName.NodeFormName);
bool flag = false;
while (!flag)
{
foreach (TreeNode node in nodeForm.Nodes)
{
if (node.Text == text)
{
flag = true;
}
}
if (flag)
{
count++;
text = "Form" + count.ToString();
flag = false;
}
else
{
flag = true;
}
}
}
return text;
case CreateType.Command:
text = "Command" + count.ToString();
projectWindow = DisplayUtil<ProjectWindow>.PadInstance;
TreeNode nodeAction = projectWindow.Tree.GetFirstNodeByNodeName(FixNodeName.NodeCommandName);
if (nodeAction != null)
{
bool flag = false;
while (!flag)
{
foreach (TreeNode node in nodeAction.Nodes)
{
if (node.Text == text)
{
flag = true;
}
}
if (flag)
{
count++;
text = "Command" + count.ToString();
flag = false;
}
else
{
flag = true;
}
}
}
return text;
default:
return "error";
}
}
/// <summary>
/// 保存节点对应的画面文件
/// </summary>
/// <param name="node"></param>
public static void SaveFormByNode(CreateType ct, TreeNode node)
{
switch (ct)
{
case CreateType.Form: //画面
FrmContainer fc = null;
Mesnac.PlugIn.View.IWorkbenchWindow win = WorkbenchSingleton.Workbench.GetViewByViewContentID(node.Name);
if (win != null)
{
fc = win.ViewContent as FrmContainer;
}
//FrmContainer fc = this._editFormList[node.Name];
if (fc != null)
{
string path = Path.Combine(Path.GetDirectoryName(AppConfigHandler.Instance.FullFileName), node.GetPathNoRoot()) + ".xml";
if (fc.Controls.Count > 0)
{
HostControl currentHostControl = fc.Controls[0] as HostControl;
if (currentHostControl != null)
{
Loader.MesnacHostLoader loder = currentHostControl.HostSurface.Loader as Loader.MesnacHostLoader;
if (loder.IsUnSave)
{
loder.PerformFlushWorker(PublicConfig.Instance.PropertyXmlDoc, PublicConfig.Instance.ActionXmlDoc, PublicConfig.Instance.EventXmlDoc);
if (!Directory.Exists(Path.GetDirectoryName(path)))
{
Directory.CreateDirectory(Path.GetDirectoryName(path));
}
//((Loader.BasicHostLoader)currentHostControl.HostSurface.Loader).Save(path);
((Loader.MesnacHostLoader)currentHostControl.HostSurface.Loader).Save(path, PublicConfig.Instance.PropertyXmlDoc, PublicConfig.Instance.ActionXmlDoc, PublicConfig.Instance.EventXmlDoc);
}
}
}
}
break;
case CreateType.Command:
string path1 = Path.Combine(Path.GetDirectoryName(AppConfigHandler.Instance.FullFileName), Mesnac.Basic.FixNodeName.NodeCommandName + ".xml");
if (!Directory.Exists(Path.GetDirectoryName(path1)))
{
Directory.CreateDirectory(Path.GetDirectoryName(path1));
}
if (!File.Exists(path1))
{
string xmlstr = "<Object type=\"ActionFrom\" name=\"Action\" > </Object>";
XmlDocument dom = new XmlDocument();
dom.LoadXml(xmlstr);
dom.Save(path1);
}
break;
case CreateType.Device: //设备
{
Mesnac.Equips.Factory.Instance.SaveConfig();
}
break;
}
}
/// <summary>
/// 获取工程数据源文件
/// </summary>
/// <returns></returns>
public static string GetProjectDataSourceFile()
{
string fileName = String.Empty;
ProjectWindow projectWindow = DisplayUtil<ProjectWindow>.PadInstance;
if (projectWindow != null)
{
TreeNode node = projectWindow.Tree.GetFirstNodeByNodeName(FixNodeName.NodeDataSourceName);
fileName = Path.Combine(Path.GetDirectoryName(AppConfigHandler.Instance.FullFileName), node.GetPathNoRoot()) + ".xml";
return fileName;
}
else
{
LoggingService<DisplayUtil<T>>.Debug("获取工程数据源文件失败,原因:工程面板未初始化!");
return String.Empty;
}
}
/// <summary>
/// 重置工程数据源工厂,从文件读取数据
/// </summary>
public static void ResetProjectDataSourceFactory(params CallBackDelegate[] callBack)
{
string fileName = GetProjectDataSourceFile();
if (!String.IsNullOrEmpty(fileName))
{
DataSourceFactory.Instance.RefreshDataFromFile(fileName, callBack);
}
}
/// <summary>
/// 保存工程数据源
/// </summary>
public static void SaveProjectDataSource(params CallBackDelegate[] callBack)
{
string fileName = GetProjectDataSourceFile();
if (!String.IsNullOrEmpty(fileName))
{
DataSourceFactory.Instance.RefreshDataToFile(fileName, callBack);
}
}
#endregion
#region 菜单处理辅助方法
/// <summary>
/// 执行编辑菜单命令函数
/// </summary>
/// <param name="cmd"></param>
public static void PerformAction(CommandID cmd)
{
if (MesnacServiceManager.Instance.HostSurfaceManager.ActiveDesignSurface == null)
{
LoggingService<DisplayUtil<T>>.Debug("当前画面实例为空!");
return;
}
//if (MesnacServiceManager.Instance.HostSurfaceManager.ActiveDesignSurface == null || this.dockPanelMain.ActiveDocument == null)
//{
// LoggingService<DisplayUtil<T>>.Warn("当前画面实例为空!");
// return;
//}
////判断是否有激活的画面设计器
//if (!this.dockPanelMain.ActiveDocument.DockHandler.IsActivated || !(this.dockPanelMain.ActiveDocument.DockHandler.Form is FrmContainer))
//{
// LoggingService<DisplayUtil<T>>.Warn("没有活动画面!");
// return;
//}
IMenuCommandService ims = MesnacServiceManager.Instance.HostSurfaceManager.ActiveDesignSurface.GetService(typeof(IMenuCommandService)) as IMenuCommandService;
try
{
ims.GlobalInvoke(cmd);
}
catch (Exception ex)
{
LoggingService<DisplayUtil<T>>.Error(ex.Message + "\r\n" + ex.StackTrace);
}
}
#endregion
}
#endregion
#region 文件菜单处理
#region 新建工程
/// <summary>
/// 新建工程
/// </summary>
public class NewProjectCommand : AbstractCommand
{
private ProjectWindow _projectWindow = null;
public override void Run()
{
this._projectWindow = DisplayUtil<ProjectWindow>.PadInstance;
if (this._projectWindow != null)
{
FrmNewProject frmPrj = new FrmNewProject();
DialogResult result = frmPrj.ShowDialog(WorkbenchSingleton.MainForm);
if (result == DialogResult.OK)
{
//new SaveProjectCommand().Run(); //先保存工程
DisplayUtil<ProjectWindow>.ClearProject(); //清除工程
AppConfigHandler.Instance.FullFileName = frmPrj.FullFileName;
bool isLoad = frmPrj.IsLoad;
if (isLoad)
{
this._projectWindow.Tree.LoadFromXml(AppConfigHandler.Instance.FullFileName);
this._projectWindow.RedrawContent(); //重绘
AppConfigHandler.Instance.CurrentProjectWizardName = this._projectWindow.Tree.Nodes[0].Tag as string; //保存过工程类型名称
TreeNode tnDeviceName = this._projectWindow.Tree.GetFirstNodeByNodeName(FixNodeName.NodeDeviceName);
Mesnac.Equips.Factory.Instance.ProjectWizardName = AppConfigHandler.Instance.CurrentProjectWizardName; //为设备接口设置工程模板名称
Mesnac.Equips.Factory.Instance.ConfigFile = Path.Combine(Path.GetDirectoryName(AppConfigHandler.Instance.FullFileName), tnDeviceName.GetPathNoRoot()) + ".xml";
}
else
{
Mesnac.Equips.Factory.Instance.ProjectWizardName = AppConfigHandler.Instance.CurrentProjectWizardName; //为设备接口设置工程模板名称
this._projectWindow.GenerateProjectTree(AppConfigHandler.Instance.FullFileName);
}
}
}
}
}
#endregion
#region 打开工程
/// <summary>
/// 打开工程
/// </summary>
public class OpenProjectCommand : AbstractCommand
{
private ProjectWindow _projectWindow = null;
public OpenProjectCommand()
{
this._projectWindow = DisplayUtil<ProjectWindow>.PadInstance;
}
public override void Run()
{
try
{
OpenFileDialog openFileDialog = new OpenFileDialog();
openFileDialog.Filter = "*.mprj|*.mprj";
DialogResult result = openFileDialog.ShowDialog(WorkbenchSingleton.MainForm);
if (result == DialogResult.OK)
{
new SaveProjectCommand().Run(); //先保存工程
DisplayUtil<ProjectWindow>.ClearProject(); //清除工程
AppConfigHandler.Instance.FullFileName = openFileDialog.FileName;
this._projectWindow.Tree.LoadFromXml(AppConfigHandler.Instance.FullFileName); //初始化工程树
this._projectWindow.RedrawContent(); //重绘
if (this._projectWindow.Tree.Nodes != null && this._projectWindow.Tree.Nodes.Count > 0)
{
this._projectWindow.Tree.SelectedNode = this._projectWindow.Tree.Nodes[0];
}
AppConfigHandler.Instance.CurrentProjectWizardName = this._projectWindow.Tree.Nodes[0].Tag as string; //保存过工程类型名称
TreeNode tnDeviceName = this._projectWindow.Tree.GetFirstNodeByNodeName(FixNodeName.NodeDeviceName);
if (tnDeviceName != null)
{
string deviceFile = Path.Combine(Path.GetDirectoryName(AppConfigHandler.Instance.FullFileName), tnDeviceName.GetPathNoRoot()) + ".xml";
Mesnac.Equips.Factory.Instance.ProjectWizardName = AppConfigHandler.Instance.CurrentProjectWizardName; //为设备接口设置工程模板名称
Mesnac.Equips.Factory.Instance.ConfigFile = deviceFile; //为设备接口设置设备配置文件完整路径
}
DisplayUtil<ProjectWindow>.ResetProjectDataSourceFactory(); //刷新数据源工厂
}
}
catch (Exception ex)
{
LoggingService<OpenProjectCommand>.Error(ex.Message + "\r\n" + ex.StackTrace);
}
}
}
#endregion
#region 保存工程
/// <summary>
/// 保存工程类
/// </summary>
public class SaveProjectCommand : AbstractCommand
{
private ProjectWindow _projectWindow = null;
public SaveProjectCommand()
{
this._projectWindow = DisplayUtil<ProjectWindow>.PadInstance;
}
public override void Run()
{
TreeNode[] parentNode = null;
//保存画面
parentNode = this._projectWindow.Tree.Nodes.Find(FixNodeName.NodeFormName, true);
if (parentNode != null && parentNode.Length == 1)
{
foreach (TreeNode tn in parentNode[0].Nodes)
{
DisplayUtil<ProjectWindow>.SaveFormByNode(CreateType.Form, tn);
}
}
//保存设备
Mesnac.Equips.Factory.Instance.SaveConfig();
}
}
#endregion
#region 关闭工程
/// <summary>
/// 关闭工程类
/// </summary>
public class CloseProjectCommand : AbstractCommand
{
public override void Run()
{
DisplayUtil<ProjectWindow>.ClearProject();
}
}
#endregion
#region 新建画面
/// <summary>
/// 新建画面
/// </summary>
public class NewFormCommand : AbstractCommand
{
private string[] fileNames;
private ProjectWindow _projectWindow;
private PropertyWindow _propertyWindow;
private ActionWindow _actionWindow;
private EventWindow _eventWindow;
private bool _ShouldUpdateSelectableObjects = false;
private string _resultFileName;
public NewFormCommand()
{
this._projectWindow = DisplayUtil<ProjectWindow>.PadInstance;
this._propertyWindow = DisplayUtil<PropertyWindow>.PadInstance;
this._actionWindow = DisplayUtil<ActionWindow>.PadInstance;
this._eventWindow = DisplayUtil<EventWindow>.PadInstance;
}
public NewFormCommand(params string[] fileNames)
{
this.fileNames = fileNames;
this._projectWindow = DisplayUtil<ProjectWindow>.PadInstance;
this._propertyWindow = DisplayUtil<PropertyWindow>.PadInstance;
this._actionWindow = DisplayUtil<ActionWindow>.PadInstance;
this._eventWindow = DisplayUtil<EventWindow>.PadInstance;
}
public override void Run()
{
if (this.fileNames == null || this.fileNames.Length == 0)
{
this._resultFileName = this.CreateNewForm();
}
else
{
this._resultFileName = this.CreateNewForm(this.fileNames);
}
}
public string ResultFileName
{
get { return this._resultFileName; }
}
#region 新建画面宿设计器
/// <summary>
/// 新建、载入画面
/// </summary>
/// <param name="fileNames">要载入的画面的文件名</param>
/// <returns>返回新建或载入的画面的文件名</returns>
public string CreateNewForm(params string[] fileNames)
{
try
{
#region 画面初始化
bool isNew = true; //是否是新建画面true为新建false为加载
string frmName = DisplayUtil<ProjectWindow>.CreateFormName(CreateType.Form); //获取画面文件名称
string nodeText = String.Empty; //获取画面节点名称
HostControl hc = null;
if (fileNames != null && fileNames.Length > 0)
{
isNew = false;
frmName = Path.GetFileNameWithoutExtension(fileNames[0]);
hc = MesnacServiceManager.Instance.HostSurfaceManager.LoadNewHost(fileNames[0]);
TreeNode currNode = this._projectWindow.Tree.GetFirstNodeByNodeName(frmName);
if (currNode != null)
{
nodeText = currNode.Text;
}
else
{
nodeText = frmName;
}
}
if (isNew)
{
//如果是新建则弹出新建文件对话框
FrmNew frmNew = new FrmNew(frmName, CreateType.Form);
DialogResult result = frmNew.ShowDialog(WorkbenchSingleton.MainForm);
if (result == DialogResult.Cancel)
{
return String.Empty;
}
else
{
frmName = frmNew.FileName;
nodeText = String.IsNullOrEmpty(frmNew.NodeName) ? frmName : frmNew.NodeName;
//hc = MesnacServiceManager.Instance.HostSurfaceManager.GetNewHost(typeof(Form), LoaderType.BasicDesignerLoader, frmName);
hc = MesnacServiceManager.Instance.HostSurfaceManager.GetNewHost(typeof(FrmRunTemplate), LoaderType.BasicDesignerLoader, frmName);
}
}
#region 初始化设计器画面窗体名称
if (isNew)
{
((Form)hc.DesignerHost.RootComponent).Text = nodeText;
}
//((Form)hc.DesignerHost.RootComponent).BackColor = Color.FromArgb(39, 72, 98); //设置默认底色
#endregion
//新建容器窗口
FrmContainer fc = new FrmContainer();
fc.Name = frmName;
fc.TitleName = nodeText;
fc.ViewContentID = frmName; //用于在ViewContent集合中查找
hc.Dock = DockStyle.Fill;
hc.Parent = fc;
fc.IsRealClose = false;
fc.FormClosing += new FormClosingEventHandler(fc_FormClosing);
MesnacServiceManager.Instance.HostSurfaceManager.ActiveDesignSurface = hc.HostSurface;
hc.HostSurface._selectionService.SelectionChanged += new EventHandler(FormDesignerHelper._selectionService_SelectionChanged);
MesnacServiceManager.Instance.Host = (System.ComponentModel.Design.IDesignerHost)MesnacServiceManager.Instance.HostSurfaceManager.ActiveDesignSurface.GetService(typeof(System.ComponentModel.Design.IDesignerHost));
this._propertyWindow.PropertyGrid.Site = (new Mesnac.Core.Service.IDEContainer(MesnacServiceManager.Instance.Host)).CreateSite(this._propertyWindow.PropertyGrid);
this._actionWindow.PropertyGrid.Site = (new Mesnac.Core.Service.IDEContainer(MesnacServiceManager.Instance.Host)).CreateSite(this._actionWindow.PropertyGrid);
this._eventWindow.PropertyGrid.Site = (new Mesnac.Core.Service.IDEContainer(MesnacServiceManager.Instance.Host)).CreateSite(this._eventWindow.PropertyGrid);
WorkbenchSingleton.Workbench.ShowView(fc, true);
if (fc.MyOwner != null)
{
(fc.MyOwner as Form).Activated += new EventHandler(fc_Activated);
}
else
{
fc.Activated += new EventHandler(fc_Activated);
}
#endregion
#region 设计器及设计器中组件的事件处理
// 增/删/重命名组件的事件
System.ComponentModel.Design.IComponentChangeService componentChangeService = (System.ComponentModel.Design.IComponentChangeService)MesnacServiceManager.Instance.HostSurfaceManager.ActiveDesignSurface.GetService(typeof(System.ComponentModel.Design.IComponentChangeService));
componentChangeService.ComponentAdded += ComponentListChanged;
componentChangeService.ComponentRemoved += ComponentListChanged;
componentChangeService.ComponentRename += ComponentListChanged;
MesnacServiceManager.Instance.Host.TransactionClosed += new System.ComponentModel.Design.DesignerTransactionCloseEventHandler(TransactionClosed);
#endregion
this.InitPropertyWindow(); //初始化各属性窗口组合框
if (isNew)
{
this.RefereshProjectTree(CreateType.Form, frmName, nodeText);
}
return frmName;
}
catch (Exception ex)
{
MessageBox.Show("新建设计画面错误\n" + ex.Message, "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
return String.Empty;
}
}
/// <summary>
/// 创建命令
/// </summary>
/// <returns></returns>
public string CreateActionFrm()
{
bool isNew = true; //新建
string frmName = DisplayUtil<ProjectWindow>.CreateFormName(CreateType.Command); //获取命令名称
if (isNew)
{
//如果是新建则弹出新建文件对话框
FrmNew frmNew = new FrmNew(frmName, CreateType.Command);
DialogResult result = frmNew.ShowDialog(WorkbenchSingleton.MainForm);
if (result == DialogResult.Cancel)
{
return String.Empty;
}
else
{
frmName = frmNew.FileName;
}
}
//保存工程树文件
if (isNew)
{
this.RefereshProjectTree(CreateType.Command, frmName, frmName);
}
return frmName;
}
void hc_PreviewKeyDown(object sender, PreviewKeyDownEventArgs e)
{
MessageBox.Show(e.KeyValue.ToString());
}
/// <summary>
/// 新建画面时,初始化画面窗口的属性
/// </summary>
private void InitPropertyWindow()
{
if (MesnacServiceManager.Instance.Host != null)
{
FormDesignerHelper.UpdateComboBox();
FormDesignerHelper.SelectedObjectsChanged();
System.ComponentModel.Design.ISelectionService ss = MesnacServiceManager.Instance.HostSurfaceManager.ActiveDesignSurface.GetService(typeof(System.ComponentModel.Design.ISelectionService)) as System.ComponentModel.Design.ISelectionService;
FormDesignerHelper.RefreshComponentProperties(ss);
}
}
/// <summary>
/// 刷新工程树
/// </summary>
/// <param name="frmName">画面文件名</param>
private void RefereshProjectTree(CreateType ct ,string frmName, string nodeName)
{
TreeNode currentNode = this._projectWindow.Tree.SelectedNode;
if (currentNode != null)
{
TreeNode node = new TreeNode();
node.Name = frmName;
node.Text = nodeName;
node.ToolTipText = frmName;
node.Tag = frmName;
switch (ct)
{
case CreateType.Form:
node.ImageIndex = 3;
node.SelectedImageIndex = 3;
break;
case CreateType.Command:
node.ImageIndex = 4;
node.SelectedImageIndex = 4;
node.ToolTipText = CreateType.Command.ToString();
break;
case CreateType.Device:
node.ImageIndex = 5;
node.SelectedImageIndex = 5;
break;
}
currentNode.Nodes.Add(node);
currentNode.Expand();
//保存工程树文件
this._projectWindow.Tree.SaveToXml(AppConfigHandler.Instance.FullFileName);
//保存文件
DisplayUtil<ProjectWindow>.SaveFormByNode(ct, node);
}
}
/// <summary>
/// 在激活某个设计器时,重新设置设置宿主主机的活动设计面
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void fc_Activated(object sender, EventArgs e)
{
try
{
FrmContainer fc = null;
if (sender is WorkspaceWindow)
{
fc = (sender as WorkspaceWindow).ActiveViewContent as FrmContainer;
}
else
{
fc = sender as FrmContainer;
}
HostControl hc = fc.Controls[0] as HostControl;
MesnacServiceManager.Instance.HostSurfaceManager.ActiveDesignSurface = hc.HostSurface;
MesnacServiceManager.Instance.Host = (System.ComponentModel.Design.IDesignerHost)MesnacServiceManager.Instance.HostSurfaceManager.ActiveDesignSurface.GetService(typeof(System.ComponentModel.Design.IDesignerHost));
WorkbenchSingleton.Workbench.CurrentViewContent = fc;
this.InitPropertyWindow();
}
catch(Exception ex)
{
ICSharpCode.Core.LoggingService<NewFormCommand>.Error(ex.Message, ex);
}
}
/// <summary>
/// 宿主设计器中的组件列表发生变化时的事件处理程序(向设计器中增加组件、删除设计器中组件时的处理程序)
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void ComponentListChanged(object sender, EventArgs e)
{
//设置更新选中对象标志为true
_ShouldUpdateSelectableObjects = true;
}
/// <summary>
/// 宿主设计器中的每个事务操作结束时的处理程序
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void TransactionClosed(object sender, System.ComponentModel.Design.DesignerTransactionCloseEventArgs e)
{
if (_ShouldUpdateSelectableObjects)
{
FormDesignerHelper.UpdateComboBox(); //更新组合框控件列表
_ShouldUpdateSelectableObjects = false; //设置更新选中对象标志为false
}
}
/// <summary>
/// 关闭某个设计器是自动保存设计画面
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void fc_FormClosing(object sender, FormClosingEventArgs e)
{
FrmContainer fc = sender as FrmContainer;
TreeNode[] nodes = this._projectWindow.Tree.Nodes.Find(fc.Name, true);
if (nodes != null && nodes.Length > 0)
{
//关闭宿主设计器时,保存画面
DisplayUtil<ProjectWindow>.SaveFormByNode(CreateType.Form, nodes[0]);
}
}
#endregion
}
#endregion
#region 退出应用程序
/// <summary>
/// 退出应用程序
/// </summary>
public class ExitCommand : AbstractCommand
{
public override void Run()
{
//1、先清除工程
DisplayUtil<ProjectWindow>.ClearProject();
//string caption = StringParser.Parse(ResourceService.GetString("Mesnac_Dialog_Caption"));
//string msg = StringParser.Parse(ResourceService.GetString("Dialog_MessageBox_ExtAsk"));
//DialogResult result = MessageBox.Show(msg, caption, MessageBoxButtons.YesNo, MessageBoxIcon.Question);
//if (result == DialogResult.Yes)
//{
// WorkbenchSingleton.Workbench.CloseFlag = true; //设置系统关闭标识
// (WorkbenchSingleton.Workbench as System.Windows.Forms.Form).Close();
//}
WorkbenchSingleton.Workbench.CloseFlag = false; //设置系统关闭标识
(WorkbenchSingleton.Workbench as System.Windows.Forms.Form).Close();
}
}
#endregion
#endregion
#region 编辑菜单处理
#region 撤销
/// <summary>
/// 插销
/// </summary>
public class UndoCommand : AbstractCommand
{
public override void Run()
{
if (MesnacServiceManager.Instance.HostSurfaceManager.ActiveDesignSurface == null)
{
LoggingService<UndoCommand>.Warn("当前画面实例为空!");
return;
}
UndoEngineExt ims = MesnacServiceManager.Instance.HostSurfaceManager.ActiveDesignSurface.GetService(typeof(UndoEngine)) as UndoEngineExt;
ims.Undo();
}
}
#endregion
#region 重做
/// <summary>
/// 重做
/// </summary>
public class RedoCommand : AbstractCommand
{
public override void Run()
{
if (MesnacServiceManager.Instance.HostSurfaceManager.ActiveDesignSurface == null)
{
LoggingService<RedoCommand>.Warn("当前画面实例为空!");
return;
}
UndoEngineExt ims = MesnacServiceManager.Instance.HostSurfaceManager.ActiveDesignSurface.GetService(typeof(UndoEngine)) as UndoEngineExt;
ims.Redo();
}
}
#endregion
#region 剪切
/// <summary>
/// 剪切
/// </summary>
public class CutCommand : AbstractCommand
{
public override void Run()
{
DisplayUtil<ProjectWindow>.PerformAction(StandardCommands.Cut);
}
}
#endregion
#region 复制
/// <summary>
/// 复制
/// </summary>
public class CopyCommand : AbstractCommand
{
public override void Run()
{
DisplayUtil<ProjectWindow>.PerformAction(StandardCommands.Copy);
}
}
#endregion
#region 粘贴
/// <summary>
/// 粘贴
/// </summary>
public class PasteCommand : AbstractCommand
{
public override void Run()
{
DisplayUtil<ProjectWindow>.PerformAction(StandardCommands.Paste);
}
}
#endregion
#region 删除
/// <summary>
/// 删除
/// </summary>
public class DeleteCommand : AbstractCommand
{
public override void Run()
{
DisplayUtil<ProjectWindow>.PerformAction(StandardCommands.Delete);
}
}
#endregion
#region 全选
/// <summary>
/// 全选
/// </summary>
public class SelectAllCommand : AbstractCommand
{
public override void Run()
{
DisplayUtil<ProjectWindow>.PerformAction(StandardCommands.SelectAll);
}
}
#endregion
#endregion
#region 视图菜单处理
#region 解决方案资源管理器
/// <summary>
/// 解决方案资源管理器
/// </summary>
public class SolutionWindowCommand : AbstractCommand
{
public override void Run()
{
Mesnac.PlugIn.Pad.PadDescriptor pd = WorkbenchSingleton.Workbench.GetPad(typeof(Mesnac.Gui.Edit.Pad.ProjectWindow));
if (pd != null)
{
WorkbenchSingleton.Workbench.ShowPad(pd);
}
}
}
#endregion
#region 属性窗口
/// <summary>
/// 属性窗口
/// </summary>
public class PropertyWindowCommand : AbstractCommand
{
public override void Run()
{
Mesnac.PlugIn.Pad.PadDescriptor pd = WorkbenchSingleton.Workbench.GetPad(typeof(Mesnac.Gui.Edit.Pad.PropertyWindow));
if (pd != null)
{
WorkbenchSingleton.Workbench.ShowPad(pd);
}
}
}
#endregion
#region 工具箱
/// <summary>
/// 工具箱
/// </summary>
public class ToolBoxWindowCommand : AbstractCommand
{
public override void Run()
{
Mesnac.PlugIn.Pad.PadDescriptor pd = WorkbenchSingleton.Workbench.GetPad(typeof(Mesnac.Gui.Edit.Pad.ToolBoxWindow));
if (pd != null)
{
WorkbenchSingleton.Workbench.ShowPad(pd);
}
}
}
#endregion
#region 动画窗口
/// <summary>
/// 动画窗口
/// </summary>
public class ActionWindowCommand : AbstractCommand
{
public override void Run()
{
Mesnac.PlugIn.Pad.PadDescriptor pd = WorkbenchSingleton.Workbench.GetPad(typeof(Mesnac.Gui.Edit.Pad.ActionWindow));
if (pd != null)
{
WorkbenchSingleton.Workbench.ShowPad(pd);
}
}
}
#endregion
#region 事件窗口
/// <summary>
/// 事件窗口
/// </summary>
public class EventWindowCommand : AbstractCommand
{
public override void Run()
{
Mesnac.PlugIn.Pad.PadDescriptor pd = WorkbenchSingleton.Workbench.GetPad(typeof(Mesnac.Gui.Edit.Pad.EventWindow));
if (pd != null)
{
WorkbenchSingleton.Workbench.ShowPad(pd);
}
}
}
#endregion
#endregion
#region 布局菜单处理
#region 对齐到网格
/// <summary>
/// 对齐到网格
/// </summary>
public class AlignToGridCommand : AbstractCommand
{
public override void Run()
{
DisplayUtil<ProjectWindow>.PerformAction(StandardCommands.AlignToGrid);
}
}
#endregion
#region 左对齐
/// <summary>
/// 左对齐
/// </summary>
public class AlignLeftCommand : AbstractCommand
{
public override void Run()
{
DisplayUtil<ProjectWindow>.PerformAction(StandardCommands.AlignLeft);
}
}
#endregion
#region 居中对齐
/// <summary>
/// 居中对齐
/// </summary>
public class AlignHorizontalCentersCommand : AbstractCommand
{
public override void Run()
{
DisplayUtil<ProjectWindow>.PerformAction(StandardCommands.AlignHorizontalCenters);
}
}
#endregion
#region 右对齐
/// <summary>
/// 右对齐
/// </summary>
public class AlignRightCommand : AbstractCommand
{
public override void Run()
{
DisplayUtil<ProjectWindow>.PerformAction(StandardCommands.AlignRight);
}
}
#endregion
#region 顶端对齐
/// <summary>
/// 顶端对齐
/// </summary>
public class AlignTopCommand : AbstractCommand
{
public override void Run()
{
DisplayUtil<ProjectWindow>.PerformAction(StandardCommands.AlignTop);
}
}
#endregion
#region 中间对齐
/// <summary>
/// 中间对齐
/// </summary>
public class AlignVerticalCentersCommand : AbstractCommand
{
public override void Run()
{
DisplayUtil<ProjectWindow>.PerformAction(StandardCommands.AlignVerticalCenters);
}
}
#endregion
#region 底部对齐
/// <summary>
/// 底部对齐
/// </summary>
public class AlignBottomCommand : AbstractCommand
{
public override void Run()
{
DisplayUtil<ProjectWindow>.PerformAction(StandardCommands.AlignBottom);
}
}
#endregion
#region 使宽度相同
/// <summary>
/// 使宽度相同
/// </summary>
public class SizeToControlWidthCommand : AbstractCommand
{
public override void Run()
{
DisplayUtil<ProjectWindow>.PerformAction(StandardCommands.SizeToControlWidth);
}
}
#endregion
#region 使高度相同
/// <summary>
/// 使高度相同
/// </summary>
public class SizeToControlHeightCommand : AbstractCommand
{
public override void Run()
{
DisplayUtil<ProjectWindow>.PerformAction(StandardCommands.SizeToControlHeight);
}
}
#endregion
#region 使大小相同
/// <summary>
/// 使大小相同
/// </summary>
public class SizeToControlCommand : AbstractCommand
{
public override void Run()
{
DisplayUtil<ProjectWindow>.PerformAction(StandardCommands.SizeToControl);
}
}
#endregion
#region 按网格调整大小
/// <summary>
/// 按网格调整大小
/// </summary>
public class SizeToGridCommand : AbstractCommand
{
public override void Run()
{
DisplayUtil<ProjectWindow>.PerformAction(StandardCommands.SizeToGrid);
}
}
#endregion
#region 使水平间距相等
/// <summary>
/// 使水平间距相等
/// </summary>
public class HorizSpaceMakeEqualCommand : AbstractCommand
{
public override void Run()
{
DisplayUtil<ProjectWindow>.PerformAction(StandardCommands.HorizSpaceMakeEqual);
}
}
#endregion
#region 增加水平间距
/// <summary>
/// 增加水平间距
/// </summary>
public class HorizSpaceIncreaseCommand : AbstractCommand
{
public override void Run()
{
DisplayUtil<ProjectWindow>.PerformAction(StandardCommands.HorizSpaceIncrease);
}
}
#endregion
#region 减小水平间距
/// <summary>
/// 减小水平间距
/// </summary>
public class HorizSpaceDecreaseCommand : AbstractCommand
{
public override void Run()
{
DisplayUtil<ProjectWindow>.PerformAction(StandardCommands.HorizSpaceDecrease);
}
}
#endregion
#region 移除水平间距
/// <summary>
/// 移除水平间距
/// </summary>
public class HorizSpaceConcatenateCommand : AbstractCommand
{
public override void Run()
{
DisplayUtil<ProjectWindow>.PerformAction(StandardCommands.HorizSpaceConcatenate);
}
}
#endregion
#region 使垂直间距相等
/// <summary>
/// 使垂直间距相等
/// </summary>
public class VertSpaceMakeEqualCommand : AbstractCommand
{
public override void Run()
{
DisplayUtil<ProjectWindow>.PerformAction(StandardCommands.VertSpaceMakeEqual);
}
}
#endregion
#region 增加垂直间距
/// <summary>
/// 增加垂直间距
/// </summary>
public class VertSpaceIncreaseCommand : AbstractCommand
{
public override void Run()
{
DisplayUtil<ProjectWindow>.PerformAction(StandardCommands.VertSpaceIncrease);
}
}
#endregion
#region 减小垂直间距
/// <summary>
/// 减小垂直间距
/// </summary>
public class VertSpaceDecreaseCommand : AbstractCommand
{
public override void Run()
{
DisplayUtil<ProjectWindow>.PerformAction(StandardCommands.VertSpaceDecrease);
}
}
#endregion
#region 取消垂直间距
/// <summary>
/// 取消垂直间距
/// </summary>
public class VertSpaceConcatenateCommand : AbstractCommand
{
public override void Run()
{
DisplayUtil<ProjectWindow>.PerformAction(StandardCommands.VertSpaceConcatenate);
}
}
#endregion
#region 水平居中
/// <summary>
/// 水平居中
/// </summary>
public class CenterHorizontallyCommand : AbstractCommand
{
public override void Run()
{
DisplayUtil<ProjectWindow>.PerformAction(StandardCommands.CenterHorizontally);
}
}
#endregion
#region 垂直居中
/// <summary>
/// 垂直居中
/// </summary>
public class CenterVerticallyCommand : AbstractCommand
{
public override void Run()
{
DisplayUtil<ProjectWindow>.PerformAction(StandardCommands.CenterVertically);
}
}
#endregion
#region 置于顶层
/// <summary>
/// 置于顶层
/// </summary>
public class BringToFrontCommand : AbstractCommand
{
public override void Run()
{
DisplayUtil<ProjectWindow>.PerformAction(StandardCommands.BringToFront);
}
}
#endregion
#region 置于底层
/// <summary>
/// 置于底层
/// </summary>
public class SendToBackCommand : AbstractCommand
{
public override void Run()
{
DisplayUtil<ProjectWindow>.PerformAction(StandardCommands.SendToBack);
}
}
#endregion
#region 前移一层
/// <summary>
/// 前移一层
/// </summary>
public class BringForwardCommand : AbstractCommand
{
public override void Run()
{
DisplayUtil<ProjectWindow>.PerformAction(StandardCommands.BringForward);
}
}
#endregion
#region 后移一层
/// <summary>
/// 后移一层
/// </summary>
public class SendBackwardCommand : AbstractCommand
{
public override void Run()
{
DisplayUtil<ProjectWindow>.PerformAction(StandardCommands.SendBackward);
}
}
#endregion
#endregion
#region 全屏切换
/// <summary>
/// 全屏切换
/// </summary>
public class ToggleFullscreenCommand : AbstractCommand
{
public override void Run()
{
WorkbenchSingleton.Workbench.FullScreen = !WorkbenchSingleton.Workbench.FullScreen;
}
}
#endregion
#region 菜单、工具栏按钮启用、禁用操作
#region 工程保存、关闭
/// <summary>
/// 工程保存、关闭
/// </summary>
public class MCEditProjectStateConditionEvaluator : IConditionEvaluator
{
public bool IsValid(object caller, Condition condition)
{
if (DisplayUtil<ProjectWindow>.PadInstance != null && DisplayUtil<ProjectWindow>.PadInstance.Tree.Nodes.Count == 0)
{
return false;
}
else
{
return true;
}
}
}
#endregion
#region 编辑菜单
/// <summary>
/// 编辑菜单
/// </summary>
public class MCEditEditStateConditionEvaluator : IConditionEvaluator
{
public bool IsValid(object owner, Condition condition)
{
if (DisplayUtil<ProjectWindow>.PadInstance != null && DisplayUtil<ProjectWindow>.PadInstance.Tree.Nodes.Count == 0 || MesnacServiceManager.Instance.Host == null)
{
//没有工程 禁用编辑
return false;
}
else
{
return true;
}
}
}
#endregion
#region 撤销、重做、仿真
/// <summary>
/// 仿真
/// </summary>
public class MCEditDesignerExistsStateConditionEvaluator : IConditionEvaluator
{
public bool IsValid(object owner, Condition condition)
{
WorkspaceWindow window = WorkbenchSingleton.Workbench.ActiveContent as WorkspaceWindow;
if (MesnacServiceManager.Instance.HostSurfaceManager.ActiveDesignSurface != null && window != null && window.ViewContent is FrmContainer)
{
return true;
}
else
{
return false;
}
}
}
/// <summary>
/// 撤销
/// </summary>
public class MCEditUndoStateConditionEvaluator : IConditionEvaluator
{
public bool IsValid(object owner, Condition condition)
{
if (MesnacServiceManager.Instance.HostSurfaceManager.ActiveDesignSurface == null)
{
return false;
}
UndoEngineExt ims = MesnacServiceManager.Instance.HostSurfaceManager.ActiveDesignSurface.GetService(typeof(UndoEngine)) as UndoEngineExt;
if (ims.EnableUndo)
{
return true;
}
else
{
return false;
}
}
}
/// <summary>
/// 重做
/// </summary>
public class MCEditRedoStateConditionEvaluator : IConditionEvaluator
{
public bool IsValid(object owner, Condition condition)
{
if (MesnacServiceManager.Instance.HostSurfaceManager.ActiveDesignSurface == null)
{
return false;
}
UndoEngineExt ims = MesnacServiceManager.Instance.HostSurfaceManager.ActiveDesignSurface.GetService(typeof(UndoEngine)) as UndoEngineExt;
if (ims.EnableRedo)
{
return true;
}
else
{
return false;
}
}
}
#endregion
#region 工程面板
/// <summary>
/// 工程面板
/// </summary>
public class MCEditProjectWindowStateConditionEvaluator : IConditionEvaluator
{
public bool IsValid(object owner, Condition condition)
{
ProjectWindow projectWindow = DisplayUtil<ProjectWindow>.PadInstance;
if (projectWindow != null && projectWindow.Visible)
{
return false;
}
else
{
return true;
}
}
}
#endregion
#region 工具箱
/// <summary>
/// 工具箱
/// </summary>
public class MCEditToolBoxWindowStateConditionEvaluator : IConditionEvaluator
{
public bool IsValid(object owner, Condition condition)
{
ToolBoxWindow toolBoxWindow = DisplayUtil<ToolBoxWindow>.PadInstance;
if (toolBoxWindow != null && toolBoxWindow.Visible)
{
return false;
}
else
{
return true;
}
}
}
#endregion
#region 属性面板
/// <summary>
/// 属性面板
/// </summary>
public class MCEditPropertyWindowStateConditionEvaluator : IConditionEvaluator
{
public bool IsValid(object owner, Condition condition)
{
PropertyWindow propertyWindow = DisplayUtil<PropertyWindow>.PadInstance;
if (propertyWindow != null && propertyWindow.Visible)
{
return false;
}
else
{
return true;
}
}
}
#endregion
#region 动画面板
/// <summary>
/// 动画面板
/// </summary>
public class MCEditActionWindowStateConditionEvaluator : IConditionEvaluator
{
public bool IsValid(object owner, Condition condition)
{
ActionWindow actionWindow = DisplayUtil<ActionWindow>.PadInstance;
if (actionWindow != null && actionWindow.Visible)
{
return false;
}
else
{
return true;
}
}
}
#endregion
#region 布局
/// <summary>
/// 布局,未选中任何控件
/// </summary>
public class MCEditLayoutEmptyConditionEvaluator : IConditionEvaluator
{
public bool IsValid(object owner, Condition condition)
{
object[] selectedcomp = FormDesignerHelper.GetSelectComponents();
if (selectedcomp == null || selectedcomp.Length > 0 && selectedcomp[0] is System.Windows.Forms.Form)
{
return false;
}
else
{
return true;
}
}
}
/// <summary>
/// 布局,设计器中只有一个组件
/// </summary>
public class MCEditLayoutOnlyOneConditionEvaluator : IConditionEvaluator
{
public bool IsValid(object owner, Condition condition)
{
ComponentCollection allComponents = FormDesignerHelper.GetAllComponents();
object[] selectedcomp = FormDesignerHelper.GetSelectComponents();
if (allComponents != null && allComponents.Count == 2 && selectedcomp != null && selectedcomp.Length > 0 && !(selectedcomp[0] is System.Windows.Forms.Form))
{
return false;
}
else
{
return true;
}
}
}
/// <summary>
/// 布局,只选中一个控件
/// </summary>
public class MCEditLayoutSelectOneConditionEvaluator : IConditionEvaluator
{
public bool IsValid(object owner, Condition condition)
{
ComponentCollection allComponents = FormDesignerHelper.GetAllComponents();
object[] selectedcomp = FormDesignerHelper.GetSelectComponents();
if (allComponents != null && allComponents.Count > 2 && selectedcomp != null && selectedcomp.Length <= 1)
{
return false;
}
else
{
return true;
}
}
}
#endregion
#endregion
#region 运行仿真
/// <summary>
/// 运行方针
/// </summary>
public class RunCommand : AbstractCommand
{
public override void Run()
{
if (WorkbenchSingleton.Workbench.ActiveContent is WorkspaceWindow)
{
WorkspaceWindow window = WorkbenchSingleton.Workbench.ActiveContent as WorkspaceWindow;
if (window.ActiveViewContent is FrmContainer)
{
FrmContainer frm = window.ActiveViewContent as FrmContainer;
ProjectWindow projectWindow = DisplayUtil<ProjectWindow>.PadInstance;
if (projectWindow != null)
{
TreeNode currNode = projectWindow.Tree.GetFirstNodeByNodeName(frm.Name);
if (currNode != null)
{
projectWindow.Tree.SelectedNode = currNode;
projectWindow.RunSimulation();
}
}
}
}
}
}
#endregion
#region 语言菜单处理
#region 中文
public class ChineseCommand : AbstractCommand
{
public override void Run()
{
LanguageHelper.SetCurrentCultureInfo("zh-CN");
}
}
#endregion
#region 英文
public class EnglishCommand : AbstractCommand
{
public override void Run()
{
LanguageHelper.SetCurrentCultureInfo("en-US");
}
}
#endregion
#endregion
#region 测试
/// <summary>
/// 测试
/// </summary>
public class TestCommand : AbstractCommand
{
public override void Run()
{
}
}
#endregion
#region 报表设计器
public class ReportDesigner : AbstractCommand
{
public override void Run()
{
//ReportDesiger rd = new ReportDesiger();
//rd.Show();
FastReport.Report report = new FastReport.Report();
report.Design();
}
}
#endregion
}