public void ElementList_ThreeLayerAndChangeSize_FreeOpacityMask()
{
var factories = new IElementFactoryViewModel<IElementViewModel>[]
{
new PortiereFactoryViewModel(),
new PleatFactoryViewModel(),
new TulleFactoryViewModel()
};
var screen = new ScreenViewModel()
{
Width = 4,
Height = 2
};
var workspace = new WorkspaceViewModel()
{
Factories = factories,
Screen = screen,
CommandFactory = MockRepository.GenerateStub<ICommandFactory>(),
SettingProvider = MockRepository.GenerateStub<ISettingProvider>()
};
var elementList = workspace.ElementList;
elementList.AppendElement(factories[0]);
elementList.AppendElement(factories[1]);
elementList.AppendElement(factories[2]);
Assert.That(elementList.Count(), Is.EqualTo(3));
Assert.That(elementList.Collection.Last().Layout.OpacityMask, Is.Null);
screen.Width = 5;
Assert.That(elementList.Collection.Last().Layout.OpacityMask, Is.Null);
}
public WorkspaceNavigationViewModel(WorkspaceViewModel startWorkspace, bool showNavButtons = true)
{
_showNavButtons = showNavButtons;
Workspaces = new List<WorkspaceViewModel>();
Workspaces.Add(startWorkspace);
_currentWorkspace = Workspaces.First();
}
public WorkModeListViewModel(WorkspaceViewModel workspace)
{
Editor = new EditorWorkModeViewModel(workspace);
Report = new ReportWorkModeViewModel(workspace);
Items = new[]
{
new ContainerRecord<IWorkModeViewModel>("Editor", Editor),
new ContainerRecord<IWorkModeViewModel>("Report", Report)
};
}
public WorkspaceWindow()
{
vm = new WorkspaceViewModel(this);
this.DataContext = vm;
InitializeComponent();
this.Title = "Workspace: " + Workspace.Current.Path;
//TODO: Need to do a query when load db, in loader
/*
var db = Workspace.Current.DB;
db.Books.Add(new Models.Book() {
Created = DateTime.Now, //Move to constructor
Title = "Test"
});
db.SaveChanges();
*/
}
public JadeViewModel(DockingGui.MainWindow view)
{
_workspaceController = JadeCore.Services.Provider.WorkspaceController;
//Todo - Workspace viewmodel to track WorkspaceController changes
_workspaceController.WorkspaceChanged += delegate { OnWorkspaceChanged(); };
_currentWorkspace = new WorkspaceViewModel();
_editorController = JadeCore.Services.Provider.EditorController;
_editorController.ActiveDocumentChanged += OnEditorControllerActiveDocumentChanged;
_editorViewModel = new JadeControls.EditorControl.ViewModel.EditorControlViewModel(_editorController, new JadeControls.EditorControl.ViewModel.DocumentViewModelFactory());
_outputViewModel = new OutputViewModel(JadeCore.Services.Provider.OutputController);
_searchController = JadeCore.Services.Provider.SearchController;
_seachResultsViewModel = new SearchResultsPaneViewModel(_searchController);
_symbolInspectorViewModel = new SymbolInspectorPaneViewModel(_editorController);
_cursorInspectorViewModel = new CursorInspectorPaneViewModel();
_contextPaneViewModel = new ContextPaneViewModel(_editorController);
_commands = new JadeCommandAdaptor(this);
_view = view;
_toolWindows = new ObservableCollection<JadeControls.Docking.ToolPaneViewModel>();
_toolWindows.Add(_seachResultsViewModel);
_toolWindows.Add(_outputViewModel);
_toolWindows.Add(_currentWorkspace);
_toolWindows.Add(_symbolInspectorViewModel);
_toolWindows.Add(_cursorInspectorViewModel);
_toolWindows.Add(_contextPaneViewModel);
OnViewWorkspaceWindow();
UpdateWindowTitle();
}
public Watch3DFullscreenViewModel(WorkspaceViewModel parentWorkspace)
{
ParentWorkspace = parentWorkspace;
}
/// <summary>
/// Initializes a new instance of the <see cref="WorkspaceWindow"/> class.
/// </summary>
/// <param name="viewModel">The view model to inject.</param>
/// <remarks>
/// This constructor can be used to use view-model injection.
/// </remarks>
public WorkspaceWindow(WorkspaceViewModel viewModel)
: base(viewModel)
{
InitializeComponent();
}
public CustomFilterOperation(WorkspaceViewModel workspaceViewModel) : base("Custom filter", new CustomFilterOperationView(workspaceViewModel))
{
}
public SelectWorkspaceMessage(WorkspaceViewModel workspaceViewModel)
{
WorkspaceViewModel = workspaceViewModel;
}
private void createWorkspace(WorkspaceViewModel workspace)
{
this.Workspaces.Add(workspace);
this.setActiveWorkspace(workspace);
}
//private ObservableCollection<PageType> _pages;
//private List<ktUIGroupOrder> _orders;
public GroupOrder()
{
_groupOrder = WorkSheetktUIGroupOrder.Instance;
_sharedResources = SharedRessources.Instance;
_workspaceVm = WorkspaceViewModel.Instance;
}
public FilterEdgeSharpeningOperation(WorkspaceViewModel workspaceViewModel) : base("Edge sharpening", new FilterEdgeSharpeningOperationView(workspaceViewModel))
{
}
public BarchartOperation(WorkspaceViewModel workspaceViewModel) : base("Barchart", new BarchartOperationView(workspaceViewModel))
{
}
public FilterEdgeSharpeningOperationView(WorkspaceViewModel workspaceViewModel)
{
this.OperationViewModel = new FilterEdgeSharpeningOperationViewModel(workspaceViewModel);
this.DataContext = this.OperationViewModel;
InitializeComponent();
}
public BandpassFilterOperationViewModel(WorkspaceViewModel workspaceViewModel) : base(workspaceViewModel)
{
}
public OutputProbabilityDensityOfPowerTo2_3OperationView(WorkspaceViewModel workspaceViewModel)
{
this.OperationViewModel = new OutputProbabilityDensityOfPowerTo2_3OperationViewModel(workspaceViewModel);
this.DataContext = this.OperationViewModel;
InitializeComponent();
}
public FilterKirschOperatorOperation(WorkspaceViewModel workspaceViewModel) : base("Kirsch Operator", new FilterKirschOperatorOperationView(workspaceViewModel))
{
}
public RegionSplittingAndMergingOperation(WorkspaceViewModel workspaceViewModel) : base("Region splitting and merging", new RegionSplittingAndMergingOperationView(workspaceViewModel))
{
}
public void CanZoom()
{
WorkspaceModel workspaceModel = ViewModel.CurrentSpaceViewModel.Model;
WorkspaceViewModel workspaceVM = ViewModel.CurrentSpaceViewModel;
double zoom;
// Test Zoom in
zoom = workspaceModel.Zoom;
if (ViewModel.ZoomInCommand.CanExecute(null))
{
ViewModel.ZoomInCommand.Execute(null);
}
Assert.Greater(workspaceModel.Zoom, zoom);
// Test Zoom out
zoom = workspaceModel.Zoom;
if (ViewModel.ZoomOutCommand.CanExecute(null))
{
ViewModel.ZoomOutCommand.Execute(null);
}
Assert.Greater(zoom, workspaceModel.Zoom);
// Test can set zoom (at random zoom for 10 times)
int testLoop = 10;
for (int i = 0; i < testLoop; i++)
{
// Get random number for the zoom
double upperBound = WorkspaceModel.ZOOM_MAXIMUM;
double lowerBound = WorkspaceModel.ZOOM_MINIMUM;
Random random = new Random();
double randomNumber = random.NextDouble() * (upperBound - lowerBound) + lowerBound;
if (ViewModel.CurrentSpaceViewModel.SetZoomCommand.CanExecute(randomNumber))
{
ViewModel.CurrentSpaceViewModel.SetZoomCommand.Execute(randomNumber);
}
// Check Zoom is correct
Assert.AreEqual(randomNumber, workspaceModel.Zoom);
}
// Border Test for Set Zoom
// Min zoom
zoom = WorkspaceModel.ZOOM_MINIMUM;
if (workspaceVM.SetZoomCommand.CanExecute(zoom))
{
workspaceVM.SetZoomCommand.Execute(zoom);
}
Assert.AreEqual(zoom, workspaceModel.Zoom);
// Zoom out over limit (check that it does not zoom out)
if (ViewModel.ZoomOutCommand.CanExecute(null))
{
ViewModel.ZoomOutCommand.Execute(null);
}
Assert.AreEqual(zoom, workspaceModel.Zoom);
// Max zoom
zoom = WorkspaceModel.ZOOM_MAXIMUM;
if (workspaceVM.SetZoomCommand.CanExecute(zoom))
{
workspaceVM.SetZoomCommand.Execute(zoom);
}
Assert.AreEqual(zoom, workspaceModel.Zoom);
// Zoom in over limit (check that it does not zoom in)
if (ViewModel.ZoomInCommand.CanExecute(null))
{
ViewModel.ZoomInCommand.Execute(null);
}
Assert.AreEqual(zoom, workspaceModel.Zoom);
// Above Max Limit Test
zoom = WorkspaceModel.ZOOM_MAXIMUM + 0.1;
if (workspaceVM.SetZoomCommand.CanExecute(zoom))
{
workspaceVM.SetZoomCommand.Execute(zoom);
}
Assert.AreNotEqual(zoom, workspaceModel.Zoom);
// Below Min Limit Test
zoom = WorkspaceModel.ZOOM_MINIMUM - 0.1;
if (workspaceVM.SetZoomCommand.CanExecute(zoom))
{
workspaceVM.SetZoomCommand.Execute(zoom);
}
Assert.AreNotEqual(zoom, workspaceModel.Zoom);
// Stress Test
// Zoom in and out repeatly
for (int i = 0; i < 20; i++)
{
for (int stepIn = 0; stepIn < 20; stepIn++)
{
if (ViewModel.ZoomInCommand.CanExecute(null))
{
ViewModel.ZoomInCommand.Execute(null);
}
}
for (int stepOut = 0; stepOut < 20; stepOut++)
{
if (ViewModel.ZoomOutCommand.CanExecute(null))
{
ViewModel.ZoomOutCommand.Execute(null);
}
}
}
// Doesn't crash the system
Assert.True(true);
}
public ShellViewModel(IWindowManager windowManager,WorkspaceViewModel workspace)
{
_windowManager = windowManager;
_workspace = workspace;
}
public ContrastChangeOperationViewModel(WorkspaceViewModel workspaceViewModel) : base(workspaceViewModel)
{
}
public void CreateNewGame()
{
Menu = new MenuViewModel();
CurrentWorkSpace = Menu;
}
private void OnMouseLeftButtonDown(object sender, MouseButtonEventArgs e)
{
WorkspaceViewModel wvm = (DataContext as WorkspaceViewModel);
if (this.snappedPort != null)
{
wvm.HandlePortClicked(this.snappedPort);
}
else
{
wvm.HandleLeftButtonDown(workBench, e);
}
// if selection is going to be dragged and ctrl is pressed
if (wvm.IsDragging && Keyboard.Modifiers == ModifierKeys.Control)
{
initialMousePosition = e.GetPosition(WorkspaceElements);
// disable clearing selection while dragged data is being generated
// new AnnotationViewModel unnecessarily clears selection
DynamoSelection.Instance.ClearSelectionDisabled = true;
var selection = DynamoSelection.Instance.Selection;
var nodes = selection.OfType <NodeModel>();
var notes = selection.OfType <NoteModel>();
var annotations = selection.OfType <AnnotationModel>();
var connectors = nodes.SelectMany(n =>
n.OutPorts.SelectMany(port => port.Connectors)
.Where(c => c.End != null && c.End.Owner.IsSelected)).Distinct();
// set list of selected viewmodels
draggedData = connectors.Select(c => (ViewModelBase) new ConnectorViewModel(ViewModel, c))
.Concat(notes.Select(n => new NoteViewModel(ViewModel, n)))
.Concat(annotations.Select(a => new AnnotationViewModel(ViewModel, a)))
.Concat(nodes.Select(n =>
{
var nodeRect = this.ChildrenOfType <NodeView>()
.First(view => view.ViewModel.NodeModel == n).nodeBorder;
var size = new Size(nodeRect.ActualWidth, nodeRect.ActualHeight);
// set fixed size for dragged nodes,
// so that they will correspond to origin nodes
return(new NodeViewModel(ViewModel, n, size));
})).ToList();
var mouse = e.GetPosition(WorkspaceElements);
var locatableModels = nodes.Concat <ModelBase>(notes);
var minX = locatableModels.Any() ? locatableModels.Min(mb => mb.X) : 0;
var minY = locatableModels.Any() ? locatableModels.Min(mb => mb.Y) : 0;
// compute offset to correctly place selected items right under mouse cursor
var mouseOffset = new Point2D(mouse.X - minX, mouse.Y - minY);
DynamoSelection.Instance.ClearSelectionDisabled = false;
DragDrop.DoDragDrop(this, mouseOffset, DragDropEffects.Copy);
// end dragging operation by setting State from DragSetup to None
ViewModel.HandleMouseRelease(workBench, e);
// remove dragged selection view
if (draggedAdorner != null)
{
draggedData = null;
draggedAdorner.Detach();
draggedAdorner = null;
}
}
InCanvasSearchBar.IsOpen = false;
}
private void onWorkspacesRequestClose(Object sender, EventArgs e)
{
WorkspaceViewModel workspace = sender as WorkspaceViewModel;
this.Workspaces.Remove(workspace);
}
void IFormsView.SetDataContext(INotifyPropertyChanged mdl)
{
this.DataContext = (WorkspaceViewModel)mdl;
}
public FilterModifyingPhaseSpectrumOperationView(WorkspaceViewModel workspaceViewModel)
{
this.OperationViewModel = new FilterModifyingPhaseSpectrumOperationViewModel(workspaceViewModel);
this.DataContext = this.OperationViewModel;
InitializeComponent();
}
public WorkspacePageUserControl(AnalysisJobViewModel analysisJobViewModel)
: this()
{
WorkspaceViewModel = new WorkspaceViewModel(analysisJobViewModel);
DataContext = WorkspaceViewModel;
}
public LowPassFilterOperation(WorkspaceViewModel workspaceViewModel) : base("Low pass filter", new LowPassFilterOperationView(workspaceViewModel))
{
}
public HighPassFilterOperationView(WorkspaceViewModel workspaceViewModel)
{
this.OperationViewModel = new HighPassFilterOperationViewModel(workspaceViewModel);
this.DataContext = this.OperationViewModel;
InitializeComponent();
}
public void ElementList_AddAllElement_NoError()
{
var factories = new IElementFactoryViewModel<IElementViewModel>[]
{
new PortiereFactoryViewModel(),
new PleatFactoryViewModel(),
new TulleFactoryViewModel(),
new TieBackFactoryViewModel(),
new PanelFactoryViewModel(),
new HardPelmetFactoryViewModel(),
new ApplicationFactoryViewModel(),
new ScanFactoryViewModel(),
new OverlayFactoryViewModel(),
new FilletFactoryViewModel(),
new EqualSwagFactoryViewModel(),
new EqualTailFactoryViewModel(),
new ScaleneSwagFactoryViewModel(),
new ScaleneTailFactoryViewModel(),
new DeJabotFactoryViewModel(),
new LatticeFactoryViewModel(),
new RomanBlindFactoryViewModel()
};
var screen = new ScreenViewModel()
{
Width = 4,
Height = 2
};
var settingData = MockRepository.GenerateStub<ISettingData>();
settingData.Stub(sd => sd.ProgramName).Return("MyName");
settingData.Stub(sd => sd.Version).Return("1.0.0.0");
var settingProvider = MockRepository.GenerateStub<ISettingProvider>();
settingProvider.Stub(sp => settingProvider.GetSettingData()).Return(settingData);
var workspace = new WorkspaceViewModel()
{
Factories = factories,
Screen = screen,
CommandFactory = MockRepository.GenerateStub<ICommandFactory>(),
SettingProvider = settingProvider
};
var elementList = workspace.ElementList;
factories.ToList()
.ForEach(factory => elementList.AppendElement(factory));
Assert.That(elementList.Count(), Is.EqualTo(factories.Length));
var dataTransfer = workspace.Save();
Assert.DoesNotThrow(() =>
{
var serializer = new XmlSerializer(StandardXmlPrimitive.Primitives, dataTransfer);
serializer.Serialize();
});
workspace.Restore(dataTransfer);
Assert.That(elementList.Count(), Is.EqualTo(factories.Length));
}
public ToolbarView(WorkspaceViewModel workspaceViewModel)
{
this.ToolbarViewModel = new ToolbarViewModel(workspaceViewModel);
this.DataContext = this.ToolbarViewModel;
InitializeComponent();
}
public OutputProbabilityDensityOfPowerTo2_3OperationViewModel(WorkspaceViewModel workspaceViewModel) : base(workspaceViewModel)
{
}
public Watch3DFullscreenViewModel(WorkspaceViewModel parentWorkspace)
{
ParentWorkspace = parentWorkspace;
}
public BrightnessChangeOperationView(WorkspaceViewModel workspaceViewModel)
{
this.OperationViewModel = new BrightnessChangeOperationViewModel(workspaceViewModel);
this.DataContext = this.OperationViewModel;
InitializeComponent();
}
private bool IsInPanMode()
{
WorkspaceViewModel vm = DataContext as WorkspaceViewModel;
return(vm.CurrentState == WorkspaceViewModel.StateMachine.State.PanMode);
}
private void removeViewModelsubscriptions(WorkspaceViewModel ViewModel)
{
ViewModel.RequestShowInCanvasSearch -= ShowHideInCanvasControl;
ViewModel.DynamoViewModel.PropertyChanged -= ViewModel_PropertyChanged;
}
public static void ShowSatteliteWindow(Window windowInstance, WorkspaceViewModel viewmodel)
{
SatteliteWindowInstance = windowInstance;
SatteliteWindowInstance.DataContext = viewmodel;
SatteliteWindowInstance.ShowDialog();
}
public RegionSplittingAndMergingOperationView(WorkspaceViewModel workspaceViewModel)
{
this.OperationViewModel = new RegionSplittingAndMergingOperationViewModel(workspaceViewModel);
this.DataContext = this.OperationViewModel;
InitializeComponent();
}
public FilterWithEdgeDetectionOperation(WorkspaceViewModel workspaceViewModel) : base("Filter with edge detection", new FilterWithEdgeDetectionOperationView(workspaceViewModel))
{
}