private void ProjectExplorer_OpenDocument(Platform.Models.Projects.ProjectItemType type, string documentName, string documentPath)
        {
            var group = new RadPaneGroup();

            if (DocumentHost.Items.Count == 0)
            {
                DocumentHost.Items.Add(group);
            }
            else
            {
                group = DocumentHost.Items[0] as RadPaneGroup;
            }

            var documentPane = new RadDocumentPane()
            {
                Title = documentName
            };
            var documentControl = BootStrapper.Resolve <LayoutingDocumentControl>(new Parameter[] {
                new NamedParameter(nameof(type), type),
                new NamedParameter(nameof(documentPath), documentPath)
            });

            documentControl.ViewModel.ViewModelMouseDown += ViewModel_ViewModelMouseDown;

            documentPane.Content = documentControl;
            group.Items.Add(documentPane);

            if (_propertiesToolWindowControl != null)
            {
                _propertiesToolWindowControl.ViewModel.UpdateEditableViewModel(null);
            }
        }
Esempio n. 2
0
        private static void HandleException(Exception exception)
        {
            Logger.Error(exception);

            var messageService = BootStrapper.Resolve <IMessageService>();

            messageService.Post(Constants.UI.ExceptionTitle, MessageViewModel.CreateExceptionMessage(exception));

            //BootStrapper.Resolve<ISchedulerService>()
            //    .Dispatcher
            //    .Schedule(exception, (scheduler, state) =>
            //    {
            //        var messageService = BootStrapper.Resolve<IMessageService>();

            //        var parameters = new Parameter[]
            //        {
            //            new NamedParameter("exception", state)
            //        };

            //        var viewModel = BootStrapper.Resolve<IExceptionViewModel>(parameters);

            //        Observable.Return(viewModel)
            //            .SelectMany(x => x.Closed, (x, y) => x)
            //            .Take(1)
            //            .Subscribe(x => x.Dispose());

            //        messageService.Post(Constants.UI.ExceptionTitle, viewModel);

            //        return Disposable.Empty;
            //    });
        }
Esempio n. 3
0
        protected override void OnStartup(StartupEventArgs args)
        {
            using (AppSolutions.Desktop.Designer.Helpers.Duration.Measure(Logger, "OnStartup - " + GetType().Name))
            {
                Logger.Info("Starting");

                // ReSharper disable once RedundantToStringCallForValueType
                var dispatcherMessage =
                    $"Dispatcher managed thread identifier = {Thread.CurrentThread.ManagedThreadId.ToString()}";

                Logger.Info(dispatcherMessage);
                Debug.WriteLine(dispatcherMessage);

                Logger.Info($"WPF rendering capability (tier) = {(RenderCapability.Tier / 0x10000).ToString()}");
                RenderCapability.TierChanged += (s, a) =>
                                                Logger.Info($"WPF rendering capability (tier) = {(RenderCapability.Tier / 0x10000).ToString()}");

                base.OnStartup(args);

                BootStrapper.Start();

                var gestureService = BootStrapper.Resolve <IGestureService>();

                AppSolutions.Desktop.Designer.Extensions.ObservableExtensions.GestureService = gestureService;

                // Load the application settings asynchronously
                //LoadSettingsAsync(schedulerService)
                //    .Wait();

                var window = BootStrapper.Resolve <MainWindow>();

                window.Closed += HandleClosed;
                Current.Exit  += HandleExit;

                // Let's go...
                window.Show();


#if DEBUG
                ObserveUiFreeze()
                .DisposeWith(_disposable);
#endif
                ObserveCultureChanges()
                .DisposeWith(_disposable);

                Logger.Info("Started");
            }
        }
        public MainWindow(IMainViewModel viewModel)
        {
            InitializeComponent();

            DataContext = viewModel;

            var welcomeScreen = BootStrapper.Resolve <WelcomeScreenControl>();

            WelcomeControlContainer.Content = welcomeScreen;

            // LeftContainer
            var group = new RadPaneGroup();
            var projectExplorerPane = new RadPane();

            projectExplorerPane.Header = "Project Explorer";
            var projectExplorer = BootStrapper.Resolve <ProjectExplorerToolWindowControl>();

            projectExplorerPane.Content             = projectExplorer;
            projectExplorer.ViewModel.OpenDocument += ProjectExplorer_OpenDocument;
            group.Items.Add(projectExplorerPane);
            LeftContainer.Items.Add(group);

            // BottomContainer
            group = new RadPaneGroup();
            var outputPane = new RadPane();

            outputPane.Header  = "Output";
            outputPane.Content = BootStrapper.Resolve <OutputToolWindowControl>();
            group.Items.Add(outputPane);

            var errorPane = new RadPane();

            errorPane.Header = "Error List";
            group.Items.Add(errorPane);

            BottomContainer.Items.Add(group);

            // RightContainer
            group = new RadPaneGroup();
            var propertiesPane = new RadPane();

            propertiesPane.Header        = "Properties";
            _propertiesToolWindowControl = BootStrapper.Resolve <PropertiesToolWindowControl>();
            propertiesPane.Content       = _propertiesToolWindowControl;
            group.Items.Add(propertiesPane);
            RightContainer.Items.Add(group);
        }