public void Add(ToolWindow window, DockSite dockSite)
{
var item = _items.FirstOrDefault(i => Equals(i.Window, window));
if (null == item)
_items.Add(new Item(window, dockSite));
}
public Item(ToolWindow window, DockSite dockSite)
{
Window = window;
MenuItem = new MenuItem
{
Header = window.Title,
IsCheckable = true,
IsChecked = window.IsOpen,
Tag = window,
Name = "MenuItem" + window.Name,
HorizontalContentAlignment = HorizontalAlignment.Left,
VerticalContentAlignment = VerticalAlignment.Center
};
MenuItem.Click += UpdateToolWindow;
if (null == dockSite)
return;
DockSite = dockSite;
DockSite.WindowClosed += WindowClosed;
DockSite.WindowOpened += WindowOpened;
}
protected override void OnCreate() {
base.OnCreate();
_site = (IServiceProvider)this;
_pyService = _site.GetPythonToolsService();
#if DEV14_OR_LATER
// TODO: Get PYEnvironment added to image list
BitmapImageMoniker = KnownMonikers.DockPanel;
#else
BitmapResourceID = PythonConstants.ResourceIdForReplImages;
BitmapIndex = 0;
#endif
Caption = SR.GetString(SR.Environments);
_service = _site.GetComponentModel().GetService<IInterpreterOptionsService>();
_outputWindow = OutputWindowRedirector.GetGeneral(_site);
Debug.Assert(_outputWindow != null);
_statusBar = _site.GetService(typeof(SVsStatusbar)) as IVsStatusbar;
var list = new ToolWindow();
list.ViewCreated += List_ViewCreated;
list.CommandBindings.Add(new CommandBinding(
EnvironmentView.OpenInteractiveWindow,
OpenInteractiveWindow_Executed,
OpenInteractiveWindow_CanExecute
));
list.CommandBindings.Add(new CommandBinding(
EnvironmentView.OpenInteractiveOptions,
OpenInteractiveOptions_Executed,
OpenInteractiveOptions_CanExecute
));
list.CommandBindings.Add(new CommandBinding(
EnvironmentPathsExtension.StartInterpreter,
StartInterpreter_Executed,
StartInterpreter_CanExecute
));
list.CommandBindings.Add(new CommandBinding(
EnvironmentPathsExtension.StartWindowsInterpreter,
StartInterpreter_Executed,
StartInterpreter_CanExecute
));
list.CommandBindings.Add(new CommandBinding(
ApplicationCommands.Help,
OnlineHelp_Executed,
OnlineHelp_CanExecute
));
list.CommandBindings.Add(new CommandBinding(
ToolWindow.UnhandledException,
UnhandledException_Executed,
UnhandledException_CanExecute
));
list.Service = _service;
Content = list;
}
public ToolWindow AddToolWindow(string title, DockPosition pos, Control c)
{
c.Dock = DockStyle.Fill;
var windowTop = new ToolWindow { Text = title, Name = title };
windowTop.Controls.Add(c);
this.rda.DockWindow(windowTop, pos);
return windowTop;
}
public MixerForm()
{
InitializeComponent();
ToolWindow<Mixer> MixToolWindow = new ToolWindow<Mixer>();
Controls.Add(MixToolWindow);
MixToolWindow.InnerControl.Channels.Add(new MixerChannel());
MixToolWindow.InnerControl.Channels.Add(new MixerChannel());
MixToolWindow.InnerControl.Channels.Add(new MixerChannel());
MixToolWindow.Location = new System.Drawing.Point(10, 10);
MixToolWindow.Size = new System.Drawing.Size(600, 400);
}
private static void SetToolWindowStyle(ToolWindow toolWindow, object tag)
{
if (tag != null)
{
var styleName = string.Format("{0}ToolWindowStyle", tag);
var style = Application.Current.Resources[styleName] as Style;
if (style != null)
{
toolWindow.Style = style;
}
}
}
internal ToolWindow CreateWindow(Size p_size, Point p_location)
{
if (_popupPanel == null)
{
CreatePopupCanvas();
}
ToolWindow win = new ToolWindow(this, _popupPanel);
win.Width = p_size.Width;
win.Height = p_size.Height;
win.HorizontalOffset = p_location.X;
win.VerticalOffset = p_location.Y;
return(win);
}
private void OnRowSelected(object sender, ListEditorEventArgs e)
{
TableEditor tab = (TableEditor)sender;
List <DBItem> rows = tab.SelectedRows;
foreach (DBItem row in rows)
{
DBItem dr = Table.NewItem();
dr[baseColumn] = baseRow.PrimaryId;
dr[tab.baseColumn] = row.PrimaryId;
Table.Add(dr);
}
_currentControl.Hide();
_currentControl = null;
}
public void CreateToolWindows()
{
this.CreateHandle();
foreach (Assembly assembly in Manager.Assemblies)
{
foreach (Type type in assembly.GetTypes())
{
if (typeof(ToolWindow).IsAssignableFrom(type) && type.IsClass)
{
ToolWindowAttribute attr = ToolWindowAttribute.ForType(type);
if (attr == null)
{
continue;
}
ToolWindow panel = Activator.CreateInstance(type, new object[] { Manager }) as ToolWindow;
IntPtr handle = panel.Handle; // Make sure we can call Invoke(), even if it isn't opened
mToolWindows.Add(panel);
ToolStripMenuItem parent;
if (attr.Group == "")
{
parent = viewToolStripMenuItem;
}
else
{
ToolStripItem [] candidates = viewToolStripMenuItem.DropDownItems.Find(attr.Group, false);
if (candidates.Length > 0)
{
parent = (ToolStripMenuItem)candidates[0];
}
else
{
parent = new ToolStripMenuItem(attr.Group);
parent.Name = attr.Group;
viewToolStripMenuItem.DropDownItems.Add(parent);
}
}
ToolStripMenuItem menu = new ToolStripMenuItem(panel.TabText);
menu.Tag = panel;
menu.Click += new EventHandler(ToolMenu_Click);
parent.DropDownItems.Add(menu);
}
}
}
}
private void ToolInitialize()
{
try
{
ControlSettings = LoadSettings(this);
var toolWindow = GetToolWindow();
IPackageContext packageContext = this;
var viewModel = ToolWindow.GetViewModel(toolWindow);
var buildContext = new BuildContext(packageContext, viewModel);
var tool = new Tool.Tool(packageContext, buildContext, buildContext, viewModel);
}
catch (Exception ex)
{
ex.TraceUnknownException();
}
}
private void ToolDBGenerateClick(object sender, EventArgs e)
{
var assemblyList = new SelectableList <AsseblyCheck>();
string[] asseblies = Directory.GetFiles(Helper.GetDirectory(), "*.dll");
foreach (string dll in asseblies)
{
AssemblyDefinition assemblyDefinition = null;
try { assemblyDefinition = AssemblyDefinition.ReadAssembly(dll); }
catch { continue; }
var moduleAttribute = assemblyDefinition.CustomAttributes
.Where(item => item.AttributeType.Name == nameof(AssemblyMetadataAttribute))
.Select(item => item.ConstructorArguments.Select(sitem => sitem.Value.ToString())
.ToArray());
if (moduleAttribute.Any(item => item[0] == "module"))
{
assemblyList.Add(new AsseblyCheck(Assembly.LoadFile(dll)));
}
}
var list = new LayoutList
{
AllowCheck = true,
CheckRecursive = true,
AutoToStringFill = true,
GenerateToString = true,
GenerateColumns = false,
ListSource = assemblyList
};
var window = new ToolWindow
{
Title = "Select Assembly",
Target = list
};
window.Show(this, Point.Zero);
window.ButtonAcceptClick += (s, a) =>
{
var schema = new DBSchema("NewSchema");
schema.Generate(assemblyList.Where(p => p.Check).Select(p => p.Assembly));
DBService.Schems.Add(schema);
ShowNewItem(schema);
};
}
/// <summary>
/// Occurs when the <c>Activate.Programmatic ToolWindow 1</c> menu item is clicked.
/// </summary>
/// <param name="sender">The sender of the event.</param>
/// <param name="e">A <see cref="RoutedEventArgs"/> that contains the event data.</param>
private void OnActivateProgrammaticToolWindow1Click(object sender, RoutedEventArgs e)
{
var toolWindow = dockSite.ToolWindows["programmaticToolWindow1"];
if (toolWindow == null)
{
// Create, initialize, and register the tool window
toolWindow = new ToolWindow();
this.InitializeProgrammaticToolWindow1(toolWindow);
this.dockSite.ToolWindows.Add(toolWindow);
// Change the menu item's header
activeProgrammaticToolWindow1.Header = "Activate Programmatic ToolWindow 1";
}
toolWindow.Activate();
}
public static void ShowResultDialog(object parent, DBProcedure proc, object result)
{
var textbox = new RichTextView();
textbox.LoadText(result.ToString(), Xwt.Formats.TextFormat.Plain);
var wind = new ToolWindow()
{
Target = textbox,
Mode = ToolShowMode.Dialog,
Size = new Size(600, 400)
};
wind.ButtonClose.Visible = false;
wind.Label.Text = "Result of " + (proc != null ? proc.Name : string.Empty);
wind.Show();
//wind.Dispose();
}
private static void SelectEnv(ToolWindow envs, IPythonInterpreterFactory interpreter, int retries)
{
if (retries <= 0)
{
Debug.Fail("Failed to select environment after multiple retries");
return;
}
var select = envs.IsLoaded ? envs.Environments.OfType <EnvironmentView>().FirstOrDefault(e => e.Factory == interpreter) : null;
if (select == null)
{
envs.Dispatcher.InvokeAsync(() => SelectEnv(envs, interpreter, retries - 1), DispatcherPriority.Background);
return;
}
envs.Environments.MoveCurrentTo(select);
}
void btn_ToolTipOpening(object sender, ToolTipEventArgs e)
{
ReflectedButton btn = sender as ReflectedButton;
ToolWindow window = btn.Tag as ToolWindow;
ToolTip toolTip = btn.ToolTip as ToolTip;
Rectangle rect = toolTip.Content as Rectangle;
VisualBrush vb = new VisualBrush(window);
vb.Opacity = 0.8;
vb.AlignmentX = AlignmentX.Center;
vb.AlignmentY = AlignmentY.Center;
vb.Stretch = Stretch.Uniform;
rect.Fill = vb;
rect.Width = 250;
rect.Height = window.ActualHeight * (250 / window.ActualWidth);
}
static void btnCoordinateFileImport_ExecuteCommand(object sender, ExecuteCommandEventArgs e)
{
try
{
windowCoordinateFileImport = new ToolWindow();
windowCoordinateFileImport.PreferredSize = new System.Drawing.Size(180, 100);
UserInterface uc = new UserInterface();
windowCoordinateFileImport.Control = uc;
windowCoordinateFileImport.Caption = "Coordinate File Import";
UIEnvironment.Windows.AddDocked(windowCoordinateFileImport, DockStyle.Right);
windowCoordinateFileImport.VisibleChanged += new EventHandler(windowCoordinateFileImport_VisibleChanged);
btnCoordinateFileImport.DefaultEnabled = false;
}
catch (Exception ex)
{
Logger.AddMessage(new LogMessage(ex.StackTrace, LogMessageSeverity.Error));
}
}
private void ButtonAddTool_Click(object sender, RoutedEventArgs e)
{
this.edit = false;
ToolWindow toolWindow = new ToolWindow(edit, selRow);
toolWindow.ShowDialog();
clsHerramientas obj_h = new clsHerramientas();
dt_herramientas = obj_h.CargarHerramientas();
dt_herramientas.Columns[0].ColumnName = "TOOL CODE";
dt_herramientas.Columns[1].ColumnName = "DESCRIPTION";
dt_herramientas.Columns[2].ColumnName = "UNIT";
dt_herramientas.Columns[3].ColumnName = "VALUE";
ToolsDataGrid.ItemsSource = dt_herramientas.DefaultView;
}
private IDockContent GetContentFromPersistString(string persistString)
{
string[] parsedStrings = persistString.Split(';');
Type type = Type.GetType(parsedStrings[0]);
if (type == null)
{
return(null);
}
if (typeof(ToolWindow).IsAssignableFrom(type))
{
ToolWindow window = _dockingService.GetDockingWindow(type);
if (window != null)
{
return(window);
}
}
if (parsedStrings.Length < 2 || !typeof(AbstractFileEditor).IsAssignableFrom(type))
{
return(null);
}
FilePath fileName = new FilePath(parsedStrings[1]);
if (!File.Exists(fileName))
{
return(null);
}
AbstractUiAction.RunCommand(new OpenFileAction(fileName));
var doc = _dockingService.Documents.OfType <AbstractFileEditor>()
.FirstOrDefault(d => fileName == d.FileName);
if (doc == null)
{
return(null);
}
doc.PersistStringLoad(parsedStrings);
return(doc);
}
/// <summary>
/// Creates a new <see cref="ToolWindow"/>.
/// </summary>
/// <param name="title">The title to use.</param>
/// <returns>The <see cref="ToolWindow"/> that was created.</returns>
private ToolWindow CreateToolWindow(string title)
{
// Create a TextBox
var textBox = new TextBox();
textBox.BorderThickness = new Thickness();
textBox.TextWrapping = TextWrapping.Wrap;
textBox.VerticalScrollBarVisibility = ScrollBarVisibility.Auto;
// Initialize
textBox.Text = String.Format("Tool window {0} created at {1}.", ++windowIndex, DateTime.Now);
var name = String.Format("ToolWindow{0}", windowIndex);
// Create the window (using this constructor registers the tool window with the DockSite)
var window = new ToolWindow(dockSite, name, title,
new BitmapImage(new Uri("/Images/Icons/TextDocument16.png", UriKind.Relative)), textBox);
return(window);
}
void OpenToolBar(ControlBase control, EventArgs args)
{
ToolWindow window = new ToolWindow(this);
window.Padding = Padding.Five;
window.HorizontalAlignment = HorizontalAlignment.Left;
window.VerticalAlignment = VerticalAlignment.Top;
window.StartPosition = StartPosition.CenterCanvas;
HorizontalLayout layout = new HorizontalLayout(window);
for (int i = 0; i < 5; i++)
{
Button button = new Button(layout);
button.Size = new Size(36, 36);
button.UserData = window;
button.Clicked += Close;
}
}
private void accountReport_Click(object sender, EventArgs e)
{
Views.ReportsView.AccountReport dr = new ReportsView.AccountReport();
dr.MdiParent = this;
dr.Show();
ToolWindow teucW = new ToolWindow();
teucW.Text = "صورت حساب";
teucW.Controls.Add(dr);
if (rightHandStrip == null)
{
this.radDock1.DockWindow(teucW, DockPosition.Right);
rightHandStrip = (ToolTabStrip)teucW.Parent;
}
else
{
this.radDock1.DockWindow(teucW, rightHandStrip, DockPosition.Fill);
}
}
/// <summary>
/// 更新Tabs内部停靠导航
/// </summary>
/// <param name="p_pos"></param>
/// <param name="p_win"></param>
void UpdateCompass(Point p_pos, ToolWindow p_win)
{
// 获取当前位置处其他窗口中的Tabs
Tabs sect = GetHitSect(p_pos, _popupPanel, p_win);
if (sect == null || !CheckIsDockable(sect))
{
// 当前位置处的Tabs
sect = GetHitSect(p_pos, this, p_win);
if (sect != null && sect.IsInCenter && !p_win.CanDockInCenter)
{
sect = null;
}
}
// 有变化
if (sect != _sectWithCompass && _compass != null)
{
_compass.ClearIndicators();
}
if (sect == null)
{
// 无选中区域
_sectWithCompass = null;
_compass.Visibility = Visibility.Collapsed;
}
else
{
// 有停靠区域
_sectWithCompass = sect;
_compass.Visibility = Visibility.Visible;
double horOffset = (sect.ActualWidth - _compass.Width) / 2.0;
double verOffset = (sect.ActualHeight - _compass.Height) / 2.0;
Point pos = GetElementPositionRelatedToPopup(sect);
double left = Math.Round((double)(horOffset + pos.X));
double top = Math.Round((double)(verOffset + pos.Y));
Canvas.SetLeft(_compass, left);
Canvas.SetTop(_compass, top);
_compass.ChangeDockPosition(p_pos);
}
}
public void SetCurrentTab(ToolWindow window)
{
if (window != null)
{
if (this.docs.Contains(window))
{
this.docs.Remove(window);
this.docs.Insert(0, window);
if (Log.IsDebugEnabled)
{
StringBuilder sb = new StringBuilder();
foreach (IDockContent doc in docs)
{
sb.Append(((ToolWindow)doc).Text).Append(", ");
}
Log.DebugFormat("Tabs: {0}", sb.ToString().TrimEnd(','));
}
}
}
}
/// <summary>
/// 拖拽中
/// </summary>
/// <param name="p_toolWin"></param>
/// <param name="p_pointer"></param>
internal void OnDragDelta(ToolWindow p_toolWin, PointerRoutedEventArgs p_pointer)
{
if (p_toolWin == null)
{
return;
}
if (CheckIsDockable(p_toolWin))
{
Point pos = p_pointer.GetCurrentPoint(null).Position;
UpdateCompass(pos, p_toolWin);
UpdateRootCompass(pos);
AdjustCueSize(p_toolWin);
}
else
{
_rootCompass.Visibility = Visibility.Collapsed;
}
_isDragDelta = true;
}
private static void OpenButtonClicked(object sender, ExecuteCommandEventArgs e)
{
if (Station.ActiveStation == null)
{
Logger.AddMessage("WZcalculator: There is no active station, add-in cannot be launched", LogMessageSeverity.Warning);
return;
}
// Create a toolwindow that contains the WZcalculator UserControl and add it to the enviroment.
ToolWindow toolWindow = new ToolWindow(MAIN_WINDOW_ID, new WZcalculatorToolWindow(), "WZcalculator");
toolWindow.Closed += MainWindowClosed;
toolWindow.ActiveTab = true;
toolWindow.CloseButtonBehavior = CloseButtonBehavior.Close;
UIEnvironment.Windows.AddDocked(toolWindow, System.Windows.Forms.DockStyle.Left);
// Disable the Open button
CommandBarButton.FromID(OPEN_BUTTON_ID).DefaultEnabled = false;
}
private void ButtonEditTool_Click(object sender, RoutedEventArgs e)
{
if (ToolsDataGrid.SelectedItem != null)
{
edit = true;
selRow = ToolsDataGrid.SelectedIndex;
ToolWindow toolWindow = new ToolWindow(edit, selRow);
toolWindow.ShowDialog();
clsHerramientas obj_h = new clsHerramientas();
dt_herramientas = obj_h.CargarHerramientas();
dt_herramientas.Columns[0].ColumnName = "TOOL CODE";
dt_herramientas.Columns[1].ColumnName = "DESCRIPTION";
dt_herramientas.Columns[2].ColumnName = "UNIT";
dt_herramientas.Columns[3].ColumnName = "VALUE";
ToolsDataGrid.ItemsSource = dt_herramientas.DefaultView;
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////////
// NON-PUBLIC PROCEDURES
/////////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Initializes the "Programmatic Tool Window 1" tool window.
/// </summary>
/// <param name="toolWindow">The tool window.</param>
private void InitializeProgrammaticToolWindow1(ToolWindow toolWindow)
{
if (toolWindow == null)
{
throw new ArgumentNullException("toolWindow");
}
// Create the tool window content
var textBox = new TextBox()
{
BorderThickness = new Thickness(),
IsReadOnly = true,
Text = "This ToolWindow was programmatically created in the code-behind.",
TextWrapping = TextWrapping.Wrap
};
toolWindow.Name = "programmaticToolWindow1";
toolWindow.Title = "Programmatic ToolWindow 1";
toolWindow.ImageSource = new BitmapImage(new Uri("/Images/Icons/Properties16.png", UriKind.Relative));
toolWindow.Content = textBox;
}
private void OnToolInsertItemClicked(object sender, EventArgs e)
{
if (((MenuItem)sender).Tag is DBColumn column)
{
var editor = new TableEditor();
editor.Initialize(column.ReferenceTable.CreateItemsView("", DBViewKeys.None, DBStatus.Actual | DBStatus.Edit | DBStatus.New | DBStatus.Error), null, column, TableEditorMode.Reference, false);
editor.ItemSelect += OnRowSelected;
var cont = new ToolWindow
{
Target = editor,
Title = column.ReferenceTable.ToString()
};
//cont.Closing += new ToolStripDropDownClosingEventHandler(cont_Closing);
((MenuItem)sender).Tag = cont;
//((ToolStripDropDownButton)e.ClickedItem).DropDown = e.ClickedItem.Tag as ToolForm;
//((ToolStripDropDownButton)e.ClickedItem).ShowDropDown();
}
_currentControl = ((MenuItem)sender).Tag as ToolWindow;
// _currentControl.Show();//sender as Control, new Point(toolStrip1.Left, toolStrip1.Height));
}
protected override bool Execute(object parameter)
{
ErrorHandler(() =>
{
var selSchema = new SelectSchema();
selSchema.ExecutableNames = from schema in _pageMgr.SchemaManager.GuiSchemas
from exec in schema.ToolConfig.Executables
select new GuiSchemaInfo {
ExecutableName = exec.Name, SchemaFilePath = schema.SchemaFilePath, ScreenName = exec.Gui.Name
};
var window = ToolWindow.Create(selSchema, "Select a Schema");
var result = window.ShowDialog();
if (result.HasValue && result.Value)
{
if (selSchema.IsNewSchema)
{
int index = _pageMgr.NewAll(selSchema.SchemaPath);
_pageMgr.ActiveDocument = _pageMgr.Documents[index];
}
else
{
var selected = (from schema in _pageMgr.SchemaManager.GuiSchemas
where schema.SchemaFilePath == selSchema.Selected.SchemaFilePath
from exec in schema.ToolConfig.Executables
where exec.Name == selSchema.Selected.ExecutableName
where exec.Gui.Name == selSchema.Selected.ScreenName
select new { Schema = schema, Executable = exec }).FirstOrDefault();
_pageMgr.ActiveDocument = _pageMgr.AddDocument(selected.Schema, selected.Executable);
}
}
});
return(base.Execute(parameter));
}
/// <summary>
/// 构造ToolWindow承载Tab，结构 ToolWindow -> Pane -> Tabs -> Tab
/// </summary>
/// <param name="p_tab"></param>
/// <returns></returns>
ToolWindow OpenInWindow(Tab p_tab)
{
Point initPos = new Point();
Size initSize = _defaultFloatSize;
ToolWindow oldWin = GetParentWindow(p_tab);
if (oldWin != null)
{
initPos = new Point(oldWin.HorizontalOffset, oldWin.VerticalOffset);
initSize = new Size(oldWin.Width, oldWin.Height);
}
else
{
Pane oldContainer = null;
if (p_tab.OwnTabs != null)
{
oldContainer = p_tab.OwnTabs.Parent as Pane;
}
if (oldContainer != null)
{
initPos = oldContainer.FloatLocation;
initSize = oldContainer.FloatSize;
}
}
p_tab.RemoveFromParent();
ToolWindow win = CreateWindow(initSize, initPos);
Pane dockItem = new Pane();
dockItem.Pos = PanePosition.Floating;
Tabs sect = new Tabs();
sect.Items.Add(p_tab);
dockItem.Items.Add(sect);
win.Content = dockItem;
win.Show();
return(win);
}
/// <summary>
/// 构造ToolWindow承载Tabs，直接将Tabs移动到新Pane
/// </summary>
/// <param name="p_tabs"></param>
/// <returns></returns>
ToolWindow OpenInWindow(Tabs p_tabs)
{
Point initPos = new Point();
Size initSize = _defaultFloatSize;
ToolWindow oldWin = GetParentWindow(p_tabs);
if (oldWin != null)
{
initPos = new Point(oldWin.HorizontalOffset, oldWin.VerticalOffset);
initSize = new Size(oldWin.Width, oldWin.Height);
}
ToolWindow win = CreateWindow(initSize, initPos);
Pane dockItem = new Pane();
dockItem.Pos = PanePosition.Floating;
p_tabs.RemoveFromParent();
dockItem.Items.Add(p_tabs);
win.Content = dockItem;
win.Show();
return(win);
}
public async void ViewDocumentsAsync(List <Document> documents)
{
if (documents.Count == 1)
{
ShowDocument(documents[0]);
}
else if (documents.Count > 1)
{
var list = new DBTableView <Document>((QParam)null, DBViewKeys.Static | DBViewKeys.Empty)
{
ItemType = documents[0].GetType()
};
list.AddRange(documents);
var dlist = new ListEditor {
DataSource = list
};
using (var form = new ToolWindow
{
Title = "New Documents",
Mode = ToolShowMode.Dialog,
Size = new Size(800, 600),
Target = dlist
})
{
var command = await form.ShowAsync(this, new Point(1, 1));
if (command == Command.Ok)
{
foreach (Document document in documents)
{
await document.Save();
}
}
}
}
}
public ToolWindow GetDockingWindow(Type panelType)
{
if (!(typeof(ToolWindow).IsAssignableFrom(panelType)))
{
throw new ArgumentException("Not type of ToolWindow");
}
ToolWindow window;
_registeredDockingWindows.TryGetValue(panelType, out window);
if (window != null)
{
return(window);
}
ToolWindow newWindow = (ToolWindow)Activator.CreateInstance(panelType);
_registeredDockingWindows.Remove(panelType);
_registeredDockingWindows.Add(panelType, newWindow);
return(newWindow);
}
/// <summary>
/// Create a simple tool window.
/// </summary>
/// <param name="layoutKey">The layout <see cref="LayoutKey"/> key</param>
/// <param name="name">Window name.</param>
/// <param name="title">The title. May not contain spaces.</param>
/// <param name="content">The window content.</param>
/// <param name="canClose">Nullable bool.</param>
/// <returns>A new tool window.</returns>
public ToolWindow CreateToolWindow(string layoutKey, string name, string title, object content, bool?canClose)
{
ParameterNullCheck(layoutKey);
if (name.Contains(" "))
{
throw new ArgumentException(string.Format("Parameter {0} may not contain space(s)", name));
}
var tool = new ToolWindow(_dockSite)
{
Name = name,
Title = title,
Content = content,
CanClose = canClose
};
ToolItems.Add(tool);
OpenDockingWindow(tool);
return(tool);
}
private void ToolInsertTemplateClick(object sender, EventArgs e)
{
var list = new SelectableList <TemplateData>(Document.Template.GetReferencing <TemplateData>(nameof(TemplateData.TemplateId), DBLoadParam.None));
var listView = new LayoutList {
ListSource = list
};
var window = new ToolWindow {
Target = listView
};
window.ButtonAcceptClick += (s, a) =>
{
if (listView.SelectedItem == null)
{
return;
}
var data = Document.GenerateFromTemplate <T>((TemplateData)listView.SelectedItem);
data.Attach();
Current = data;
ToolTemplateClick(s, a);
};
window.Show(Bar, toolAdd.Bound.BottomLeft);
}
public void SetCurrentTab(ToolWindow window)
{
// If we aren't using Ctrl-Tab to move between panels,
// i.e. we got here because the operator clicked on the
// panel directly, then record it as the current panel.
if (!IsSwitchingTabs && window != null)
{
if (this.docs.Contains(window))
{
this.docs.Remove(window);
this.docs.Insert(0, window);
if (Log.IsDebugEnabled)
{
StringBuilder sb = new StringBuilder();
foreach (IDockContent doc in docs)
{
sb.Append(((ToolWindow)doc).Text).Append(", ");
}
Log.DebugFormat("Tabs: {0}", sb.ToString().TrimEnd(','));
}
}
}
}
private void ABInit()
{
tmpLayout_ABBuildInfoPath = EditorEnv.frameworkPath.CombinePath("AssetBundle/Editor/ABBLayout.xml");
LoadCollectInfo();
if (string.IsNullOrEmpty(tmpLayout_ABBuildInfo))
{
if (File.Exists(tmpLayout_ABBuildInfoPath))
{
tmpLayout_ABBuildInfo = File.ReadAllText(tmpLayout_ABBuildInfoPath);
}
}
if (toolWindow == null)
{
toolWindow = new ToolWindow(this);
}
if (dirCollectWindow == null)
{
dirCollectWindow = new DirCollectWindow(this);
}
if (abBulidWindow == null)
{
abBulidWindow = new AssetBundleBulidWindow(this, tmpLayout_ABBuildInfo);
}
}
public void SetCurrentTab(ToolWindow window)
{
if (window != null)
{
if (this.docs.Contains(window))
{
this.docs.Remove(window);
this.docs.Insert(0, window);
if (Log.IsDebugEnabled)
{
StringBuilder sb = new StringBuilder();
foreach (IDockContent doc in docs)
{
sb.Append(((ToolWindow)doc).Text).Append(", ");
}
Log.DebugFormat("Tabs: {0}", sb.ToString().TrimEnd(','));
}
}
}
}
void AddDocument(ToolWindow tab)
{
this.TabSwitchStrategy.AddTab(tab);
tab.FormClosed += window_FormClosed;
}
public Object Execute(Type typePresenter, ToolWindow window)
{
//Excute y segun el tipo del presenter enviado muestra el view
//Console.WriteLine("............ "+typePresenter.Name);
switch (typePresenter.Name)
{
#region Execute - IQ
case "MoverProductoPresenter":
MoverProductoPresenter MoverProducto = container.Resolve<MoverProductoPresenter>();
MoverProducto.Window = window;
return MoverProducto.View;
case "EntradaAlmacenPresenter":
EntradaAlmacenPresenter EntradaAlmacen = container.Resolve<EntradaAlmacenPresenter>();
EntradaAlmacen.Window = window;
return EntradaAlmacen.View;
case "EntradaAlmacenV2Presenter":
EntradaAlmacenV2Presenter EntradaAlmacenV2 = container.Resolve<EntradaAlmacenV2Presenter>();
EntradaAlmacenV2.Window = window;
return EntradaAlmacenV2.View;
////////// 18 DE FEBRERO DE 2015 /////////////
case "ConfirmacionIntermediaPresenter":
ConfirmacionIntermediaPresenter ConfirmacionIntermedia = container.Resolve<ConfirmacionIntermediaPresenter>();
ConfirmacionIntermedia.Window = window;
return ConfirmacionIntermedia.View;
////////// 18 DE FEBRERO DE 2015 /////////////
////////// 23 DE FEBRERO DE 2015 /////////////
case "ConfirmacionIntermediaPresenterP":
ConfirmacionIntermediaPresenterP ConfirmacionIntermediaP = container.Resolve<ConfirmacionIntermediaPresenterP>();
ConfirmacionIntermediaP.Window = window;
return ConfirmacionIntermediaP.View;
////////// 23 DE FEBRERO DE 2015 /////////////
////////// 23 DE FEBRERO DE 2015 /////////////
case "ActualizacionRRPresenter":
ActualizacionRRPresenter ActualizacionRRPresenter = container.Resolve<ActualizacionRRPresenter>();
ActualizacionRRPresenter.Window = window;
return ActualizacionRRPresenter.View;
////////// 23 DE FEBRERO DE 2015 /////////////
////////// 25 DE MAYO DE 2015 /////////////
case "NovedadesPresenter":
NovedadesPresenter NovedadesPresenterP = container.Resolve<NovedadesPresenter>();
NovedadesPresenterP.Window = window;
return NovedadesPresenterP.View;
////////// 23 DE MAYO DE 2015 /////////////
case "ReciboPresenter":
ReciboPresenter Recibo = container.Resolve<ReciboPresenter>();
Recibo.Window = window;
return Recibo.View;
case "AdministradorPresenter":
AdministradorPresenter Administrador = container.Resolve<AdministradorPresenter>();
Administrador.Window = window;
return Administrador.View;
case "AdministradorDTVPresenter":
AdministradorDTVPresenter AdministradorDTV = container.Resolve<AdministradorDTVPresenter>();
AdministradorDTV.Window = window;
return AdministradorDTV.View;
case "AlmacenamientoPresenter":
AlmacenamientoPresenter Almacenamiento = container.Resolve<AlmacenamientoPresenter>();
Almacenamiento.Window = window;
return Almacenamiento.View;
case "MoverMercanciaDTVPresenter":
MoverMercanciaDTVPresenter MoverMercanciaDTV = container.Resolve<MoverMercanciaDTVPresenter>();
MoverMercanciaDTV.Window = window;
return MoverMercanciaDTV.View;
case "DespachoDTVPresenter":
DespachoDTVPresenter DespachoDTV = container.Resolve<DespachoDTVPresenter>();
DespachoDTV.Window = window;
return DespachoDTV.View;
case "DiagnosticoDTVPresenter":
DiagnosticoDTVPresenter DiagnosticoDTV = container.Resolve<DiagnosticoDTVPresenter>();
DiagnosticoDTV.Window = window;
return DiagnosticoDTV.View;
case "ReparacionesDTVPresenter":
ReparacionesDTVPresenter ReparacionesDTV = container.Resolve<ReparacionesDTVPresenter>();
ReparacionesDTV.Window = window;
return ReparacionesDTV.View;
case "EtiquetadosDTVPresenter":
EtiquetadosDTVPresenter EtiquetadosDTV = container.Resolve<EtiquetadosDTVPresenter>();
EtiquetadosDTV.Window = window;
return EtiquetadosDTV.View;
case "VerificacionDTVPresenter":
VerificacionDTVPresenter VerificacionDTV = container.Resolve<VerificacionDTVPresenter>();
VerificacionDTV.Window = window;
return VerificacionDTV.View;
case "EmpaqueDTVPresenter":
EmpaqueDTVPresenter EmpaqueDTV = container.Resolve<EmpaqueDTVPresenter>();
EmpaqueDTV.Window = window;
return EmpaqueDTV.View;
/////////////////////////////////////////////////////////////////////////////////////
case "SmartCardDTVPresenterP":
SmartCardDTVPresenterP SmartCardDTVpp = container.Resolve<SmartCardDTVPresenterP>();
SmartCardDTVpp.Window = window;
return SmartCardDTVpp.View;
//////////////////////////////////////////////////////////////////////////////////////
case "GeneradorEstibasPresenter":
GeneradorEstibasPresenter GeneradorEstibas = container.Resolve<GeneradorEstibasPresenter>();
GeneradorEstibas.Window = window;
return GeneradorEstibas.View;
case "BodegasPresenter":
BodegasPresenter Bodegas = container.Resolve<BodegasPresenter>();
Bodegas.Window = window;
return Bodegas.View;
case "MoverMercanciaPresenter":
MoverMercanciaPresenter MoverMercancia = container.Resolve<MoverMercanciaPresenter>();
MoverMercancia.Window = window;
return MoverMercancia.View;
//case "ConfirmarReciboPresenter":
// ConfirmarReciboPresenter ConfirmarRecibo = container.Resolve<ConfirmarReciboPresenter>();
// ConfirmarRecibo.Window = window;
// return ConfirmarRecibo.View;
case "NoProcesablesPresenter":
NoProcesablesPresenter NoProcesables = container.Resolve<NoProcesablesPresenter>();
NoProcesables.Window = window;
return NoProcesables.View;
case "DiagnosticoPresenter":
DiagnosticoPresenter Diagnostico = container.Resolve<DiagnosticoPresenter>();
Diagnostico.Window = window;
return Diagnostico.View;
case "EnsamblePresenter":
EnsamblePresenter Ensamble = container.Resolve<EnsamblePresenter>();
Ensamble.Window = window;
return Ensamble.View;
case "EtiquetadosPresenter":
EtiquetadosPresenter Etiquetados = container.Resolve<EtiquetadosPresenter>();
Etiquetados.Window = window;
return Etiquetados.View;
case "VerificacionPresenter":
VerificacionPresenter Verificacion = container.Resolve<VerificacionPresenter>();
Verificacion.Window = window;
return Verificacion.View;
case "ReparacionesPresenter":
ReparacionesPresenter Reparaciones = container.Resolve<ReparacionesPresenter>();
Reparaciones.Window = window;
return Reparaciones.View;
case "EmpaquePresenter":
EmpaquePresenter Empaque = container.Resolve<EmpaquePresenter>();
Empaque.Window = window;
return Empaque.View;
case "DespachoPresenter":
DespachoPresenter Despacho = container.Resolve<DespachoPresenter>();
Despacho.Window = window;
return Despacho.View;
case "DataInformationPresenter":
DataInformationPresenter DataInformation = container.Resolve<DataInformationPresenter>();
DataInformation.Window = window;
return DataInformation.View;
case "DespachosPresenter":
DespachosPresenter Despachos = container.Resolve<DespachosPresenter>();
Despachos.Window = window;
return Despachos.View;
case "AdminInformationPresenter":
AdminInformationPresenter AdminInformation = container.Resolve<AdminInformationPresenter>();
AdminInformation.Window = window;
return AdminInformation.View;
case "ImpresionEtiquetasPresenter":
ImpresionEtiquetasPresenter ImpresionEtiquetas = container.Resolve<ImpresionEtiquetasPresenter>();
ImpresionEtiquetas.Window = window;
return ImpresionEtiquetas.View;
case "AdminInformationConsultaPresenter":
AdminInformationConsultaPresenter AdminInformationConsulta = container.Resolve<AdminInformationConsultaPresenter>();
AdminInformationConsulta.Window = window;
return AdminInformationConsulta.View;
case "ValidadorSerialesPresenter":
ValidadorSerialesPresenter ValidadorSerialesConsulta = container.Resolve<ValidadorSerialesPresenter>();
ValidadorSerialesConsulta.Window = window;
return ValidadorSerialesConsulta.View;
#endregion
case "OrderMngrV2Presenter":
OrderMngrV2Presenter presenOM = container.Resolve<OrderMngrV2Presenter>();
presenOM.Window = window;
return presenOM.View;
case "BookingMngrPresenter":
BookingMngrPresenter presenterb = container.Resolve<BookingMngrPresenter>();
presenterb.Window = window;
return presenterb.View;
case "ShipRoutePresenter":
ShipRoutePresenter presenter31 = container.Resolve<ShipRoutePresenter>();
presenter31.Window = window;
return presenter31.View;
case "DocumentManagerPresenter":
DocumentManagerPresenter presenter30 = container.Resolve<DocumentManagerPresenter>();
presenter30.Window = window;
return presenter30.View;
case "SchedulePresenter":
ISchedulePresenter presenter29y = container.Resolve<SchedulePresenter>();
presenter29y.Window = window;
return presenter29y.View;
case "ProductCategoryPresenter":
IProductCategoryPresenter presenter29c = container.Resolve<ProductCategoryPresenter>();
presenter29c.Window = window;
return presenter29c.View;
case "InventoryCountPresenter":
IInventoryCountPresenter presenter29 = container.Resolve<InventoryCountPresenter>();
presenter29.Window = window;
return presenter29.View;
case "QueriesPresenter":
IQueriesPresenter presenter = container.Resolve<QueriesPresenter>();
presenter.Window = window;
return presenter.View;
case "ReceivingPresenter":
IReceivingPresenter presenter1 = container.Resolve<ReceivingPresenter>();
presenter1.Window = window;
return presenter1.View;
case "ChangeLocationPresenter":
IChangeLocationPresenter presenter2 = container.Resolve<ChangeLocationPresenter>();
presenter2.Window = window;
return presenter2.View;
case "PrintingPresenter":
IPrintingPresenter presenter3 = container.Resolve<PrintingPresenter>();
presenter3.Window = window;
return presenter3.View;
case "InventoryAdjustmentPresenter":
IInventoryAdjustmentPresenter presenter4 = container.Resolve<InventoryAdjustmentPresenter>();
presenter4.Window = window;
return presenter4.View;
case "ShippingPresenter":
IShippingPresenter presenter5 = container.Resolve<ShippingPresenter>();
presenter5.Window = window;
return presenter5.View;
case "ZoneManagerPresenter":
IZoneManagerPresenter presenter6 = container.Resolve<ZoneManagerPresenter>();
presenter6.Window = window;
return presenter6.View;
case "ShippingConsolePresenter":
IShippingConsolePresenter presenter7 = container.Resolve<ShippingConsolePresenter>();
presenter7.Window = window;
return presenter7.View;
case "IntroInventoryPresenter":
IIntroInventoryPresenter presenter8 = container.Resolve<IntroInventoryPresenter>();
presenter8.Window = window;
return presenter8.View;
case "ReceivingCubePresenter":
IReceivingCubePresenter presenter9 = container.Resolve<ReceivingCubePresenter>();
presenter9.Window = window;
return presenter9.View;
case "CrossDockPresenter":
ICrossDockPresenter presenter10 = container.Resolve<CrossDockPresenter>();
presenter10.Window = window;
presenter10.SetShowProcess(false);
presenter10.ShowProcessPanel();
return presenter10.View;
case "KitAssemblyPresenter":
IKitAssemblyPresenter presenter11 = container.Resolve<KitAssemblyPresenter>();
presenter11.Window = window;
return presenter11.View;
//Febrero 15 de 2011
case "KitAssemblyV2Presenter":
IKitAssemblyV2Presenter KitAssemblyPresenter = container.Resolve<KitAssemblyV2Presenter>();
KitAssemblyPresenter.Window = window;
return KitAssemblyPresenter.View;
case "InventoryTaskPresenter":
IInventoryTaskPresenter presenter12 = container.Resolve<InventoryTaskPresenter>();
presenter12.Window = window;
return presenter12.View;
case "BasicSetupPresenter":
IBasicSetupPresenter presenter13 = container.Resolve<BasicSetupPresenter>();
presenter13.Window = window;
return presenter13.View;
case "BasicProcessPresenter":
IBasicProcessPresenter presenter14 = container.Resolve<BasicProcessPresenter>();
presenter14.Window = window;
return presenter14.View;
case "TrackOptionPresenter":
ITrackOptionPresenter presenter15 = container.Resolve<TrackOptionPresenter>();
presenter15.Window = window;
return presenter15.View;
case "ReportPresenter":
IReportPresenter presenter16 = container.Resolve<ReportPresenter>();
presenter16.Window = window;
return presenter16.View;
case "ShipperMngrPresenter":
IShipperMngrPresenter pship = container.Resolve<ShipperMngrPresenter>();
pship.Window = window;
return pship.View;
case "FileProcessPresenter":
IFileProcessPresenter presenter16x = container.Resolve<FileProcessPresenter>();
presenter16x.Window = window;
return presenter16x.View;
#region Execute - Master
case "BinPresenter":
IBinPresenter presenter17 = container.Resolve<BinPresenter>();
presenter17.Window = window;
return presenter17.View;
case "CompanyPresenter":
ICompanyPresenter presenter18 = container.Resolve<CompanyPresenter>();
presenter18.Window = window;
return presenter18.View;
case "MetaTypePresenter":
IMetaTypePresenter MetaTypePresenter = container.Resolve<MetaTypePresenter>();
MetaTypePresenter.Window = window;
return MetaTypePresenter.View;
//case "ConnectionPresenter":
//
// IConnectionPresenter presenter = container.Resolve<ConnectionPresenter>();
// regionManager.Shell.ShowViewInShell(RegionNames.MainInformation, presenter.View, typeof(ConnectionPresenter).Name, true);
// break;
//
case "LocationPresenter":
ILocationPresenter presenter19 = container.Resolve<LocationPresenter>();
presenter19.Window = window;
return presenter19.View;
case "ProductPresenter":
IProductPresenter presenter20 = container.Resolve<ProductPresenter>();
presenter20.Window = window;
return presenter20.View;
case "AccountPresenter":
IAccountPresenter presenter20a = container.Resolve<AccountPresenter>();
presenter20a.Window = window;
return presenter20a.View;
//case "TerminalPresenter":
//
// ITerminalPresenter presenter = container.Resolve<TerminalPresenter>();
// regionManager.Shell.ShowViewInShell(RegionNames.MainInformation, presenter.View, typeof(TerminalPresenter).Name, true);
// break;
//
case "UnitPresenter":
IUnitPresenter presenter21 = container.Resolve<UnitPresenter>();
presenter21.Window = window;
return presenter21.View;
//case "UnitProductEquivalencePresenter":
//
// IUnitProductEquivalencePresenter presenter = container.Resolve<UnitProductEquivalencePresenter>();
// regionManager.Shell.ShowViewInShell(RegionNames.MainInformation, presenter.View, typeof(UnitProductEquivalencePresenter).Name, true);
// break;
//
//case "UnitProductLogisticPresenter":
//
// IUnitProductLogisticPresenter presenter = container.Resolve<UnitProductLogisticPresenter>();
// regionManager.Shell.ShowViewInShell(RegionNames.MainInformation, presenter.View, typeof(UnitProductLogisticPresenter).Name, true);
// break;
//
//case "UnitProductRelationPresenter":
//
// IUnitProductRelationPresenter presenter = container.Resolve<UnitProductRelationPresenter>();
// regionManager.Shell.ShowViewInShell(RegionNames.MainInformation, presenter.View, typeof(UnitProductRelationPresenter).Name, true);
// break;
//
//case "VehiclePresenter":
//
// IVehiclePresenter presenter = container.Resolve<VehiclePresenter>();
// regionManager.Shell.ShowViewInShell(RegionNames.MainInformation, presenter.View, typeof(VehiclePresenter).Name, true);
// break;
//
case "CustomProcessPresenter":
ICustomProcessPresenter presenter22 = container.Resolve<CustomProcessPresenter>();
presenter22.Window = window;
return presenter22.View;
case "KitPresenter":
IKitPresenter presenter22a = container.Resolve<KitPresenter>();
presenter22a.Window = window;
return presenter22a.View;
case "C_CasNumberPresenter":
IC_CasNumberPresenter ccnp = container.Resolve<C_CasNumberPresenter>();
ccnp.Window = window;
return ccnp.View;
#endregion
#region Execute - General
//case "ClassEntityPresenter":
//
// IClassEntityPresenter presenter = container.Resolve<ClassEntityPresenter>();
// regionManager.Shell.ShowViewInShell(RegionNames.MainInformation, presenter.View, typeof(ClassEntityPresenter).Name, true);
// break;
//
//case "DocumentClassPresenter":
//
// IDocumentClassPresenter presenter = container.Resolve<DocumentClassPresenter>();
// regionManager.Shell.ShowViewInShell(RegionNames.MainInformation, presenter.View, typeof(DocumentClassPresenter).Name, true);
// break;
//
//case "DocumentConceptPresenter":
//
// IDocumentConceptPresenter presenter = container.Resolve<DocumentConceptPresenter>();
// regionManager.Shell.ShowViewInShell(RegionNames.MainInformation, presenter.View, typeof(DocumentConceptPresenter).Name, true);
// break;
//
//case "DocumentTypePresenter":
//
// IDocumentTypePresenter presenter = container.Resolve<DocumentTypePresenter>();
// regionManager.Shell.ShowViewInShell(RegionNames.MainInformation, presenter.View, typeof(DocumentTypePresenter).Name, true);
// break;
//
case "DocumentTypeSequencePresenter":
IDocumentTypeSequencePresenter presenter23 = container.Resolve<DocumentTypeSequencePresenter>();
presenter23.Window = window;
return presenter23.View;
//case "GroupCriteriaPresenter":
//
// IGroupCriteriaPresenter presenter = container.Resolve<GroupCriteriaPresenter>();
// regionManager.Shell.ShowViewInShell(RegionNames.MainInformation, presenter.View, typeof(GroupCriteriaPresenter).Name, true);
// break;
//
//case "GroupCriteriaDetailPresenter":
//
// IGroupCriteriaDetailPresenter presenter = container.Resolve<GroupCriteriaDetailPresenter>();
// regionManager.Shell.ShowViewInShell(RegionNames.MainInformation, presenter.View, typeof(GroupCriteriaDetailPresenter).Name, true);
// break;
//
//case "GroupCriteriaRelationPresenter":
//
// IGroupCriteriaRelationPresenter presenter = container.Resolve<GroupCriteriaRelationPresenter>();
// regionManager.Shell.ShowViewInShell(RegionNames.MainInformation, presenter.View, typeof(GroupCriteriaRelationPresenter).Name, true);
// break;
//
//case "GroupCriteriaRelationDataPresenter":
//
// IGroupCriteriaRelationDataPresenter presenter = container.Resolve<GroupCriteriaRelationDataPresenter>();
// regionManager.Shell.ShowViewInShell(RegionNames.MainInformation, presenter.View, typeof(GroupCriteriaRelationDataPresenter).Name, true);
// break;
//
//case "LabelMappingPresenter":
//
// ILabelMappingPresenter presenter = container.Resolve<LabelMappingPresenter>();
// regionManager.Shell.ShowViewInShell(RegionNames.MainInformation, presenter.View, typeof(LabelMappingPresenter).Name, true);
// break;
//
//case "LabelTemplatePresenter":
//
// ILabelTemplatePresenter presenter = container.Resolve<LabelTemplatePresenter>();
// regionManager.Shell.ShowViewInShell(RegionNames.MainInformation, presenter.View, typeof(LabelTemplatePresenter).Name, true);
// break;
//
//case "MeasureTypePresenter":
//
// IMeasureTypePresenter presenter = container.Resolve<MeasureTypePresenter>();
// regionManager.Shell.ShowViewInShell(RegionNames.MainInformation, presenter.View, typeof(MeasureTypePresenter).Name, true);
// break;
//
//case "MeasureUnitPresenter":
//
// IMeasureUnitPresenter presenter = container.Resolve<MeasureUnitPresenter>();
// regionManager.Shell.ShowViewInShell(RegionNames.MainInformation, presenter.View, typeof(MeasureUnitPresenter).Name, true);
// break;
//
//case "MeasureUnitConvertionPresenter":
//
// IMeasureUnitConvertionPresenter presenter = container.Resolve<MeasureUnitConvertionPresenter>();
// regionManager.Shell.ShowViewInShell(RegionNames.MainInformation, presenter.View, typeof(MeasureUnitConvertionPresenter).Name, true);
// break;
//
//case "StatusPresenter":
//
// IStatusPresenter presenter = container.Resolve<StatusPresenter>();
// regionManager.Shell.ShowViewInShell(RegionNames.MainInformation, presenter.View, typeof(StatusPresenter).Name, true);
// break;
//
//case "StatusTypePresenter":
//
// IStatusTypePresenter presenter = container.Resolve<StatusTypePresenter>();
// regionManager.Shell.ShowViewInShell(RegionNames.MainInformation, presenter.View, typeof(StatusTypePresenter).Name, true);
// break;
//
#endregion
#region Execute Profile
case "ConfigOptionPresenter":
IConfigOptionPresenter presenter24 = container.Resolve<ConfigOptionPresenter>();
presenter24.Window = window;
return presenter24.View;
//case "ConfigTypePresenter":
//
// IConfigTypePresenter presenter = container.Resolve<ConfigTypePresenter>();
// regionManager.Shell.ShowViewInShell(RegionNames.MainInformation, presenter.View, typeof(ConfigTypePresenter).Name, true);
// break;
//
case "MenuOptionPresenter":
IMenuOptionPresenter presenter25 = container.Resolve<MenuOptionPresenter>();
presenter25.Window = window;
return presenter25.View;
//case "MenuOptionByRolPresenter":
//
// IMenuOptionByRolPresenter presenter = container.Resolve<MenuOptionByRolPresenter>();
// regionManager.Shell.ShowViewInShell(RegionNames.MainInformation, presenter.View, typeof(MenuOptionByRolPresenter).Name, true);
// break;
//
//case "MenuOptionTypePresenter":
//
// IMenuOptionTypePresenter presenter = container.Resolve<MenuOptionTypePresenter>();
// regionManager.Shell.ShowViewInShell(RegionNames.MainInformation, presenter.View, typeof(MenuOptionTypePresenter).Name, true);
// break;
//
case "RolPresenter":
IRolPresenter presenter26 = container.Resolve<RolPresenter>();
presenter26.Window = window;
return presenter26.View;
case "SysUserPresenter":
ISysUserPresenter presenter27 = container.Resolve<SysUserPresenter>();
presenter27.Window = window;
return presenter27.View;
case "IqToolPresenter":
IIqToolPresenter presenter28 = container.Resolve<IqToolPresenter>();
presenter28.Window = window;
return presenter28.View;
}
#endregion
#region Execute Trace
//if (typePresenter == typeof(DocumentPresenter))
//{
// IDocumentPresenter presenter = container.Resolve<DocumentPresenter>();
// regionManager.Shell.ShowViewInShell(RegionNames.MainInformation, presenter.View, typeof(DocumentPresenter).Name, true);
// return;
//}
//if (typePresenter == typeof(DocumentAddressPresenter))
//{
// IDocumentAddressPresenter presenter = container.Resolve<DocumentAddressPresenter>();
// regionManager.Shell.ShowViewInShell(RegionNames.MainInformation, presenter.View, typeof(DocumentAddressPresenter).Name, true);
// return;
//}
//if (typePresenter == typeof(DocumentLinePresenter))
//{
// IDocumentLinePresenter presenter = container.Resolve<DocumentLinePresenter>();
// regionManager.Shell.ShowViewInShell(RegionNames.MainInformation, presenter.View, typeof(DocumentLinePresenter).Name, true);
// return;
//}
//if (typePresenter == typeof(LabelPresenter))
//{
// ILabelPresenter presenter = container.Resolve<LabelPresenter>();
// regionManager.Shell.ShowViewInShell(RegionNames.MainInformation, presenter.View, typeof(LabelPresenter).Name, true);
// return;
//}
//if (typePresenter == typeof(NodePresenter))
//{
// INodePresenter presenter = container.Resolve<NodePresenter>();
// regionManager.Shell.ShowViewInShell(RegionNames.MainInformation, presenter.View, typeof(NodePresenter).Name, true);
// return;
//}
//if (typePresenter == typeof(NodeDocumentTypePresenter))
//{
// INodeDocumentTypePresenter presenter = container.Resolve<NodeDocumentTypePresenter>();
// regionManager.Shell.ShowViewInShell(RegionNames.MainInformation, presenter.View, typeof(NodeDocumentTypePresenter).Name, true);
// return;
//}
//if (typePresenter == typeof(NodeExtensionPresenter))
//{
// INodeExtensionPresenter presenter = container.Resolve<NodeExtensionPresenter>();
// regionManager.Shell.ShowViewInShell(RegionNames.MainInformation, presenter.View, typeof(NodeExtensionPresenter).Name, true);
// return;
//}
//if (typePresenter == typeof(NodeExtensionTracePresenter))
//{
// INodeExtensionTracePresenter presenter = container.Resolve<NodeExtensionTracePresenter>();
// regionManager.Shell.ShowViewInShell(RegionNames.MainInformation, presenter.View, typeof(NodeExtensionTracePresenter).Name, true);
// return;
//}
//if (typePresenter == typeof(NodeRoutePresenter))
//{
// INodeRoutePresenter presenter = container.Resolve<NodeRoutePresenter>();
// regionManager.Shell.ShowViewInShell(RegionNames.MainInformation, presenter.View, typeof(NodeRoutePresenter).Name, true);
// return;
//}
//if (typePresenter == typeof(TaskDocumentRelationPresenter))
//{
// ITaskDocumentRelationPresenter presenter = container.Resolve<TaskDocumentRelationPresenter>();
// regionManager.Shell.ShowViewInShell(RegionNames.MainInformation, presenter.View, typeof(TaskDocumentRelationPresenter).Name, true);
// return;
//}
//if (typePresenter == typeof(TaskByUserPresenter))
//{
// ITaskByUserPresenter presenter = container.Resolve<TaskByUserPresenter>();
// regionManager.Shell.ShowViewInShell(RegionNames.MainInformation, presenter.View, typeof(TaskByUserPresenter).Name, true);
// return;
//}
return null;
#endregion
}
public void RemoveTab(ToolWindow oldTab)
{
this.docs.Remove(oldTab);
}
private static void SelectEnvAndExt(ToolWindow envs, IPythonInterpreterFactory interpreter, Type extension, int retries) {
if (retries <= 0) {
Debug.Fail("Failed to select environment/extension after multiple retries");
return;
}
var select = envs.IsLoaded ? envs.Environments.OfType<EnvironmentView>().FirstOrDefault(e => e.Factory == interpreter) : null;
if (select == null) {
envs.Dispatcher.InvokeAsync(() => SelectEnvAndExt(envs, interpreter, extension, retries - 1), DispatcherPriority.Background);
return;
}
var ext = select?.Extensions.FirstOrDefault(e => e != null && extension.IsEquivalentTo(e.GetType()));
envs.Environments.MoveCurrentTo(select);
if (ext != null) {
var exts = envs.Extensions;
if (exts != null && exts.Contains(ext)) {
exts.MoveCurrentTo(ext);
((ext as IEnvironmentViewExtension)?.WpfObject as ICanFocus)?.Focus();
}
}
}
void IComponentConnector.Connect(int connectionId, object target)
{
switch (connectionId)
{
case 1:
button_0 = (ActiproSoftware.Windows.Controls.Ribbon.Controls.Button)target;
button_0.Click += new EventHandler<ExecuteRoutedEventArgs>(method9);
break;
case 2:
((ActiproSoftware.Windows.Controls.Ribbon.Controls.Button)target).Click += new EventHandler<ExecuteRoutedEventArgs>(buttonOpen_Click);
break;
case 3:
((ActiproSoftware.Windows.Controls.Ribbon.Controls.Button)target).Click += new EventHandler<ExecuteRoutedEventArgs>(buttonSave_Click);
break;
case 4:
((ActiproSoftware.Windows.Controls.Ribbon.Controls.Button)target).Click += new EventHandler<ExecuteRoutedEventArgs>(buttonReanalyze_Click);
break;
case 5:
((ActiproSoftware.Windows.Controls.Ribbon.Controls.Button)target).Click += new EventHandler<ExecuteRoutedEventArgs>(buttonWheel_Click);
break;
case 6:
this.group_0 = (Group)target;
break;
case 7:
((ActiproSoftware.Windows.Controls.Ribbon.Controls.Button)target).Click += new EventHandler<ExecuteRoutedEventArgs>(method2);
break;
case 8:
this.dockSite = (DockSite)target;
break;
case 9:
this.toolWindow = (ToolWindow)target;
break;
case 10:
this.noScrollTreeView = (NoScrollTreeView)target;
break;
case 11:
this.toolWindow1 = (ToolWindow)target;
break;
case 12:
this.toolWindow2 = (ToolWindow)target;
break;
case 13:
this.toolWindow3 = (ToolWindow)target;
break;
case 14:
((System.Windows.Controls.Button)target).Click += button0_Click;
break;
case 15:
((System.Windows.Controls.Button)target).Click += button1_Click;
break;
case 16:
((System.Windows.Controls.Button)target).Click += button2_Click;
break;
case 17:
((System.Windows.Controls.Button)target).Click += button3_Click;
break;
case 18:
((System.Windows.Controls.Button)target).Click += button4_Click;
break;
default:
this._isInitialized = true;
break;
}
}
public void Display(ToolWindow tw)
{
rda.DisplayWindow(tw);
}
void IComponentConnector.Connect(int connectionId, object target)
{
switch (connectionId)
{
case 1:
this.button_0 = (ActiproSoftware.Windows.Controls.Ribbon.Controls.Button)target;
this.button_0.Click += new EventHandler<ExecuteRoutedEventArgs>(this.method_9);
break;
case 2:
((ActiproSoftware.Windows.Controls.Ribbon.Controls.Button)target).Click += new EventHandler<ExecuteRoutedEventArgs>(this.method_11);
break;
case 3:
((ActiproSoftware.Windows.Controls.Ribbon.Controls.Button)target).Click += new EventHandler<ExecuteRoutedEventArgs>(this.method_12);
break;
case 4:
((ActiproSoftware.Windows.Controls.Ribbon.Controls.Button)target).Click += new EventHandler<ExecuteRoutedEventArgs>(this.method_13);
break;
case 5:
((ActiproSoftware.Windows.Controls.Ribbon.Controls.Button)target).Click += new EventHandler<ExecuteRoutedEventArgs>(this.method_15);
break;
case 6:
this.group_0 = (Group)target;
break;
case 7:
((ActiproSoftware.Windows.Controls.Ribbon.Controls.Button)target).Click += new EventHandler<ExecuteRoutedEventArgs>(this.method_2);
break;
case 8:
this.dockSite_0 = (DockSite)target;
break;
case 9:
this.toolWindow_0 = (ToolWindow)target;
break;
case 10:
this.noScrollTreeView_0 = (NoScrollTreeView)target;
break;
case 11:
this.toolWindow_1 = (ToolWindow)target;
break;
case 12:
this.toolWindow_2 = (ToolWindow)target;
break;
case 13:
this.toolWindow_3 = (ToolWindow)target;
break;
case 14:
((System.Windows.Controls.Button)target).Click += new RoutedEventHandler(this.method_4);
break;
case 15:
((System.Windows.Controls.Button)target).Click += new RoutedEventHandler(this.method_5);
break;
case 16:
((System.Windows.Controls.Button)target).Click += new RoutedEventHandler(this.method_8);
break;
case 17:
((System.Windows.Controls.Button)target).Click += new RoutedEventHandler(this.method_6);
break;
case 18:
((System.Windows.Controls.Button)target).Click += new RoutedEventHandler(this.method_7);
break;
default:
this.bool_1 = true;
break;
}
}
public Workbench()
{
InitializeComponent();
// Initialize the Colordialog
radColorDialog1.Icon = Icon;
(radColorDialog1.ColorDialogForm as RadColorDialogForm).ThemeName = ThemeName;
radColorDialog1.ColorDialogForm.AllowColorPickFromScreen = false;
ThemeResolutionService.ApplicationThemeName = ThemeName;
openFileDialog1.Filter = Utils.GetFileFilter("/Workspace/FileFilter");
saveFileDialog1.Filter = Utils.GetFileFilter("/Workspace/FileFilter");
AddInTree.Doozers.Add("Tool", new ToolDoozer());
AddInTree.Doozers.Add("Window", new WindowDoozer());
// Add Tools to ToolBox
foreach (var tool in AddInTree.BuildItems<Tool>("/Workspace/Tools", this, false))
{
var ib = new ImageButton();
ib.ToolTipText = tool.ToolTipText;
ib.Image = ib.Image;
ib.Click += (s, e) => tool.Command.Run();
toolsLayout.Controls.Add(ib);
}
foreach (var window in AddInTree.BuildItems<Window>("/Workspace/Windows", this, false))
{
var w = new ToolWindow(window.Title);
window.ContainerControl.Dock = DockStyle.Fill;
w.Controls.Add(window.ContainerControl);
dock.DockWindow(w, (DockPosition)Enum.Parse(typeof(DockPosition), window.DockPosition));
}
//var menu = new MenuStrip();
//MenuService.AddItemsToMenu(menu.Items, this, "/Workbench/MainMenu");
//Controls.Add(menu);
/*pictureBox1.MouseClick += (s, e) =>
{
var qm = new QuickMouseMenu();
qm.AddQuickMouseMenuItem(Resources.GIMP_Toolbox_GEGLOperationTool_Icon, "GEGL");
qm.AddQuickMouseMenuItem(Resources.GIMP_Toolbox_MeasureTool_Icon, "GEGL");
qm.AddQuickMouseMenuItem(Resources.GIMP_Toolbox_SelectionForeground_Icon, "GEGL");
qm.AddQuickMouseMenuItem(Resources.GIMP_Toolbox_TransformShear_Icon, "GEGL");
qm.AddQuickMouseMenuItem(Resources.GIMP_Toolbox_TransformMove_Icon, "GEGL");
qm.AddQuickMouseMenuItem(Resources.GIMP_Toolbox_TextTool_Icon, "GEGL");
qm.QuickMenuItemClicked += (se, ee) =>
{
MessageBox.Show(((QuickMouseMenuItem)se).Caption);
};
qm.ShowMenu(e.Location);
};
*/
}
private void CreateToolWindow(string title, string name, object content, bool canClose = false)
{
var wnd = new ToolWindow(DockSite)
{
Name = name,
Title = title,
Content = content,
CanClose = canClose
};
ToolItems.Add(wnd);
OpenDockingWindow(wnd);
//return wnd;
}
/// <summary>
/// Create a simple tool window.
/// </summary>
/// <param name="layoutKey">The layout <see cref="LayoutKey"/> key</param>
/// <param name="name">Window name.</param>
/// <param name="title">The title. May not contain spaces.</param>
/// <param name="content">The window content.</param>
/// <param name="canClose">Nullable bool.</param>
/// <returns>A new tool window.</returns>
public ToolWindow CreateToolWindow(string layoutKey, string name, string title, object content, bool? canClose)
{
ParameterNullCheck(layoutKey);
if (name.Contains(" "))
throw new ArgumentException(string.Format("Parameter {0} may not contain space(s)", name));
var tool = new ToolWindow(_dockSite)
{
Name = name,
Title = title,
Content = content,
CanClose = canClose
};
ToolItems.Add(tool);
OpenDockingWindow(tool);
return tool;
}
public void DockToolWindowToDockSite(DockSite dockSite, ToolWindow toolWindow, Dock dock)
{
ParameterNullCheck(dockSite);
try
{
toolWindow.Dock(dockSite, dock);
}
catch (Exception e)
{
throw new InvalidOperationException("Invalid dock site.");
}
}
/// <summary>
/// Create a new <see cref="ToolWindowDiagramView"/> for the specific <see cref="ToolWindow"/>
/// </summary>
/// <remarks>The control is returned sited to the <see cref="IServiceProvider"/> of the ToolWindow</remarks>
public ToolWindowDiagramView(ToolWindow hostWindow)
{
myHostWindow = hostWindow;
base.DiagramClientView.DiagramAssociated += new EventHandler(this.OnDiagramAssociated);
base.DiagramClientView.DiagramDisassociating += new EventHandler(this.OnDiagramDisassociating);
base.DiagramClientView.ContextMenuRequested += new ContextMenuRequestedEventHandler(this.OnClientViewContextMenuRequested);
base.DiagramClientView.DragDrop += new DragEventHandler(this.OnClientViewDragDrop);
base.DiagramClientView.DragLeave += new EventHandler(this.OnClientViewDragLeave);
InPlaceTextEditor.Instance.BeginEdit += new DiagramItemEventHandler(this.OnBeginInPlaceEdit);
InPlaceTextEditor.Instance.EndEdit += new DiagramItemEventHandler(this.OnEndInPlaceEdit);
Site = new DiagramViewSite(hostWindow);
}
protected override void OnCreate()
{
base.OnCreate();
_site = (IServiceProvider)this;
_pyService = _site.GetPythonToolsService();
// TODO: Get PYEnvironment added to image list
BitmapImageMoniker = KnownMonikers.DockPanel;
Caption = Strings.Environments;
_outputWindow = OutputWindowRedirector.GetGeneral(_site);
Debug.Assert(_outputWindow != null);
_statusBar = _site.GetService(typeof(SVsStatusbar)) as IVsStatusbar;
var list = new ToolWindow();
list.Site = _site;
list.ViewCreated += List_ViewCreated;
list.CommandBindings.Add(new CommandBinding(
EnvironmentView.OpenInteractiveWindow,
OpenInteractiveWindow_Executed,
OpenInteractiveWindow_CanExecute
));
list.CommandBindings.Add(new CommandBinding(
EnvironmentView.OpenInteractiveScripts,
OpenInteractiveScripts_Executed,
OpenInteractiveScripts_CanExecute
));
list.CommandBindings.Add(new CommandBinding(
EnvironmentPathsExtension.StartInterpreter,
StartInterpreter_Executed,
StartInterpreter_CanExecute
));
list.CommandBindings.Add(new CommandBinding(
EnvironmentPathsExtension.StartWindowsInterpreter,
StartInterpreter_Executed,
StartInterpreter_CanExecute
));
list.CommandBindings.Add(new CommandBinding(
ApplicationCommands.Help,
OnlineHelp_Executed,
OnlineHelp_CanExecute
));
list.CommandBindings.Add(new CommandBinding(
ToolWindow.UnhandledException,
UnhandledException_Executed,
UnhandledException_CanExecute
));
list.CommandBindings.Add(new CommandBinding(
EnvironmentView.OpenInPowerShell,
OpenInPowerShell_Executed,
OpenInPowerShell_CanExecute
));
list.CommandBindings.Add(new CommandBinding(
EnvironmentView.OpenInCommandPrompt,
OpenInCommandPrompt_Executed,
OpenInCommandPrompt_CanExecute
));
list.CommandBindings.Add(new CommandBinding(
EnvironmentView.EnableIPythonInteractive,
EnableIPythonInteractive_Executed,
EnableIPythonInteractive_CanExecute
));
list.CommandBindings.Add(new CommandBinding(
EnvironmentView.DisableIPythonInteractive,
DisableIPythonInteractive_Executed,
DisableIPythonInteractive_CanExecute
));
list.CommandBindings.Add(new CommandBinding(
EnvironmentPathsExtension.OpenInBrowser,
OpenInBrowser_Executed,
OpenInBrowser_CanExecute
));
Content = list;
}
void RemoveDocument(ToolWindow tab)
{
this.TabSwitchStrategy.RemoveTab(tab);
}
public void AddTab(ToolWindow tab) {}
public void RemoveTab(ToolWindow tab) {}
public TabSwitcher()
{
this.Documents = this.tabSwitchStrategy.GetDocuments();
this.ActiveDocument = (ToolWindow)this.DockPanel.ActiveDocument;
if(Strategies == null)
{
List<ITabSwitchStrategy> strats = new List<ITabSwitchStrategy>
{
new VisualOrderTabSwitchStrategy(),
new OpenOrderTabSwitchStrategy(),
new MRUTabSwitchStrategy()
};
Strategies = strats.ToArray();
}
}
public void SetCurrentTab(ToolWindow window) { }
private static void SelectEnv(ToolWindow envs, IPythonInterpreterFactory interpreter, int retries) {
if (retries <= 0) {
Debug.Fail("Failed to select environment after multiple retries");
return;
}
var select = envs.IsLoaded ? envs.Environments.OfType<EnvironmentView>().FirstOrDefault(e => e.Factory == interpreter) : null;
if (select == null) {
envs.Dispatcher.InvokeAsync(() => SelectEnv(envs, interpreter, retries - 1), DispatcherPriority.Background);
return;
}
envs.Environments.MoveCurrentTo(select);
}
public void AddTab(ToolWindow newTab)
{
Log.InfoFormat("AddTab: {0}", newTab.Text);
this.docs.Add(newTab);
}
public void DockToolWindowToToolWindow(ToolWindow toolWindowParent, ToolWindow toolWindow, Direction direction)
{
ParameterNullCheck(toolWindowParent);
try
{
toolWindow.Dock(toolWindowParent, direction);
}
catch (Exception e)
{
throw new InvalidOperationException("Invalid parent tool window.");
}
}
//public static ChannelFactory<T> _channelFactory = new ChannelFactory<T>("NetTcp");
//public void ShowInSell<presenterT, IpresenterT>()
//where presenterT : Type
//{
// IpresenterT presenter = container.Resolve<presenterT>();
// regionManager.Shell.ShowViewInShell(RegionNames.MainInformation, presenter.View, typeof(presenterT).Name, true);
// return;
// var service = new ServiceT();
// bool success = false;
// try
// {
// action(service);
// service.Close();
// success = true;
// }
// finally
// {
// if (!success)
// {
// service.Abort();
// }
// }
//}
#endregion
#region IModule Members
public object ExecuteWebUrl(Type typePresenter, ToolWindow window, string WebUrl)
{
return new object();
}
