internal static LocationReport Find(TabablzControl tabablzControl)
{
if (tabablzControl == null) throw new ArgumentNullException("tabablzControl");
var locationReportBuilder = new LocationReportBuilder(tabablzControl);
foreach (var loadedInstance in Layout.GetLoadedInstances())
{
locationReportBuilder.CurrentLayout = loadedInstance;
loadedInstance.Query().Visit(
locationReportBuilder,
BranchVisitor,
TabablzControlVisitor
);
if (locationReportBuilder.IsFound)
break;
}
if (!locationReportBuilder.IsFound)
throw new LocationReportException("Instance not within any layout.");
return locationReportBuilder.ToLocationReport();
}
public BranchResult(Branch branch, TabablzControl tabablzControl)
{
if (branch == null) throw new ArgumentNullException("branch");
if (tabablzControl == null) throw new ArgumentNullException("tabablzControl");
_branch = branch;
_tabablzControl = tabablzControl;
}
internal LocationReport(TabablzControl tabablzControl, Layout rootLayout, Branch parentBranch, bool isSecondLeaf)
{
if (tabablzControl == null) throw new ArgumentNullException("tabablzControl");
if (rootLayout == null) throw new ArgumentNullException("rootLayout");
_tabablzControl = tabablzControl;
_rootLayout = rootLayout;
_parentBranch = parentBranch;
_isLeaf = _parentBranch != null;
_isSecondLeaf = isSecondLeaf;
}
public BranchAccessor(Branch branch)
{
if (branch == null) throw new ArgumentNullException("branch");
_branch = branch;
var firstChildBranch = branch.FirstItem as Branch;
if (firstChildBranch != null)
_firstItemBranchAccessor = new BranchAccessor(firstChildBranch);
else
_firstItemTabablzControl = FindTabablzControl(branch.FirstItem, branch.FirstContentPresenter);
var secondChildBranch = branch.SecondItem as Branch;
if (secondChildBranch != null)
_secondItemBranchAccessor = new BranchAccessor(secondChildBranch);
else
_secondItemTabablzControl = FindTabablzControl(branch.SecondItem, branch.SecondContentPresenter);
}
public INewTabHost <UIElement> GetNewHost(object partition, TabablzControl source)
{
var tabablzControl = new TabablzControl {
DataContext = source.DataContext
};
Clone(source, tabablzControl);
if (source.InterTabController == null)
{
throw new InvalidOperationException("Source tab does not have an InterTabCOntroller set. Ensure this is set on initial, and subsequently generated tab controls.");
}
var newInterTabController = new InterTabController
{
Partition = source.InterTabController.Partition
};
Clone(source.InterTabController, newInterTabController);
tabablzControl.SetCurrentValue(TabablzControl.InterTabControllerProperty, newInterTabController);
return(new NewTabHost <UIElement>(tabablzControl, tabablzControl));
}
private static void WindowOnClosed(object sender, EventArgs eventArgs)
{
var window = (Window)sender;
window.Closed -= WindowOnClosed;
var redundantTabs = TabablzControl.GetLoadedInstances()
.SelectMany(
tabControl =>
tabControl.Items.OfType <TabItemContainer>()
.Select(tabItemContainer => new { tabControl, tabViewModel = tabItemContainer }))
.Where(a => window.Equals(Window.GetWindow(a.tabControl)))
.ToList();
//TODO this is shoddy, but am in a rush right now. What if user kills app from task bar? or OS shut down
var remainingWindowCount = Application.Current.Windows.OfType <MainWindow>().Count();
var tabCloseReason = remainingWindowCount == 0 ? TabCloseReason.ApplicationClosed : TabCloseReason.TabClosed;
foreach (var redundantTab in redundantTabs)
{
redundantTab.tabViewModel.TabContentLifetimeHost.Cleanup(tabCloseReason);
}
}
public INewTabHost <UIElement> GetNewHost(object partition, TabablzControl source)
{
TabControlVM vm = new TabControlVM();
InterTabWindow mw = (InterTabWindow)Window.GetWindow(source);
mw.TabWindowVM.TabControlVMs.Add(vm);
var tabablzControl = new TabablzControl {
DataContext = vm
};
tabablzControl.ItemsSource = vm.TabPanelVMs;
Clone(source, tabablzControl);
var newInterTabController = new InterTabController
{
Partition = source.InterTabController.Partition
};
Clone(source.InterTabController, newInterTabController);
tabablzControl.SetCurrentValue(TabablzControl.InterTabControllerProperty, newInterTabController);
return(new NewTabHost <UIElement>(tabablzControl, tabablzControl));
}
/// <summary>
/// Restors the state of all windows
/// </summary>
/// <typeparam name="TTabModel">The type of tab model</typeparam>
/// <typeparam name="TTabViewModel">The type of tab view model to be displayed in the app.</typeparam>
/// <param name="windowInitialTabablzControl">The initial tabablz control that will be used for restore</param>
/// <param name="layoutWindowsState">The state of the windows</param>
/// <param name="viewModelFactory">The function that creates the view model based on a model</param>
public static void RestoreWindowsState <TTabModel, TTabViewModel>(TabablzControl windowInitialTabablzControl, LayoutWindowState <TTabModel>[] layoutWindowsState, Func <TTabModel, TTabViewModel> viewModelFactory)
{
if (!layoutWindowsState.Any())
{
return;
}
var mainWindowState = layoutWindowsState[0];
var mainWindow = Window.GetWindow(windowInitialTabablzControl);
if (mainWindow == null)
{
throw new InvalidOperationException("Window not found");
}
mainWindow.Width = mainWindowState.Width;
mainWindow.Height = mainWindowState.Height;
mainWindow.Left = mainWindowState.X;
mainWindow.Top = mainWindowState.Y;
mainWindow.WindowState = mainWindowState.WindowState;
RestoreBranchItemState(windowInitialTabablzControl, mainWindowState.Child, viewModelFactory);
foreach (var windowState in layoutWindowsState.Skip(1))
{
var interTabController = windowInitialTabablzControl.InterTabController;
var newHost = interTabController.InterTabClient.GetNewHost(interTabController.InterTabClient, interTabController.Partition, windowInitialTabablzControl);
newHost.Container.Width = windowState.Width;
newHost.Container.Height = windowState.Height;
newHost.Container.Left = windowState.X;
newHost.Container.Top = windowState.Y;
newHost.Container.WindowState = windowState.WindowState;
newHost.Container.Show();
RestoreBranchItemState(newHost.TabablzControl, windowState.Child, viewModelFactory);
}
}
private static IEnumerable <Tuple <Guid, TabablzControl> > BuildLayout(
TabablzControl intoTabablzControl,
LayoutStructureBranch layoutStructureBranch,
IDictionary <Guid, LayoutStructureBranch> layoutStructureBranchIndex)
{
var newSiblingTabablzControl = CreateTabablzControl();
var branchResult = Layout.Branch(intoTabablzControl, newSiblingTabablzControl, layoutStructureBranch.Orientation, false, layoutStructureBranch.Ratio);
if (layoutStructureBranch.ChildFirstBranchId.HasValue)
{
var firstChildBranch = layoutStructureBranchIndex[layoutStructureBranch.ChildFirstBranchId.Value];
foreach (var tuple in BuildLayout(intoTabablzControl, firstChildBranch, layoutStructureBranchIndex))
{
yield return(tuple);
}
}
else if (layoutStructureBranch.ChildFirstTabSetId.HasValue)
{
SetTabSetId(intoTabablzControl, layoutStructureBranch.ChildFirstTabSetId.Value);
yield return(new Tuple <Guid, TabablzControl>(layoutStructureBranch.ChildFirstTabSetId.Value, intoTabablzControl));
}
if (layoutStructureBranch.ChildSecondBranchId.HasValue)
{
var secondChildBranch = layoutStructureBranchIndex[layoutStructureBranch.ChildSecondBranchId.Value];
foreach (var tuple in BuildLayout(branchResult.TabablzControl, secondChildBranch, layoutStructureBranchIndex))
{
yield return(tuple);
}
}
else if (layoutStructureBranch.ChildSecondTabSetId.HasValue)
{
SetTabSetId(newSiblingTabablzControl, layoutStructureBranch.ChildSecondTabSetId.Value);
yield return(new Tuple <Guid, TabablzControl>(layoutStructureBranch.ChildSecondTabSetId.Value, newSiblingTabablzControl));
}
}
public INewTabHost <Window> GetNewHost(IInterTabClient interTabClient, object partition, TabablzControl source)
{
var managedWindow = _windowInstanceManager.Create();
return(new NewTabHost <Window>(managedWindow, managedWindow.InitialTabablzControl));
}
private void Branch(DropZoneLocation location, DragablzItem sourceDragablzItem)
{
if (InterLayoutClient == null)
{
throw new InvalidOperationException("InterLayoutClient is not set.");
}
var sourceOfDragItemsControl = ItemsControl.ItemsControlFromItemContainer(sourceDragablzItem) as DragablzItemsControl;
if (sourceOfDragItemsControl == null)
{
throw new ApplicationException("Unable to determin source items control.");
}
var sourceTabControl = TabablzControl.GetOwnerOfHeaderItems(sourceOfDragItemsControl);
if (sourceTabControl == null)
{
throw new ApplicationException("Unable to determin source tab control.");
}
var sourceItem = sourceOfDragItemsControl.ItemContainerGenerator.ItemFromContainer(sourceDragablzItem);
sourceTabControl.RemoveItem(sourceDragablzItem);
var branchItem = new Branch
{
Orientation = (location == DropZoneLocation.Right || location == DropZoneLocation.Left) ? Orientation.Horizontal : Orientation.Vertical
};
object newContent;
if (BranchTemplate == null)
{
var newTabHost = InterLayoutClient.GetNewHost(Partition, sourceTabControl);
if (newTabHost == null)
{
throw new ApplicationException("InterLayoutClient did not provide a new tab host.");
}
newTabHost.TabablzControl.AddToSource(sourceItem);
newTabHost.TabablzControl.SelectedItem = sourceItem;
newContent = newTabHost.Container;
}
else
{
newContent = new ContentControl
{
Content = new object(),
ContentTemplate = BranchTemplate,
};
((ContentControl)newContent).Dispatcher.BeginInvoke(new Action(() =>
{
//TODO might need to improve this a bit, make it a bit more declarative for complex trees
var newTabControl = ((ContentControl)newContent).VisualTreeDepthFirstTraversal().OfType <TabablzControl>().FirstOrDefault();
if (newTabControl != null)
{
newTabControl.DataContext = sourceTabControl.DataContext;
newTabControl.AddToSource(sourceItem);
newTabControl.SelectedItem = sourceItem;
}
}), DispatcherPriority.Loaded);
}
if (location == DropZoneLocation.Right || location == DropZoneLocation.Bottom)
{
branchItem.FirstItem = Content;
branchItem.SecondItem = newContent;
}
else
{
branchItem.FirstItem = newContent;
branchItem.SecondItem = Content;
}
SetCurrentValue(ContentProperty, branchItem);
}
public INewTabHost <Window> GetNewHost(IInterTabClient interTabClient, object partition, TabablzControl source)
{
//When tearing a windows, create a new main window
var view = ServiceLocator.Current.GetInstance <MainWindow>();
return(new NewTabHost <Window>(view, view.TabablzControl));
}
public LocationReportBuilder(TabablzControl targetTabablzControl)
{
_targetTabablzControl = targetTabablzControl;
}
public INewTabHost <Window> GetNewHost(IInterTabClient interTabClient, object partition, TabablzControl source)
{
var dragablzTabHostWindow = new DragablzTabHostWindow(_applicationName);
return(new NewTabHost <DragablzTabHostWindow>(dragablzTabHostWindow, dragablzTabHostWindow.TabsContainer));
}
private static bool TryGetSourceTabControl(DragablzItem dragablzItem, out TabablzControl tabablzControl)
{
var sourceOfDragItemsControl = ItemsControl.ItemsControlFromItemContainer(dragablzItem) as DragablzItemsControl;
if (sourceOfDragItemsControl == null) throw new ApplicationException("Unable to determine source items control.");
tabablzControl = TabablzControl.GetOwnerOfHeaderItems(sourceOfDragItemsControl);
return tabablzControl != null;
}
/// <summary>
/// Creates a split in a layout, at the location of a specified <see cref="TabablzControl"/>.
/// </summary>
/// <para></para>
/// <param name="tabablzControl">Tab control to be split.</param>
/// <param name="orientation">Direction of split.</param>
/// <param name="makeSecond">Set to <c>true</c> to make the current tab control push into the right hand or bottom of the split.</param>
/// <remarks>The tab control to be split must be hosted in a layout control.</remarks>
public static BranchResult Branch(TabablzControl tabablzControl, Orientation orientation, bool makeSecond)
{
return Branch(tabablzControl, orientation, makeSecond, .5);
}
private static void TabablzControlVisitor(LocationReportBuilder locationReportBuilder, TabablzControl tabablzControl)
{
if (Equals(tabablzControl, locationReportBuilder.TargetTabablzControl))
{
locationReportBuilder.MarkFound();
}
}
public INewTabHost <Window> GetNewHost(IInterTabClient interTabClient, object partition, TabablzControl source)
{
MainWindow window = new MainWindow(fullscreen: false);
MainPage mainPage = window.GetMainPage();
return(new NewTabHost <Window>(window, mainPage.tcMainTabControl));
}
/// <summary>
/// Implementation of InterTabClient.
/// To open dragged tabs in a different window class than they originated from.
/// </summary>
/// <param name="interTabClient">InterTabClient</param>
/// <param name="partition">Partition</param>
/// <param name="source">Source</param>
/// <returns>Tab host.</returns>
public INewTabHost <Window> GetNewHost(IInterTabClient interTabClient, object partition, TabablzControl source)
{
TabWindow view = new TabWindow();
view.Owner = App.Current.MainWindow;
TControl = source;
view.Closing += new CancelEventHandler(CloseWindow);
return(new NewTabHost <Window>(view, view.TabablzControl)); //TabablzControl is a names control in the XAML.
}
public INewTabHost <Window> GetNewHost(IInterTabClient interTabClient, object partition, TabablzControl source)
{
var window = _factory.Create();
return(new NewTabHost <Window>(window, window.InitialTabablzControl));
}
private static void TabablzControlVisitor(LocationReportBuilder locationReportBuilder, TabablzControl tabablzControl)
{
if (Equals(tabablzControl, locationReportBuilder.TargetTabablzControl))
locationReportBuilder.MarkFound();
}
public TabEmptiedResponse TabEmptiedHandler(TabablzControl tabControl, Window window)
{
return(Application.Current.Windows.OfType <MainWindow>().Count() == 1
? TabEmptiedResponse.DoNothing
: TabEmptiedResponse.CloseWindowOrLayoutBranch);
}
/// <summary>
/// Creates a split in a layout, at the location of a specified <see cref="TabablzControl"/>.
/// </summary>
/// <para></para>
/// <param name="tabablzControl">Tab control to be split.</param>
/// <param name="orientation">Direction of split.</param>
/// <param name="makeSecond">Set to <c>true</c> to make the current tab control push into the right hand or bottom of the split.</param>
/// <remarks>The tab control to be split must be hosted in a layout control.</remarks>
public static BranchResult Branch(TabablzControl tabablzControl, Orientation orientation, bool makeSecond)
{
return(Branch(tabablzControl, orientation, makeSecond, .5));
}
//TODO I've internalised constructor for now, so I can come back and add Window without breaking.
internal LocationReport(TabablzControl tabablzControl, Layout rootLayout)
: this(tabablzControl, rootLayout, null, false)
{
}
public INewTabHost <Window> GetNewHost(IInterTabClient interTabClient, object partition, TabablzControl source)
{
MainWindow view = new();
var model = ChromEr.Instance.CreateMainViewModel(new List <DirectoryTabItemViewModel>());
view.DataContext = model;
return(new NewTabHost <Window>(view, view.InitMainView.InitialTabablzControl));
}
public TabEmptiedResponse TabEmptiedHandler(TabablzControl tabControl, Window window)
{
return(TabEmptiedResponse.DoNothing);
}
public INewTabHost <Window> GetNewHost(IInterTabClient interTabClient, object partition, TabablzControl source)
{
var childWindow = new ChildWindow();
childWindow.TabablzControl.Items.Clear();
return(new NewTabHost <Window>(childWindow, childWindow.TabablzControl));
}
/// <summary>
/// Finds the location of a tab control withing a layout.
/// </summary>
/// <param name="tabablzControl"></param>
/// <returns></returns>
public static LocationReport Find(TabablzControl tabablzControl)
{
if (tabablzControl == null) throw new ArgumentNullException("tabablzControl");
return Finder.Find(tabablzControl);
}
public INewTabHost <Window> GetNewHost(IInterTabClient interTabClient, object partition, TabablzControl source)
{
DragablzSNMPTabHostWindow dragablzSNMPTabHostWindow = new DragablzSNMPTabHostWindow();
return(new NewTabHost <DragablzSNMPTabHostWindow>(dragablzSNMPTabHostWindow, dragablzSNMPTabHostWindow.TabsContainer));
}
/// <summary>
/// Creates a split in a layout, at the location of a specified <see cref="TabablzControl"/>.
/// </summary>
/// <para></para>
/// <param name="tabablzControl">Tab control to be split.</param>
/// <param name="orientation">Direction of split.</param>
/// <param name="makeSecond">Set to <c>true</c> to make the current tab control push into the right hand or bottom of the split.</param>
/// <param name="firstItemProportion">Sets the proportion of the first tab control, with 0.5 being 50% of available space.</param>
/// <remarks>The tab control to be split must be hosted in a layout control.</remarks>
public static BranchResult Branch(TabablzControl tabablzControl, Orientation orientation, bool makeSecond, double firstItemProportion)
{
if (firstItemProportion < 0.0 || firstItemProportion > 1.0) throw new ArgumentOutOfRangeException("firstItemProportion", "Must be >= 0.0 and <= 1.0");
var locationReport = Find(tabablzControl);
Action<Branch> applier;
object existingContent;
if (!locationReport.IsLeaf)
{
existingContent = locationReport.RootLayout.Content;
applier = branch => locationReport.RootLayout.Content = branch;
}
else if (!locationReport.IsSecondLeaf)
{
existingContent = locationReport.ParentBranch.FirstItem;
applier = branch => locationReport.ParentBranch.FirstItem = branch;
}
else
{
existingContent = locationReport.ParentBranch.SecondItem;
applier = branch => locationReport.ParentBranch.SecondItem = branch;
}
var selectedItem = tabablzControl.SelectedItem;
var branchResult = Branch(orientation, firstItemProportion, makeSecond, locationReport.RootLayout.BranchTemplate, existingContent, applier);
tabablzControl.SelectedItem = selectedItem;
tabablzControl.Dispatcher.BeginInvoke(new Action(() =>
tabablzControl.SetCurrentValue(Selector.SelectedItemProperty, selectedItem)),
DispatcherPriority.Loaded);
return branchResult;
}
public INewTabHost <Window> GetNewHost(IInterTabClient interTabClient, object partition, TabablzControl source)
{
var view = new HostView();
var viewModel = new HostViewModel();
view.DataContext = viewModel;
return(new NewTabHost <Window>(view, view.InitialTabablzControl));
}
//private readonly IViewManager _viewManager;
//public CustomTabClient(IViewManager viewManager)
//{
// _viewManager = viewManager;
//}
public override INewTabHost <Window> GetNewHost(IInterTabClient interTabClient, object partition, TabablzControl source)
{
var window = new NewSubWindow();
window.InitializeComponent();
window.TabablzControl.Items.Clear();
return(new NewTabHost <Window>(window, window.TabablzControl));
//var vm = new SubWindowViewModel(_viewManager);
//var view = _viewManager.CreateViewForModel(vm);
//var window = view as SubWindowView;
//return new NewTabHost<Window>(window, window.InitialTabablzControl);
}
public static FloatTransfer TakeSnapshot(DragablzItem dragablzItem, TabablzControl sourceTabControl)
{
if (dragablzItem == null) throw new ArgumentNullException("dragablzItem");
return new FloatTransfer(sourceTabControl.ActualWidth, sourceTabControl.ActualHeight, dragablzItem.UnderlyingContent ?? dragablzItem.Content ?? dragablzItem);
}
public TabEmptiedResponse TabEmptiedHandler(TabablzControl tabControl, Window window)
{
return(window is MainWindow ? TabEmptiedResponse.DoNothing : TabEmptiedResponse.CloseWindowOrLayoutBranch);
}
public INewTabHost <Window> GetNewHost(IInterTabClient interTabClient, object partition, TabablzControl source)
{
var view = new BasicExampleTemplateWindow();
var model = new BasicExampleTemplateModel(interTabClient, partition);
view.DataContext = model;
return(new NewTabHost <Window>(view, view.TabablzControl));
}
private void TeamInfo(object obj)
{
TabablzControl teamViewTabablzControl = (TabablzControl)obj;
teamViewTabablzControl.SelectedIndex = 1;
}
/// <summary>
/// Create a new <see cref="SigmaWindow" /> when a tab is dragged out.
/// Provide a new host window so a tab can be teared from an existing window into
/// a new window.
/// </summary>
/// <param name="interTabClient"></param>
/// <param name="partition">Provides the partition where the drag operation was initiated.</param>
/// <param name="source">The source control where a dragging operation was initiated.</param>
/// <returns></returns>
public INewTabHost <Window> GetNewHost(IInterTabClient interTabClient, object partition, TabablzControl source)
{
TWindow window = Construct(new[] { typeof(WPFMonitor), typeof(Application), typeof(string), typeof(TWindow) },
new object[] { _monitor, _app, _title, _monitor.Window });
return(new NewTabHost <WPFWindow>(window, window.TabControl.InitialTabablzControl));
}
public TabEmptiedResponse TabEmptiedHandler(TabablzControl tabControl, Window window)
{
//When closing the last tab, close the root window
return(TabEmptiedResponse.CloseWindowOrLayoutBranch);
}
/// <summary>
/// Called when a tab has been emptied, and thus typically a window needs closing.
/// </summary>
/// <param name="tabControl"></param>
/// <param name="window"></param>
/// <returns></returns>
public TabEmptiedResponse TabEmptiedHandler(TabablzControl tabControl, Window window)
{
window.Close();
return(TabEmptiedResponse.CloseWindowOrLayoutBranch);
}
private static void TabablzControlVisitor(TreeNode treeNode, TabablzControl tabablzControl)
{
treeNode.Children.Add(new TreeNode {
Content = new TabablzControlProxy(tabablzControl)
});
}
//TODO I've internalised constructor for now, so I can come back and add Window without breaking.
internal LocationReport(TabablzControl tabablzControl, Layout rootLayout)
: this(tabablzControl, rootLayout, null, false)
{ }
