public void ClosingDocumentOnWindowClosingShouldntThrow()
        {
            Window.Show();
            DispatcherHelper.DoEvents();
            BindingTestClass          testClass = new BindingTestClass();
            WindowedDocumentUIService service   = CreateService();

            Interaction.GetBehaviors(Window).Add(service);
            IDocumentManagerService iService = service;

            IDocument document = null;

            WindowedDocumentUIService.WindowDocument typedDocument = null;
            var content = new TestDocumentContent();

            document      = iService.CreateDocument("View1", content);
            typedDocument = (WindowedDocumentUIService.WindowDocument)document;
            document.Show();
            DispatcherHelper.DoEvents();

            Window window = typedDocument.Window.RealWindow;

            content.onClose = () => document.Close();
            window.Close();
            DispatcherHelper.DoEvents();
        }
        void DoCloseTest(bool?allowClose, bool destroyOnClose, bool destroyed, Action <IDocument, bool> closeMethod)
        {
            Window.Show();
            DispatcherHelper.DoEvents();
            IDocumentManagerService service = null;
            bool      closeChecked          = false;
            bool      destroyCalled         = false;
            IDocument document = null;

            WindowedDocumentUIService windowedDocumentUIService = CreateService();

            Interaction.GetBehaviors(Window).Add(windowedDocumentUIService);
            service = windowedDocumentUIService;
            TestDocumentContent viewModel = new TestDocumentContent(() => {
                closeChecked = true;
                return(allowClose != null && allowClose.Value);
            }, () => {
                destroyCalled = true;
            });

            document = service.CreateDocument("EmptyView", viewModel);
            document.Show();
            DispatcherHelper.DoEvents();

            document.DestroyOnClose = destroyOnClose;
            closeMethod(document, allowClose == null);
            Assert.AreEqual(allowClose != null, closeChecked);
            Assert.AreEqual(destroyed, destroyCalled);
            Assert.AreEqual(!destroyed, service.Documents.Contains(document));
        }
        public void ActivateWhenDocumentShow()
        {
            EnqueueShowWindow();
            IDocument document = null;
            WindowedDocumentUIService service = CreateService();

            Interaction.GetBehaviors(Window).Add(service);
            IDocumentManagerService iService = service;

            EnqueueCallback(() => {
                document = iService.CreateDocument("View1",
                                                   ViewModelSource.Create(() => new UITestViewModel()
                {
                    Title = "Title1", Parameter = 1
                }));
                document.Show();
            });
            EnqueueWindowUpdateLayout();
            EnqueueCallback(() => {
                Assert.AreEqual(iService.ActiveDocument, document);
                Assert.IsNotNull(document.Content);
                Assert.AreEqual(document.Content, ViewHelper.GetViewModelFromView(service.ActiveView));
                Assert.AreEqual(document.Content, ((WindowedDocumentUIService.WindowDocument)document).Window.RealWindow.DataContext);
                document.Close();
            });
            EnqueueTestComplete();
        }
Ejemplo n.º 4
0
        public void UseDXWindowWithNullTitle()
        {
            WindowedDocumentUIService service = CreateService();

            Interaction.GetBehaviors(Window).Add(service);
            IDocument document = service.CreateDocument("EmptyView", new ViewModelWithNullTitle());

            Assert.AreEqual(string.Empty, document.Title);
        }
        public void TwoWayBindingReadonlyProperty()
        {
            BindingTestClass          testClass = new BindingTestClass();
            WindowedDocumentUIService service   = CreateService();

            Interaction.GetBehaviors(Window).Add(service);
            IDocumentManagerService iService = service;

            BindingOperations.SetBinding(service, WindowedDocumentUIService.ActiveDocumentProperty,
                                         new Binding()
            {
                Path = new PropertyPath(BindingTestClass.ReadonlyActiveDocumentProperty), Source = testClass, Mode = BindingMode.Default
            });
        }
Ejemplo n.º 6
0
        private void SetGetBehaviors()
        {
            DXMessageBoxService dxMessageBoxService = new DXMessageBoxService();

            Interaction.GetBehaviors(this).Add(dxMessageBoxService);

            WindowedDocumentUIService windowedDocumentUIService = new WindowedDocumentUIService();

            windowedDocumentUIService.YieldToParent = true;
            Interaction.GetBehaviors(this).Add(windowedDocumentUIService);

            DispatcherService dispatcherService = new DispatcherService();

            Interaction.GetBehaviors(this).Add(dispatcherService);
        }
        public void SettingActiveDocument()
        {
            EnqueueShowWindow();
            IDocument document1 = null;
            IDocument document2 = null;
            WindowedDocumentUIService service = new WindowedDocumentUIService();

            Interaction.GetBehaviors(Window).Add(service);
            IDocumentManagerService iService = service;
            int counter = 0;

            EnqueueCallback(() => {
                iService.ActiveDocumentChanged += (s, e) => counter++;
                document1 = iService.CreateDocument("View1",
                                                    ViewModelSource.Create(() => new UITestViewModel()
                {
                    Title = "Title1", Parameter = 1
                }));
                document2 = iService.CreateDocument("View2",
                                                    ViewModelSource.Create(() => new UITestViewModel()
                {
                    Title = "Title2", Parameter = 2
                }));
                document1.Show();
                document2.Show();
            });
            EnqueueWindowUpdateLayout();
            EnqueueCallback(() => {
#if !SILVERLIGHT
                Assert.AreEqual(3, counter);
#else
                Assert.AreEqual(2, counter);
#endif
                iService.ActiveDocument = document1;
            });
            EnqueueWindowUpdateLayout();
            EnqueueCallback(() => {
                Assert.AreEqual(iService.ActiveDocument, document1);
#if !SILVERLIGHT
                Assert.AreEqual(4, counter);
#else
                Assert.AreEqual(3, counter);
#endif
                document1.Close();
                document2.Close();
            });
            EnqueueTestComplete();
        }
        public void ActivateDocumentsWhenClosed()
        {
            EnqueueShowWindow();
            List <IDocument>          documents = new List <IDocument>();
            WindowedDocumentUIService service   = CreateService();

            Interaction.GetBehaviors(Window).Add(service);
            IDocumentManagerService iService = service;
            int counter = 0;

            EnqueueCallback(() => {
                service.ActiveDocumentChanged += (s, e) => counter++;
                for (int i = 0; i < 4; i++)
                {
                    documents.Add(iService.CreateDocument("View" + i,
                                                          ViewModelSource.Create(() => new UITestViewModel()
                    {
                        Title = "Title" + i, Parameter = i
                    })));
                    documents[i].Show();
                }
                iService.ActiveDocument = documents[1];
            });
            EnqueueWindowUpdateLayout();
            EnqueueCallback(() => {
                counter = 0;
                documents[1].Close();
            });
            EnqueueWindowUpdateLayout();
            EnqueueCallback(() => {
                Assert.AreEqual(2, counter);
                Assert.AreEqual(iService.ActiveDocument, documents[3]);
                iService.ActiveDocument = documents[3];
            });
            EnqueueWindowUpdateLayout();
            EnqueueCallback(() => {
                counter = 0;
                documents[3].Close();
            });
            EnqueueWindowUpdateLayout();
            EnqueueCallback(() => {
                Assert.AreEqual(iService.ActiveDocument, documents[2]);
                Assert.AreEqual(2, counter);
                documents[0].Close();
                documents[2].Close();
            });
            EnqueueTestComplete();
        }
 public void IDocumentViewModelCloseTest() {
     EnqueueShowWindow();
     IDocumentManagerService service = null;
     bool close = false;
     bool closeChecked = false;
     IDocument document = null;
     EnqueueCallback(() => {
         WindowedDocumentUIService windowedDocumentUIService = new WindowedDocumentUIService();
         Interaction.GetBehaviors(Window).Add(windowedDocumentUIService);
         service = windowedDocumentUIService;
         TestDocumentViewModel viewModel = new TestDocumentViewModel(() => {
             closeChecked = true;
             return close;
         });
         document = service.CreateDocument("EmptyView", viewModel);
         document.Show();
     });
     EnqueueWindowUpdateLayout();
     EnqueueCallback(() => {
         document.DestroyOnClose = false;
         close = false;
         closeChecked = false;
         document.Close(false);
         Assert.IsTrue(closeChecked);
         Assert.IsTrue(service.Documents.Contains(document));
         close = true;
         closeChecked = false;
         document.Close(false);
         Assert.IsTrue(closeChecked);
         document.Show();
     });
     EnqueueWindowUpdateLayout();
     EnqueueCallback(() => {
         document.DestroyOnClose = true;
         close = false;
         closeChecked = false;
         document.Close(false);
         Assert.IsTrue(closeChecked);
         Assert.IsTrue(service.Documents.Contains(document));
         close = true;
         closeChecked = false;
         document.Close(false);
         Assert.IsTrue(closeChecked);
         Assert.IsFalse(service.Documents.Contains(document));
     });
     EnqueueTestComplete();
 }
 protected override void TearDownCore()
 {
     try {
         WindowedDocumentUIService service = Interaction.GetBehaviors(Window).OfType <WindowedDocumentUIService>().FirstOrDefault();
         if (service != null)
         {
             while (service.Documents.Any())
             {
                 service.Documents.First().DestroyOnClose = true;
                 service.Documents.First().Close(true);
             }
         }
         Interaction.GetBehaviors(Window).Clear();
     } catch { }
     ViewLocator.Default = null;
     base.TearDownCore();
 }
 public void ActivateWhenDocumentShow() {
     EnqueueShowWindow();
     IDocument document = null;
     WindowedDocumentUIService service = new WindowedDocumentUIService();
     Interaction.GetBehaviors(Window).Add(service);
     IDocumentManagerService iService = service;
     EnqueueCallback(() => {
         document = iService.CreateDocument("View1",
             ViewModelSource.Create(() => new UITestViewModel() { Title = "Title1", Parameter = 1 }));
         document.Show();
     });
     EnqueueWindowUpdateLayout();
     EnqueueCallback(() => {
         Assert.AreEqual(iService.ActiveDocument, document);
         document.Close();
     });
     EnqueueTestComplete();
 }
        public void WindowStyleSelector()
        {
            WindowedDocumentUIService service = CreateService();

            Interaction.GetBehaviors(Window).Add(service);
            service.WindowType = typeof(Window);
            Style windowStyle = new Style(typeof(Window));

            windowStyle.Setters.Add(new Setter(System.Windows.Window.TagProperty, "Style Selector Tag"));
            service.WindowStyleSelector = new TestStyleSelector()
            {
                Style = windowStyle
            };
            IDocument document       = service.CreateDocument("EmptyView", new object());
            var       windowDocument = (WindowedDocumentUIService.WindowDocument)document;

            Assert.AreEqual("Style Selector Tag", windowDocument.Window.RealWindow.Tag);
        }
        public void UnActiveDocumentClose()
        {
            EnqueueShowWindow();
            IDocument document1 = null;
            IDocument document2 = null;
            WindowedDocumentUIService service = CreateService();

            Interaction.GetBehaviors(Window).Add(service);
            IDocumentManagerService iService = service;
            int counter = 0;

            EnqueueCallback(() => {
                iService.ActiveDocumentChanged += (s, e) => counter++;
                document1 = iService.CreateDocument("View1",
                                                    ViewModelSource.Create(() => new UITestViewModel()
                {
                    Title = "Title1", Parameter = 1
                }));
                document2 = iService.CreateDocument("View2",
                                                    ViewModelSource.Create(() => new UITestViewModel()
                {
                    Title = "Title2", Parameter = 2
                }));
                document1.Show();
                Assert.AreEqual(1, counter);
                document2.Show();
            });
            EnqueueWindowUpdateLayout();
            EnqueueCallback(() => {
                Assert.AreEqual(iService.ActiveDocument, document2);
                Assert.IsNotNull(document2.Content);
                Assert.AreEqual(document2.Content, ViewHelper.GetViewModelFromView(service.ActiveView));
                document1.Close();
            });
            EnqueueWindowUpdateLayout();
            EnqueueCallback(() => {
                Assert.AreEqual(iService.ActiveDocument, document2);
                Assert.IsNotNull(document2.Content);
                Assert.AreEqual(document2.Content, ViewHelper.GetViewModelFromView(service.ActiveView));
                Assert.AreEqual(3, counter);
                document2.Close();
            });
            EnqueueTestComplete();
        }
 public void WindowStyle() {
     EnqueueShowWindow();
     IDocument document = null;
     EnqueueCallback(() => {
         WindowedDocumentUIService service = new WindowedDocumentUIService();
         Interaction.GetBehaviors(Window).Add(service);
         service.WindowType = typeof(Window);
         Style windowStyle = new Style(typeof(Window));
         windowStyle.Setters.Add(new Setter(FrameworkElement.TagProperty, "Style Tag"));
         service.WindowStyle = windowStyle;
         document = service.CreateDocument("EmptyView", new object());
     });
     EnqueueWindowUpdateLayout();
     EnqueueCallback(() => {
         var windowDocument = (WindowedDocumentUIService.WindowDocument)document;
         Assert.AreEqual("Style Tag", windowDocument.Window.RealWindow.Tag);
     });
     EnqueueTestComplete();
 }
        public void TwoWayBinding()
        {
            EnqueueShowWindow();
            BindingTestClass          testClass = new BindingTestClass();
            WindowedDocumentUIService service   = CreateService();

            Interaction.GetBehaviors(Window).Add(service);
            IDocumentManagerService iService = service;

            IDocument document1 = null;
            IDocument document2 = null;

            BindingOperations.SetBinding(service, WindowedDocumentUIService.ActiveDocumentProperty,
                                         new Binding()
            {
                Path = new PropertyPath(BindingTestClass.ActiveDocumentProperty), Source = testClass, Mode = BindingMode.Default
            });

            EnqueueCallback(delegate {
                document1 = iService.CreateDocument("View1", ViewModelSource.Create(() => new UITestViewModel()
                {
                    Title = "Title1", Parameter = 1
                }));
                document1.Show();
                DispatcherHelper.DoEvents();
                document2 = iService.CreateDocument("View2", ViewModelSource.Create(() => new UITestViewModel()
                {
                    Title = "Title2", Parameter = 2
                }));
                document2.Show();
                DispatcherHelper.DoEvents();
            });
            EnqueueWindowUpdateLayout();
            EnqueueCallback(delegate {
                Assert.AreSame(document2, service.ActiveDocument);
                Assert.AreSame(document2, testClass.ActiveDocument);
                testClass.ActiveDocument = document1;
                DispatcherHelper.DoEvents();
                Assert.AreSame(document1, service.ActiveDocument);
            });
            EnqueueWindowUpdateLayout();
            EnqueueTestComplete();
        }
        public void ActivateDocumentsWhenClosed()
        {
            Window.Show();
            DispatcherHelper.DoEvents();
            List <IDocument>          documents = new List <IDocument>();
            WindowedDocumentUIService service   = CreateService();

            Interaction.GetBehaviors(Window).Add(service);
            IDocumentManagerService iService = service;
            int counter = 0;

            service.ActiveDocumentChanged += (s, e) => counter++;
            for (int i = 0; i < 4; i++)
            {
                documents.Add(iService.CreateDocument("View" + i,
                                                      ViewModelSource.Create(() => new UITestViewModel()
                {
                    Title = "Title" + i, Parameter = i
                })));
                documents[i].Show();
            }
            iService.ActiveDocument = documents[1];
            DispatcherHelper.DoEvents();

            counter = 0;
            documents[1].Close();
            DispatcherHelper.DoEvents();

            Assert.AreEqual(2, counter, "#1");
            Assert.AreEqual(iService.ActiveDocument, documents[3]);
            iService.ActiveDocument = documents[3];
            DispatcherHelper.DoEvents();

            counter = 0;
            documents[3].Close();
            DispatcherHelper.DoEvents();

            Assert.AreEqual(iService.ActiveDocument, documents[2]);
            Assert.AreEqual(2, counter, "#2");
            documents[0].Close();
            documents[2].Close();
        }
        public void WindowStyle()
        {
            EnqueueShowWindow();
            IDocument document = null;

            EnqueueCallback(() => {
                WindowedDocumentUIService service = CreateService();
                Interaction.GetBehaviors(Window).Add(service);
                service.WindowType = typeof(Window);
                Style windowStyle  = new Style(typeof(Window));
                windowStyle.Setters.Add(new Setter(FrameworkElement.TagProperty, "Style Tag"));
                service.WindowStyle = windowStyle;
                document            = service.CreateDocument("EmptyView", new object());
            });
            EnqueueWindowUpdateLayout();
            EnqueueCallback(() => {
                var windowDocument = (WindowedDocumentUIService.WindowDocument)document;
                Assert.AreEqual("Style Tag", windowDocument.Window.RealWindow.Tag);
            });
            EnqueueTestComplete();
        }
        public void WindowStyle()
        {
            EnqueueShowWindow();
            Window.Show();
            IDocument document = null;

            DispatcherHelper.DoEvents();

            WindowedDocumentUIService service = CreateService();

            Interaction.GetBehaviors(Window).Add(service);
            service.WindowType = typeof(Window);
            Style windowStyle = new Style(typeof(Window));

            windowStyle.Setters.Add(new Setter(FrameworkElement.TagProperty, "Style Tag"));
            service.WindowStyle = windowStyle;
            document            = service.CreateDocument("EmptyView", new object());
            DispatcherHelper.DoEvents();

            var windowDocument = (WindowedDocumentUIService.WindowDocument)document;

            Assert.AreEqual("Style Tag", windowDocument.Window.RealWindow.Tag);
        }
        public void ActivateWhenDocumentShow()
        {
            EnqueueShowWindow();
            IDocument document = null;
            WindowedDocumentUIService service = new WindowedDocumentUIService();

            Interaction.GetBehaviors(Window).Add(service);
            IDocumentManagerService iService = service;

            EnqueueCallback(() => {
                document = iService.CreateDocument("View1",
                                                   ViewModelSource.Create(() => new UITestViewModel()
                {
                    Title = "Title1", Parameter = 1
                }));
                document.Show();
            });
            EnqueueWindowUpdateLayout();
            EnqueueCallback(() => {
                Assert.AreEqual(iService.ActiveDocument, document);
                document.Close();
            });
            EnqueueTestComplete();
        }
        public void ActivateWhenDocumentShow()
        {
            Window.Show();
            IDocument document = null;
            WindowedDocumentUIService service = CreateService();

            Interaction.GetBehaviors(Window).Add(service);
            IDocumentManagerService iService = service;

            DispatcherHelper.DoEvents();
            document = iService.CreateDocument("View1",
                                               ViewModelSource.Create(() => new UITestViewModel()
            {
                Title = "Title1", Parameter = 1
            }));
            document.Show();

            DispatcherHelper.DoEvents();
            Assert.AreEqual(iService.ActiveDocument, document);
            Assert.IsNotNull(document.Content);
            Assert.AreEqual(document.Content, ViewHelper.GetViewModelFromView(service.ActiveView));
            Assert.AreEqual(document.Content, ((WindowedDocumentUIService.WindowDocument)document).Window.RealWindow.DataContext);
            document.Close();
        }
        public void SettingActiveDocument()
        {
            Window.Show();
            DispatcherHelper.DoEvents();
            IDocument document1 = null;
            IDocument document2 = null;
            WindowedDocumentUIService service = CreateService();

            Interaction.GetBehaviors(Window).Add(service);
            IDocumentManagerService iService = service;
            int counter = 0;

            iService.ActiveDocumentChanged += (s, e) => counter++;
            document1 = iService.CreateDocument("View1",
                                                ViewModelSource.Create(() => new UITestViewModel()
            {
                Title = "Title1", Parameter = 1
            }));
            document2 = iService.CreateDocument("View2",
                                                ViewModelSource.Create(() => new UITestViewModel()
            {
                Title = "Title2", Parameter = 2
            }));
            document1.Show();
            document2.Show();
            DispatcherHelper.DoEvents();

            Assert.AreEqual(3, counter);
            iService.ActiveDocument = document1;
            DispatcherHelper.DoEvents();

            Assert.AreEqual(iService.ActiveDocument, document1);
            Assert.AreEqual(4, counter);
            document1.Close();
            document2.Close();
        }
        public void SettingActiveDocument() {
            EnqueueShowWindow();
            IDocument document1 = null;
            IDocument document2 = null;
            WindowedDocumentUIService service = new WindowedDocumentUIService();
            Interaction.GetBehaviors(Window).Add(service);
            IDocumentManagerService iService = service;
            int counter = 0;
            EnqueueCallback(() => {
                iService.ActiveDocumentChanged += (s, e) => counter++;
                document1 = iService.CreateDocument("View1",
                    ViewModelSource.Create(() => new UITestViewModel() { Title = "Title1", Parameter = 1 }));
                document2 = iService.CreateDocument("View2",
                    ViewModelSource.Create(() => new UITestViewModel() { Title = "Title2", Parameter = 2 }));
                document1.Show();
                document2.Show();
            });
            EnqueueWindowUpdateLayout();
            EnqueueCallback(() => {
#if !SILVERLIGHT
                Assert.AreEqual(3, counter);
#else
                Assert.AreEqual(2, counter);
#endif
                iService.ActiveDocument = document1;
            });
            EnqueueWindowUpdateLayout();
            EnqueueCallback(() => {
                Assert.AreEqual(iService.ActiveDocument, document1);
#if !SILVERLIGHT
                Assert.AreEqual(4, counter);
#else
                Assert.AreEqual(3, counter);
#endif
                document1.Close();
                document2.Close();
            });
            EnqueueTestComplete();
        }
 public void WindowStyleSelector() {
     WindowedDocumentUIService service = new WindowedDocumentUIService();
     Interaction.GetBehaviors(Window).Add(service);
     service.WindowType = typeof(Window);
     Style windowStyle = new Style(typeof(Window));
     windowStyle.Setters.Add(new Setter(System.Windows.Window.TagProperty, "Style Selector Tag"));
     service.WindowStyleSelector = new TestStyleSelector() { Style = windowStyle };
     IDocument document = service.CreateDocument("EmptyView", new object());
     var windowDocument = (WindowedDocumentUIService.WindowDocument)document;
     Assert.AreEqual("Style Selector Tag", windowDocument.window.Tag);
 }
 void DoCloseTest(bool? allowClose, bool destroyOnClose, bool destroyed, Action<IDocument, bool> closeMethod) {
     EnqueueShowWindow();
     IDocumentManagerService service = null;
     bool closeChecked = false;
     bool destroyCalled = false;
     IDocument document = null;
     EnqueueCallback(() => {
         WindowedDocumentUIService windowedDocumentUIService = new WindowedDocumentUIService();
         Interaction.GetBehaviors(Window).Add(windowedDocumentUIService);
         service = windowedDocumentUIService;
         TestDocumentContent viewModel = new TestDocumentContent(() => {
             closeChecked = true;
             return allowClose != null && allowClose.Value;
         }, () => {
             destroyCalled = true;
         });
         document = service.CreateDocument("EmptyView", viewModel);
         document.Show();
     });
     EnqueueWindowUpdateLayout();
     EnqueueCallback(() => {
         document.DestroyOnClose = destroyOnClose;
         closeMethod(document, allowClose == null);
         Assert.AreEqual(allowClose != null, closeChecked);
         Assert.AreEqual(destroyed, destroyCalled);
         Assert.AreEqual(!destroyed, service.Documents.Contains(document));
     });
     EnqueueTestComplete();
 }
        public void ActivateDocumentsWhenClosed() {
            EnqueueShowWindow();
            List<IDocument> documents = new List<IDocument>();
            WindowedDocumentUIService service = new WindowedDocumentUIService();
            Interaction.GetBehaviors(Window).Add(service);
            IDocumentManagerService iService = service;
            int counter = 0;
            EnqueueCallback(() => {
                service.ActiveDocumentChanged += (s, e) => counter++;
                for(int i = 0; i < 4; i++) {
                    documents.Add(iService.CreateDocument("View" + i,
                    ViewModelSource.Create(() => new UITestViewModel() { Title = "Title" + i, Parameter = i })));
                    documents[i].Show();
                }
                iService.ActiveDocument = documents[1];

            });
            EnqueueWindowUpdateLayout();
            EnqueueCallback(() => {
                counter = 0;
                documents[1].Close();
            });
            EnqueueWindowUpdateLayout();
            EnqueueCallback(() => {
                Assert.AreEqual(2, counter);
                Assert.AreEqual(iService.ActiveDocument, documents[3]);
                iService.ActiveDocument = documents[3];
            });
            EnqueueWindowUpdateLayout();
            EnqueueCallback(() => {
                counter = 0;
                documents[3].Close();
            });
            EnqueueWindowUpdateLayout();
            EnqueueCallback(() => {
                Assert.AreEqual(iService.ActiveDocument, documents[2]);
                Assert.AreEqual(2, counter);
                documents[0].Close();
                documents[2].Close();
            });
            EnqueueTestComplete();
        }