コード例 #1
0
ファイル: EditorProvider.cs プロジェクト: zhangf911/gemini
        public IDocument Open(string path)
        {
            var editor = new EditorViewModel();

            editor.Open(path);
            return(editor);
        }
コード例 #2
0
 public EditorWindow()
 {
     InitializeComponent();
     _currentContext = (EditorViewModel)this.DataContext;
     _graphicsWindow = new GraphicsWindow(_currentContext);
     _graphicsWindow.Show();
 }
コード例 #3
0
ファイル: EditorProvider.cs プロジェクト: zhangf911/gemini
        public IDocument CreateNew(string name)
        {
            var editor = new EditorViewModel();

            editor.New(name);
            return(editor);
        }
コード例 #4
0
        public ResultViewModel Post([FromBody] EditorViewModel model)
        {
            model.Validate();

            if (model.Invalid)
            {
                return(new ResultViewModel
                {
                    Success = false,
                    Message = "Não foi possível cadastrar o todo",
                    Data = model.Notifications
                });
            }

            var todo = new TodoItem();

            todo.Name       = model.Name;
            todo.IsComplete = model.IsComplete;

            _repository.Save(todo);

            return(new ResultViewModel
            {
                Success = true,
                Message = "Todo cadastrado com sucesso",
                Data = todo
            });
        }
コード例 #5
0
        public async Task <IActionResult> Export(int projectId, bool jsonExport = true)
        {
            EditorViewModel model = EditorBL.EditorData(_context, projectId, $"{_env.WebRootPath}");

            model.Mode = EditorMode.Export;

            if (model.ProjectData == null)
            {
                return(RedirectToAction("Index", "Projects"));
            }

            string redirect = "";

            if (jsonExport)
            {
                redirect = EditorBL.ExportProjectJson(_context, projectId, $"{_env.WebRootPath}");
            }
            else
            {
                string htmlContent = await RenderPartialViewToString("Preview", model);

                redirect = EditorBL.ExportProjectHtml(projectId, $"{_env.WebRootPath}", htmlContent, model.EditorData.CustomCss);
            }

            ProjectsBL.SetProjectStatus(_context, projectId, Models.Enums.ProjectStatus.Exported, true);

            return(RedirectToAction("Index", "Projects", new { RedirectTo = redirect }));
        }
コード例 #6
0
        public MainWindow(EditorViewModel viewModel)
        {
            InitializeComponent();
            ViewModel = viewModel;
            viewModel.RequestDelayedWork += (sender, e) => deferredActions.Add(e);
            DataContext = viewModel;
            viewModel.MoveFocusToFind += (sender, e) => FocusTextBox(FindBox);
            viewModel.GotoViewModel.MoveFocusToGoto += FocusGotoBox;
            viewModel.PropertyChanged += ViewModelPropertyChanged;

            GotoPanel.IsVisibleChanged    += AnimateFocusToCorner;
            FindPanel.IsVisibleChanged    += AnimateFocusToCorner;
            MessagePanel.IsVisibleChanged += AnimateFocusToCorner;
            ErrorPanel.IsVisibleChanged   += AnimateFocusToCorner;

            viewModel.PropertyChanged += (sender, e) => {
                if (e.PropertyName == nameof(viewModel.InformationMessage) &&
                    MessagePanel.IsVisible &&
                    !string.IsNullOrEmpty(viewModel.InformationMessage)
                    )
                {
                    AnimateFocusToCorner(MessagePanel, default);
                }
            };

            Application.Current.DispatcherUnhandledException += (sender, e) => {
                File.AppendAllText("crash.log", e.Exception.Message + Environment.NewLine + e.Exception.StackTrace);
                FileSystem.ShowCustomMessageBox("An unhandled error occured. Please report it on Discord or open an issue on GitHub." + Environment.NewLine +
                                                "HexManiac might be in a bad state. You should close as soon as possible." + Environment.NewLine +
                                                "The error has been logged to crash.log", showYesNoCancel: false);
                e.Handled = true;
            };

            FillQuickEditMenu();
        }
コード例 #7
0
        public IDocument Create(string path)
        {
            var editor = new EditorViewModel(_propertyGrid, _extendedShell);

            editor.Open(path);
            return(editor);
        }
コード例 #8
0
        public nint GetHeight(EditorViewModel viewModel)
        {
            if (!(viewModel is PropertyGroupViewModel gvm))
            {
                throw new ArgumentException("Invalid viewmodel type");
            }

            Type        propertyVmType = gvm.Properties[0].GetType();
            IEditorView view;

            if (propertyVmType == ViewModel?.Properties[0].GetType())
            {
                if (this.hostedEditor == null)
                {
                    UpdateHosted();
                }

                view = this.hostedEditor;
            }
            else
            {
                view = this.selector.GetEditor(this.hostResources, gvm.Properties[0]);
            }

            nint editorHeight = view.GetHeight(gvm.Properties[0]);

            return(((nint)this.table.RowHeight * gvm.Properties.Count) + editorHeight);
        }
コード例 #9
0
        public EditorView(EditorViewModel evm)
        {
            InitializeComponent();
            _viewModel  = evm;
            DataContext = evm;
            toolbox     = new ToolBox(this);



            strokeMenu          = new StrokeContextMenu(this);
            _undoStack          = new Stack <KeyValuePair <Stroke, int> >(20);
            _redoStack          = new Stack <KeyValuePair <Stroke, int> >(20);
            _highlighterStrokes = new BlockingCollection <Stroke>();
            inkDispatcher       = icCanvas.Dispatcher;
            InitializeHighlightManager();

            // Bind inkcanvas stroke to activecanvas
            RebindStrokes();

            Binding newBinding = new Binding();

            newBinding        = new Binding("allCanvasesView");
            newBinding.Source = _viewModel;
            lvCanvasList.SetBinding(ListView.ItemsSourceProperty, newBinding);

            newBinding        = new Binding("SelectedWSName");
            newBinding.Source = _viewModel;
            cboWSNameSelector.SetBinding(ComboBox.SelectedItemProperty, newBinding);

            DBOperations.SetUpConnection();
            dtKnowledge = new DataTable();
            //UpdateListViewData();
            TimerSetUp();
            //cmdInfo.IsEnabled = false;
        }
コード例 #10
0
ファイル: App.xaml.cs プロジェクト: hjk321/HexManiacAdvance
        private void UpdateThemeDictionary(EditorViewModel viewModel)
        {
            if (Resources.MergedDictionaries.Count == 0)
            {
                Resources.MergedDictionaries.Add(new ResourceDictionary());
            }

            var sources = new List <string> {
                nameof(viewModel.Theme.Primary),
                nameof(viewModel.Theme.Secondary),
                nameof(viewModel.Theme.Background),
                nameof(viewModel.Theme.Backlight),
                nameof(viewModel.Theme.Error),
                nameof(viewModel.Theme.Text1),
                nameof(viewModel.Theme.Text2),
                nameof(viewModel.Theme.Data1),
                nameof(viewModel.Theme.Data2),
                nameof(viewModel.Theme.Accent),
                nameof(viewModel.Theme.Stream1),
                nameof(viewModel.Theme.Stream2),
                nameof(viewModel.Theme.EditBackground),
            };

            var dict  = new ResourceDictionary();
            var theme = viewModel.Theme.GetType();

            sources.ForEach(source => {
                var rawValue = (string)theme.GetProperty(source).GetValue(viewModel.Theme);
                dict.Add(source, Brush(rawValue));
                dict.Add(source + "Color", ColorConverter.ConvertFromString(rawValue));
            });

            Resources.MergedDictionaries[0] = dict;
        }
コード例 #11
0
        public GameStudioWindow(EditorViewModel editor)
        {
            if (editor == null)
            {
                throw new ArgumentNullException(nameof(editor));
            }
            if (editor.Session == null)
            {
                throw new ArgumentException($@"A valid session must exist before creating a {nameof(GameStudioWindow)}", nameof(editor));
            }
            DataContext = editor; // Must be set before calling InitializeComponent

            dockingLayout       = new DockingLayoutManager(this, editor.Session);
            assetEditorsManager = new AssetEditorsManager(dockingLayout, editor.Session);
            editor.ServiceProvider.Get <IEditorDialogService>().AssetEditorsManager = assetEditorsManager;

            OpenDebugWindowCommand     = new AnonymousCommand(editor.ServiceProvider, OpenDebugWindow);
            CreateTestAssetCommand     = new AnonymousCommand(editor.ServiceProvider, CreateTestAsset);
            CreateUnitTestAssetCommand = new AnonymousCommand(editor.ServiceProvider, CreateUnitTestAsset);
            BreakDebuggerCommand       = new AnonymousCommand(editor.ServiceProvider, BreakDebugger);
            EditorSettings.ResetEditorLayout.Command = new AnonymousTaskCommand(editor.ServiceProvider, ResetAllLayouts);

            InitializeComponent();
            Application.Current.Activated += (s, e) => editor.ServiceProvider.Get <IEditorDialogService>().ShowDelayedNotifications();
            Loaded += GameStudioLoaded;

            OpenMetricsProjectSession(editor);
        }
コード例 #12
0
        public void WhenContentIsNotReadyTheProjectSelectionComboBoxIsDisabled()
        {
            var mockPlugins = GetEditorPluginLoaderMock();
            var model       = new EditorViewModel(mockPlugins, new MockSettings());

            Assert.AreEqual(false, model.IsContentReady);
        }
コード例 #13
0
        public IActionResult Index()
        {
            //using (var scope = _noteSaverDbContext.Database.BeginTransaction())
            //{
            //    var list = new List<int>() { 2 };

            //    var joinedList = list
            //        .Join(_noteSaverDbContext.InnerContents, c => c, l => l.Id, (c, l) => new { c, l })
            //        .ToList();

            //    var joinedList2 = _noteSaverDbContext.InnerContents
            //        .Join(list.Distinct(), c => c.Id, l => l, (c, l) => new { c, l })
            //        .ToList();

            //    scope.Commit();
            //}



            var content = _noteSaverDbContext.InnerContents.FirstOrDefault();
            var editor  = new EditorViewModel()
            {
                Content = ""
            };

            if (content != null)
            {
                editor.Content = content.InnerText;
            }

            return(View(editor));
        }
コード例 #14
0
ファイル: RadioController.cs プロジェクト: kodebot/exp-web
        public IActionResult Add()
        {
            var viewModel = new EditorViewModel();

            SetupEditorViewModelSelectListItems(viewModel);
            return(View("Editor", viewModel));
        }
コード例 #15
0
        public void ViewPortWarnsIfLoadedMatchedWordValueDoesNotMatch()
        {
            // Arrange
            var data   = new byte[0x200];
            var model  = new PokemonModel(data);
            var change = new ModelDelta();

            ArrayRun.TryParse(model, "[a:]8", 0x10, null, out var table);
            model.ObserveAnchorWritten(change, "table", table);
            change.AddMatchedWord(model, 0, "table");
            model.ObserveRunWritten(change, new WordRun(0, "table"));

            fileSystem.MetadataFor = name => model.ExportMetadata().Serialize();
            fileSystem.OpenFile    = (name, extensions) => new LoadedFile(name, data);
            var editor = new EditorViewModel(fileSystem);

            // change the data so that the viewPort will notice something weird
            change.ChangeData(model, 0, 4);

            // Act
            editor.Open.Execute("text.gba");

            // Assert
            Assert.True(editor.ShowMessage);
        }
コード例 #16
0
ファイル: UserScreenViewModel.cs プロジェクト: sm-g/ura
        public UserScreenViewModel()
        {
            Editor = new EditorViewModel <UserVM>(controller.Users.Select(u => CreateVM(u)),
                                                  "Выберите пользователя:",
                                                  () =>
            {
                var ent = controller.CreateUser();
                return(CreateVM(ent));
            });
            Buttons = new AddButtonsViewModel <UserVM>(OnAddRoles, "+ роли", OnAddAbilities, "+ возможности");

            Editor.PropertyChanged      += Editor_PropertyChanged;
            controller.UserRolesChanged += (s, e1) =>
            {
                SetupUserRoles();
                SetupRoleAbilities();
            };
            controller.UserAbilitiesChanged += (s, e1) =>
            {
                SetupRoleAbilities();
            };
            // возможности в роли не меняются
            controller.DeprecatedChanged += (s, e1) =>
            {
                if (e1.entity == CurrentEntity.user)
                {
                    CurrentEntity.OnDeprecatedChangedByCode();
                }
            };

            AfterConstructed();
        }
コード例 #17
0
        PropertyEditorControl GetEditor(EditorViewModel vm, NSOutlineView outlineView)
        {
            Type[] genericArgs = null;
            Type   controlType;
            Type   propertyType = vm.GetType();

            if (!ViewModelTypes.TryGetValue(propertyType, out controlType))
            {
                if (propertyType.IsConstructedGenericType)
                {
                    genericArgs  = propertyType.GetGenericArguments();
                    propertyType = propertyType.GetGenericTypeDefinition();
                    ViewModelTypes.TryGetValue(propertyType, out controlType);
                }
            }
            if (controlType == null)
            {
                return(null);
            }

            if (controlType.IsGenericTypeDefinition)
            {
                if (genericArgs == null)
                {
                    genericArgs = propertyType.GetGenericArguments();
                }
                controlType = controlType.MakeGenericType(genericArgs);
            }

            return(SetUpEditor(controlType, vm, outlineView));
        }
コード例 #18
0
 public void OnHideSystemPropertiesChanged()
 {
     if (_queryResult != null)
     {
         EditorViewModel.SetText(_queryResult, HideSystemProperties);
     }
 }
コード例 #19
0
        public async Task <bool> StartDebug(EditorViewModel editor, ProjectViewModel currentProject, LoggerResult logger)
        {
            if (currentProject == null)
            {
                await editor.Session.Dialogs.MessageBox(Tr._p("Message", "An executable project must be set as current project in the session explorer in order to process build."),
                                                        MessageBoxButton.OK, MessageBoxImage.Information);

                return(false);
            }

            try
            {
                var projectWatcher = new ProjectWatcher(currentProject.Session, false);
                await projectWatcher.Initialize();

                var executableOutputPath = Path.GetDirectoryName(projectWatcher.CurrentGameExecutable.OutputFilePath);

                var debuggerProcess = await GetDebuggerProcess(editor);

                var projectCouldFirstCompile = new TaskCompletionSource <bool>();
                Task.Run(() => StartDebugHost(executableOutputPath, projectWatcher, projectCouldFirstCompile, RecompilationDelay, debuggerProcess, logger)).Forget();

                return(await projectCouldFirstCompile.Task);
            }
            catch
            {
                return(false);
            }
        }
コード例 #20
0
 private static void DebugLog(EditorViewModel editor, params string[] text)
 {
     if (editor.LogAppStartupProgress)
     {
         File.AppendAllLines("HexManiacAdvance.debug.txt", text);
     }
 }
コード例 #21
0
        public MainWindow(EditorViewModel viewModel)
        {
            InitializeComponent();
            ViewModel = viewModel;
            viewModel.RequestDelayedWork += (sender, e) => deferredActions.Add(e);
            DataContext = viewModel;
            viewModel.MoveFocusToFind               += (sender, e) => FocusTextBox(FindBox);
            viewModel.MoveFocusToHexConverter       += (sender, e) => FocusTextBox(HexBox);
            viewModel.GotoViewModel.MoveFocusToGoto += FocusGotoBox;
            viewModel.PropertyChanged               += ViewModelPropertyChanged;

            GotoPanel.IsVisibleChanged    += AnimateFocusToCorner;
            FindPanel.IsVisibleChanged    += AnimateFocusToCorner;
            HexConverter.IsVisibleChanged += AnimateFocusToCorner;
            HexBox.GotFocus += (sender, e) => HexBox.SelectAll();
            DecBox.GotFocus += (sender, e) => DecBox.SelectAll();
            MessagePanel.IsVisibleChanged += AnimateFocusToCorner;
            ErrorPanel.IsVisibleChanged   += AnimateFocusToCorner;

            viewModel.PropertyChanged += (sender, e) => {
                if (e.PropertyName == nameof(viewModel.InformationMessage) &&
                    MessagePanel.IsVisible &&
                    !string.IsNullOrEmpty(viewModel.InformationMessage)
                    )
                {
                    AnimateFocusToCorner(MessagePanel, default);
                }
            };

            Application.Current.DispatcherUnhandledException += HandleException;
            Loaded += SetupDebugListener;

            FillQuickEditMenu();
        }
コード例 #22
0
        private void InitializeEditor()
        {
            _vm = new EditorViewModel();

            _vm.Editor = new SpiroEditor()
            {
                State      = new EditorState(),
                Measure    = new EditorMeasure(),
                Invalidate = () => _canvas.InvalidateVisual(),
                Drawing    = SpiroDrawing.Create(600, 600),
                Data       = new Dictionary <SpiroShape, string>(),
                Knots      = new Dictionary <SpiroShape, IList <SpiroKnot> >()
            };

            _vm.InvalidateCommand = Command.Create(_vm.Editor.Invalidate);
            _vm.NewCommand        = Command.Create(New);
            _vm.OpenCommand       = Command.Create(Open);
            _vm.SaveAsCommand     = Command.Create(SaveAs);
            _vm.ExportCommand     = Command.Create(Export);
            _vm.ExitCommand       = Command.Create(Exit);
            _vm.DeleteCommand     = Command.Create(_vm.Editor.Delete);
            _vm.IsStrokedCommand  = Command.Create(_vm.Editor.ToggleIsStroked);
            _vm.IsFilledCommand   = Command.Create(_vm.Editor.ToggleIsFilled);
            _vm.IsClosedCommand   = Command.Create(_vm.Editor.ToggleIsClosed);
            _vm.IsTaggedCommand   = Command.Create(_vm.Editor.ToggleIsTagged);
            _vm.ToolCommand       = Command <string> .Create(_vm.Editor.ToggleTool);

            _vm.PointTypeCommand = Command <string> .Create(_vm.Editor.TogglePointType);

            _vm.ExecuteScriptCommand = Command <string> .Create(_vm.Editor.ExecuteScript);
        }
コード例 #23
0
        private static void OpenMetricsProjectSession(EditorViewModel editor)
        {
            var projectUid = editor.Session.CurrentPackage?.Id ?? Guid.Empty;

            var execProfiles     = editor.Session.AllPackages.SelectMany(x => x.ExecutableProfiles);
            var sessionPlatforms = new HashSet <PlatformType>();

            foreach (var execProfile in execProfiles)
            {
                if (execProfile.Platform != PlatformType.Shared)
                {
                    sessionPlatforms.Add(execProfile.Platform);
                }
            }
            if (sessionPlatforms.Count > 0)
            {
                var metricData = new StringBuilder();
                foreach (var sessionPlatform in sessionPlatforms)
                {
                    metricData.Append($"#platform:{sessionPlatform}|");
                }
                metricData.Remove(metricData.Length - 1, 1);

                XenkoGameStudio.MetricsClient?.OpenProjectSession($"#projectUid:{projectUid}|{metricData}");
            }
            else
            {
                XenkoGameStudio.MetricsClient?.OpenProjectSession($"#projectUid:{projectUid}|#platform:None");
            }
        }
コード例 #24
0
        public ActionResult Index(int id = 0)
        {
            Class classObj;

            if (!Utilities.GetClassObjFromId(db, id, out classObj))
            {
                return(HttpNotFound());
            }

            Instructor instructorObj;

            if (!Utilities.GetInstructorObjFromEmail(db, classObj.Instructor, out instructorObj))
            {
                return(HttpNotFound());
            }

            EditorViewModel editorViewData = new EditorViewModel();

            //data
            editorViewData.classObj      = classObj;
            editorViewData.instructorObj = instructorObj;
            editorViewData.announcements = V1.DeserializeAnnouncements(classObj.Announcements);
            editorViewData.assignments   = V1.DeserializeAssignments(classObj.Assignments);
            editorViewData.subscribers   = V1.DeserializeSubscribers(classObj.Subscribers);
            editorViewData.fullUrl       = Utilities.GetFullUrl(classObj.Url);
            //labels
            editorViewData.AnnouncementsLbl = Constants.AnnouncementsLbl;
            editorViewData.AssignmentsLbl   = Constants.AssignmentsLbl;
            editorViewData.InstructorLbl    = Constants.InstructorLbl;

            return(View(editorViewData));
        }
コード例 #25
0
ファイル: EditorModel.cs プロジェクト: MMDaemon/Voxel-Editor
        private EditorViewModel CreateViewModel()
        {
            EditorViewModel viewModel = new EditorViewModel(_lastUpdateTime, _camera.Position, _camera.CalcMatrix(), _world.UpdatedChunks, VoxelSize, _world.WorldSize, _materialID, _materialAmount, _raytraceVoxelPosition, _raytracedVoxel);

            _world.ResetUpdateList();
            return(viewModel);
        }
コード例 #26
0
        /// <summary>
        ///     Open the selected file and display it if you can do it
        /// </summary>
        private void SelectedItemChanged()
        {
            var s = Path.GetExtension(SelectedItemPath);

            if (SelectedItemIsFolder || s == null)
            {
                return;
            }
            var extension = s.ToLower();

            switch (extension)  //Only open these extensions
            {
            case ".html":
            case ".css":
            case ".js":
            case ".ws":
                break;

            default:
                return;
            }

            foreach (var doc in ProjectModel.Instance.Documents)
            {
                doc.IsSelected = false;
            }

            EditorViewModel myEditor = ProjectModel.Instance.SearchOrCreateDocument(SelectedItemPath);

            myEditor.IsSelected = true;
        }
コード例 #27
0
 public void DefaultProjectToLoginWithIsSelectedIfUserHasNotLoggedInYetOrLoggedOut()
 {
     var mockPlugins = GetEditorPluginLoaderMock();
     var model = new EditorViewModel(mockPlugins, new MockSettings());
     model.SelectedProject = new ProjectNameAndFontWeight("", FontWeights.Normal);
     Assert.AreEqual("GhostWars", model.SelectedProject);
 }
コード例 #28
0
        public EditorView()
        {
            InitializeComponent();

            BindingContext      = vm = new EditorViewModel();
            vm.PropertyChanged += HandlePropertyChanged;
        }
コード例 #29
0
        private NSView GetEditor(string identifier, EditorViewModel vm, NSOutlineView outlineView)
        {
            var view = outlineView.MakeView(identifier, this);

            if (view != null)
            {
                return(view);
            }

            if (vm != null)
            {
                IEditorView editor = this.editorSelector.GetEditor(this.hostResources, vm);

                var editorControl = editor?.NativeView as PropertyEditorControl;
                if (editorControl != null)
                {
                    editorControl.TableView = outlineView;
                }
                else if (editor?.NativeView != null)
                {
                    editor.NativeView.Identifier = identifier;
                    return(editor.NativeView);
                }

                return(new EditorContainer(this.hostResources, editor)
                {
                    Identifier = identifier
                });
            }
            else
            {
                return(new PanelHeaderEditorControl(this.hostResources));
            }
        }
コード例 #30
0
        public MainViewModel()
        {
            VirtualMachine machine = new VirtualMachine();

            EditorViewModel = new EditorViewModel(machine);
            StackViewModel  = new StackViewModel(EditorViewModel);
        }
コード例 #31
0
        private static EditorViewModel GetViewModel(string fileName, int address, WindowsFileSystem fileSystem, bool[] options)
        {
            bool useMetadata = options[0];
            bool showDevMenu = options[1];

            if (fileName != string.Empty)
            {
                fileName = Path.GetFullPath(fileName);
            }
            SetInitialWorkingDirectory();
            var editor = new EditorViewModel(fileSystem, fileSystem, allowLoadingMetadata: useMetadata)
            {
                ShowDeveloperMenu = showDevMenu
            };

            DebugLog(editor, "------");
            DebugLog(editor, fileName);
            CheckIsNewerVersionAvailable(editor);
            if (!File.Exists(fileName))
            {
                return(editor);
            }
            DebugLog(editor, "File Exists");
            TryOpenFile(editor, fileSystem, fileName, address);
            return(editor);
        }
コード例 #32
0
		public void ToggleMaximize(bool moveWindowToTop, EditorViewModel viewModel)
		{
			if (isMaximized)
				RestoreWindowLocation(moveWindowToTop);
			else
				MaximizeWindow();
			viewModel.UpdateBorderThicknessOfChromeStyle();
		}
コード例 #33
0
 public IntellisenseViewModel(EditorModel editor, EditorViewModel viewModel)
 {
     completionData = new List<CompletionDataViewModel>();
     completionAssistant = new CompletionAssistantViewModel(this);
     editorViewModel = viewModel;
     this.editor = editor;
     isVisible = false;
 }
コード例 #34
0
 public void CreateEditorPluginEntryFromLoadedPlugins()
 {
     var mockPlugins = GetEditorPluginLoaderMock();
     var model = new EditorViewModel(mockPlugins, new MockSettings());
     model.AddAllPlugins();
     Assert.AreEqual(1, model.EditorPlugins.Count);
     Assert.AreEqual("Mock Plugin", model.EditorPlugins[0].ShortName);
     Assert.AreEqual("Mock.png", model.EditorPlugins[0].Icon);
     Assert.AreEqual(typeof(MockEditorPluginView), model.EditorPlugins[0].GetType());
 }
コード例 #35
0
        protected override void OnDetachedFromVisualTree(VisualTreeAttachmentEventArgs e)
        {
            editor.EditorScrolled -= Editor_EditorScrolled;
            editor.CaretChangedByPointerClick -= Editor_CaretChangedByPointerClick;

            editor = null;
            editorViewModel = null;

            disposables.Dispose();
        }
コード例 #36
0
        protected override void OnDetaching()
        {
            editorVm = null;

            if (editor != null)
            {
                editor.DataContextChanged -= Editor_DataContextChanged;

                editor = null;
            }

            base.OnDetaching();
        }
コード例 #37
0
        protected override void OnAttachedToVisualTree(VisualTreeAttachmentEventArgs e)
        {
            editor = this.Find<TextEditor.TextEditor>("editor");

            editor.CaretChangedByPointerClick += Editor_CaretChangedByPointerClick;
            editor.EditorScrolled += Editor_EditorScrolled;

            editorViewModel = DataContext as EditorViewModel;

            if (editorViewModel != null && editor != null)
            {
                editorViewModel.Model.Editor = editor;
                editor.Focus();
            }
        }
コード例 #38
0
		public void PopUpNotificationForUpdatedContentDoesNotShowUpInitially()
		{
			var mockPlugins = GetEditorPluginLoaderMock();
			var model = new EditorViewModel(mockPlugins, new MockSettings());
			Assert.IsTrue(string.IsNullOrEmpty(model.PopupText));
			Assert.AreEqual(Visibility.Hidden, model.PopupVisibility);
		}
コード例 #39
0
        //Private
        private EditorViewModel GetEditor(ViewModelConfig viewModelConfig, PropertyInfo prop, Type type)
        {
            var detailViewAttr = prop.GetCustomAttribute<DetailViewAttribute>();

            var systemPropertyAttr = prop.GetCustomAttribute<SystemPropertyAttribute>();

            if (detailViewAttr == null && systemPropertyAttr != null)
            {
                detailViewAttr = new DetailViewAttribute()
                {
                    Name = prop.Name,
                    Visible = false
                };
            }

            if (detailViewAttr != null)
            {
                var maxLengthAttr = prop.GetCustomAttribute<MaxLengthAttribute>();
                var jsonIgnoreAttr = prop.GetCustomAttribute<JsonIgnoreAttribute>();

                bool hideLabel = detailViewAttr.HideLabel;

                if (!hideLabel)
                    hideLabel = String.IsNullOrEmpty(detailViewAttr.Name);

                var editor = new EditorViewModel
                {
                    Mnemonic = detailViewAttr.Mnemonic,
                    ParentViewModelConfig = viewModelConfig,
                    Title = detailViewAttr.Name ?? prop.Name,
                    Description = detailViewAttr.Description,
                    PropertyName = prop.Name,
                    PropertyType = prop.PropertyType,
                    IsLabelVisible = !hideLabel,
                    TabName = detailViewAttr.TabName ?? "[0]Основное",
                    GroupName = detailViewAttr.GroupName ?? Guid.NewGuid().ToString("N"),
                    IsReadOnly = !prop.CanWrite || detailViewAttr.ReadOnly,
                    IsRequired = detailViewAttr.Required,
                    Order = detailViewAttr.Order,
                    MaxLength = maxLengthAttr != null ? (int?)maxLengthAttr.Length : null,
                    DeferredLoading = detailViewAttr.DeferredLoading,
                    Width = detailViewAttr.Width != 0 ? (int?)detailViewAttr.Width : null,
                    Height = detailViewAttr.Height != 0 ? (int?)detailViewAttr.Height : null,
                    JsonIgnore = jsonIgnoreAttr != null,
                    IsSystemPropery = systemPropertyAttr != null,
                    Visible = detailViewAttr.Visible,
                    EditorType =
                        prop.PropertyType.IsBaseCollection()
                            ? prop.PropertyType.GetGenericType().GenericTypeArguments[0]
                            : prop.PropertyType,
                    Relationship = GetRelationship(prop.PropertyType, type),
                };

                var dataTypeAttr = prop.GetCustomAttribute<PropertyDataTypeAttribute>();

                if (dataTypeAttr == null)
                {
                    if (editor.EditorType == typeof(string) && editor.MaxLength == null)
                        editor.EditorTemplate = "MultilineText";
                    else if (editor.EditorType == typeof(int) || editor.EditorType == typeof(int?))
                        editor.EditorTemplate = "Integer";
                    else if (editor.EditorType == typeof(decimal) || editor.EditorType == typeof(decimal?))
                        editor.EditorTemplate = "Currency";
                    else if (editor.EditorType == typeof(double) || editor.EditorType == typeof(double?))
                        editor.EditorTemplate = "Double";
                    else if (editor.EditorType == typeof(DateTime) || editor.EditorType == typeof(DateTime?))
                        editor.EditorTemplate = "Date";
                    else if (editor.EditorType.IsEnum())
                        editor.EditorTemplate = "Enum";
                    else if (editor.EditorType == typeof(Period))
                        editor.EditorTemplate = "Period";
                    else if (editor.EditorType == typeof(Icon))
                        editor.EditorTemplate = "Icon";
                    else if (typeof(MultilanguageText).IsAssignableFrom(editor.EditorType))
                        editor.EditorTemplate = "Multilanguage";
                    else if (editor.EditorType == typeof(Url))
                        editor.EditorTemplate = "ComplexUrl";
                    else if (editor.EditorType == typeof(UrlMultilanguageText))
                        editor.EditorTemplate = "UrlMultilanguageText";
                    else if (editor.EditorType == typeof(LinkBaseObject))
                        editor.EditorTemplate = "LinkBaseObject";
                    else if (editor.EditorType == typeof(MultiEnum))
                        editor.EditorTemplate = "MultiEnum";
                    //else if (editor.EditorType == typeof(ValidationObjectBinding))
                    //    editor.EditorTemplate = "ValidationObjectBinding";
                    else
                    {
                        Type easyCollectionEntry =
                            prop.PropertyType.GetEntryOfUnboundedTypeOfCollection(typeof(EasyCollectionEntry<>));

                        if (easyCollectionEntry != null)
                        {
                            editor.EditorTemplate = "EasyCollection";
                            editor.ViewModelConfig = _viewModelConfigService.Get(easyCollectionEntry);
                        }
                        else
                        {
                            switch (editor.Relationship)
                            {
                                case Relationship.OneToMany:
                                    if (typeof(FileData).IsAssignableFrom(editor.EditorType))
                                        editor.EditorTemplate = "Files";
                                    else if (typeof(Base.LinkedObjects.Entities.Link).IsAssignableFrom(editor.EditorType))
                                        editor.EditorTemplate = "ListLinkedОbjects";
                                    else
                                        editor.EditorTemplate = "OneToMany";

                                    break;

                                case Relationship.ManyToMany:
                                    editor.EditorTemplate = "ManyToMany";
                                    break;

                                case Relationship.One:
                                    editor.EditorTemplate = "BaseObjectOne";
                                    break;

                                case Relationship.None:
                                    editor.EditorTemplate = editor.EditorType.Name;
                                    break;
                            }
                        }
                    }
                }
                else
                {
                    editor.EditorTemplate = dataTypeAttr.DataType != PropertyDataType.Custom
                        ? dataTypeAttr.DataType.ToString()
                        : dataTypeAttr.CustomDataType;

                    editor.EditorTemplateParams = dataTypeAttr.Params;
                }


                var configEditor = viewModelConfig.DetailView.Editors.FirstOrDefault(m => m.PropertyName == editor.PropertyName);

                if (configEditor != null)
                {
                    if (configEditor.Mnemonic != null)
                        editor.Mnemonic = configEditor.Mnemonic;

                    if (configEditor.Title != null)
                        editor.Title = configEditor.Title;

                    if (configEditor.IsLabelVisible != null)
                        editor.IsLabelVisible = configEditor.IsLabelVisible.Value;

                    if (configEditor.EditorTemplate != null)
                        editor.EditorTemplate = configEditor.EditorTemplate;

                    if (configEditor.TabName != null)
                        editor.TabName = configEditor.TabName;

                    if (configEditor.IsReadOnly != null)
                        editor.IsReadOnly = configEditor.IsReadOnly.Value;

                    if (configEditor.IsRequired != null)
                        editor.IsRequired = configEditor.IsRequired.Value;

                    if (configEditor.Order != null)
                        editor.Order = configEditor.Order.Value;

                    if (configEditor.Visible != null)
                        editor.Visible = configEditor.Visible.Value;
                }

                if (editor.ViewModelConfig == null)
                {
                    editor.ViewModelConfig = _viewModelConfigService.Get(editor.Mnemonic) ?? _viewModelConfigService.Get(editor.EditorType);

                    if (editor.ViewModelConfig == null && prop.PropertyType.IsAssignableFromBase())
                        throw new Exception(String.Format("The configuration file is not configured for type \"{0}\"", editor.EditorType.Name));
                }


                if (String.IsNullOrEmpty(editor.Mnemonic))
                    editor.Mnemonic = type.GetTypeName();

                return editor;
            }

            return null;
        }
コード例 #40
0
		public void SaveAndLoadStartEditorFullscreenRegistryState()
		{
			MakeSureToDeleteStartMaximizedRegistryEntry();
			var mockPlugins = GetEditorPluginLoaderMock();
			var model = new EditorViewModel(mockPlugins, new MockSettings());
			model.StartEditorMaximized = false;
			Assert.IsFalse(model.StartEditorMaximized);
			model.StartEditorMaximized = true;
			Assert.IsTrue(model.StartEditorMaximized);
		}
コード例 #41
0
		public void WhenContentIsNotReadyTheProjectSelectionComboBoxIsDisabled()
		{
			var mockPlugins = GetEditorPluginLoaderMock();
			var model = new EditorViewModel(mockPlugins, new MockSettings());
			Assert.AreEqual(false, model.IsContentReady);
		}
コード例 #42
0
        public StockAdministrationViewModel(ISession session, IProductService productService, IStockService stockService)
        {
            _session = session;
            _productService = productService;
            _stockService = stockService;

            #region Maintance - Products

            Actions.Add(new AdministrationActionViewModel()
            {
                Action = (p) =>
                                {
                                    IsBusy = true;

                                    Dispatcher.CurrentDispatcher.BeginInvoke((Action)delegate
                                    {
                                        View = new EditorView(_session);
                                        var _viewModel = new EditorViewModel<Product>(_session);
                                        _viewModel.ItemRemoved += (sender, e) =>
                                            {
                                                _session.Delete<Data.Models.Stock>(s => s.ProductId == e.Item.Id);
                                                _session.CommitChanges();
                                            };
                                        _viewModel.NewItemSaved += (sender, e) =>
                                            {
                                                _session.Add<Data.Models.Stock>(new Data.Models.Stock()
                                                            {
                                                                Id = Guid.NewGuid(),
                                                                ProductId = e.Item.Id,
                                                                Units = 0
                                                            });
                                                _session.CommitChanges();
                                            };
                                        View.DataContext = _viewModel;

                                        IsBusy = false;
                                    }, DispatcherPriority.Background);
                                },
                Category = "Maintance",
                Title = "Products"
            });

            #endregion

            #region Maintance - Tax

            Actions.Add(new AdministrationActionViewModel()
            {
                Action = (p) =>
                {
                    IsBusy = true;
                    Dispatcher.CurrentDispatcher.BeginInvoke((Action)delegate
                                                                         {
                                                                             View = new EditorView(_session);
                                                                             View.DataContext =
                                                                                 new EditorViewModel<Tax>(_session);

                                                                             IsBusy = false;
                                    }, DispatcherPriority.Background);
                },
                Category = "Maintance",
                Title = "Tax"
            });

            #endregion

            #region Maintance - Categories

            Actions.Add(new AdministrationActionViewModel()
            {
                Action = (p) =>
                {
                    IsBusy = true;
                    Dispatcher.CurrentDispatcher.BeginInvoke((Action)delegate
                                                                         {
                                                                             View = new EditorView(_session);
                                                                             View.DataContext =
                                                                                 new EditorViewModel<Category>(_session);

                                                                             IsBusy = false;
                                    }, DispatcherPriority.Background);
                },
                Category = "Maintance",
                Title = "Categories"
            });

            #endregion

            #region Maintance - Stock Maintance

            Actions.Add(new AdministrationActionViewModel()
            {
                Action = (p) =>
                {
                    IsBusy = true;
                    Dispatcher.CurrentDispatcher.BeginInvoke((Action)delegate
                                                                         {

                                                                             View = new StockMaintanceView_Main();
                                                                             View.DataContext =
                                                                                 new StockMaintanceViewModel(
                                                                                     _productService, _stockService);

                                                                             IsBusy = false;
                                    }, DispatcherPriority.Background);
                },
                Category = "Maintance",
                Title = "Stock Maintance"
            });

            #endregion

            #region Reports - Products

            Actions.Add(new AdministrationActionViewModel()
            {
                Action = (p) =>
                {
                    IsBusy = true;
                    Dispatcher.CurrentDispatcher.BeginInvoke((Action)delegate
                                                                         {

                                                                             ReportDocument reportDocument =
                                                                                 new ReportDocument();

                                                                             StreamReader reader =
                                                                                 new StreamReader(
                                                                                     new FileStream(
                                                                                         @"Templates\ProductsReport.xaml",
                                                                                         FileMode.Open, FileAccess.Read));
                                                                             reportDocument.XamlData =
                                                                                 reader.ReadToEnd();
                                                                             reportDocument.XamlImagePath =
                                                                                 Path.Combine(
                                                                                     Environment.CurrentDirectory,
                                                                                     @"Templates\");
                                                                             reader.Close();

                                                                             ReportData reportData = new ReportData();
                                                                             DataTable table = new DataTable("Products");
                                                                             table.Columns.Add("Reference",
                                                                                               typeof (string));
                                                                             table.Columns.Add("Name", typeof (string));
                                                                             table.Columns.Add("BuyPrice",
                                                                                               typeof (double));
                                                                             table.Columns.Add("SellPrice",
                                                                                               typeof (double));

                                                                             foreach (
                                                                                 var product in
                                                                                     _productService.GetProducts())
                                                                             {
                                                                                 table.Rows.Add(new object[]
                                                                                                    {
                                                                                                        product.Reference,
                                                                                                        product.Name,
                                                                                                        product.BuyPrice,
                                                                                                        product.SellPrice
                                                                                                    });
                                                                             }
                                                                             reportData.DataTables.Add(table);

                                                                             XpsDocument xps =
                                                                                 reportDocument.CreateXpsDocument(
                                                                                     reportData);

                                                                             View = new SimpleReportView(xps);

                                                                             IsBusy = false;
                                                                         }, DispatcherPriority.SystemIdle);
                },
                Category = "Reports",
                Title = "Products"
            });

            #endregion

            #region Reports - Current Inventory

            Actions.Add(new AdministrationActionViewModel()
            {
                Action = (p) =>
                {
                    IsBusy = true;
                    Dispatcher.CurrentDispatcher.BeginInvoke((Action)delegate
                                                                         {
                                                                             ReportDocument reportDocument =
                                                                                 new ReportDocument();

                                                                             StreamReader reader =
                                                                                 new StreamReader(
                                                                                     new FileStream(
                                                                                         @"Templates\CurrentInventoryReport.xaml",
                                                                                         FileMode.Open, FileAccess.Read));
                                                                             reportDocument.XamlData =
                                                                                 reader.ReadToEnd();
                                                                             reportDocument.XamlImagePath =
                                                                                 Path.Combine(
                                                                                     Environment.CurrentDirectory,
                                                                                     @"Templates\");
                                                                             reader.Close();

                                                                             ReportData reportData = new ReportData();
                                                                             DataTable table = new DataTable("Products");
                                                                             table.Columns.Add("Reference",
                                                                                               typeof (string));
                                                                             table.Columns.Add("Name", typeof (string));
                                                                             table.Columns.Add("Units", typeof (double));

                                                                             foreach (
                                                                                 var product in
                                                                                     _productService.GetProducts())
                                                                             {
                                                                                 Data.Models.Stock stock =
                                                                                     _stockService.GetStockByProductId(
                                                                                         product.Id);
                                                                                 table.Rows.Add(new object[]
                                                                                                    {
                                                                                                        product.Reference,
                                                                                                        product.Name,
                                                                                                        stock.Units
                                                                                                    });
                                                                             }
                                                                             reportData.DataTables.Add(table);

                                                                             XpsDocument xps =
                                                                                 reportDocument.CreateXpsDocument(
                                                                                     reportData);

                                                                             View = new SimpleReportView(xps);

                                                                             IsBusy = false;
                                                                         }, DispatcherPriority.SystemIdle);
                },
                Category = "Reports",
                Title = "Current Inventory"
            });

            #endregion
        }
コード例 #43
0
 public void Dispose()
 {
     editor = null;
     editorViewModel = null;
 }
コード例 #44
0
 private void Editor_DataContextChanged(object sender, EventArgs e)
 {
     editorVm = editor.DataContext as EditorViewModel;
 }
コード例 #45
0
        public async Task<IEditor> OpenDocument(ISourceFile file, int line, int column = 1, bool debugHighlight = false,
            bool selectLine = false)
        {
            var currentTab = DocumentTabs.Documents.OfType<EditorViewModel>().FirstOrDefault(t => t.Model.ProjectFile.FilePath == file.FilePath);

            var selectedDocumentTCS = new TaskCompletionSource<IDocumentTabViewModel>();

            if (currentTab == null)
            {
                await Dispatcher.UIThread.InvokeTaskAsync(async () =>
                {
                    if (DocumentTabs.TemporaryDocument != null)
                    {
                        var documentToClose = DocumentTabs.TemporaryDocument;
                        DocumentTabs.TemporaryDocument = null;
                        await documentToClose.CloseCommand.ExecuteAsyncTask(null);
                        SelectedDocument = null;
                    }
                });

                EditorViewModel newEditor = null;
                await Dispatcher.UIThread.InvokeTaskAsync(async () =>
                {
                    newEditor = new EditorViewModel(new EditorModel());

                    newEditor.Margins.Add(new BreakPointMargin(IoC.Get<IDebugManager>().BreakPointManager));
                    newEditor.Margins.Add(new LineNumberMargin());

                    await Dispatcher.UIThread.InvokeTaskAsync(() =>
                    {
                        DocumentTabs.Documents.Add(newEditor);
                        DocumentTabs.TemporaryDocument = newEditor;
                    });

                    DocumentTabs.SelectedDocument = newEditor;

                    await Dispatcher.UIThread.InvokeTaskAsync(() => { newEditor.Model.OpenFile(file, newEditor.Intellisense, newEditor.Intellisense.CompletionAssistant); });

                    selectedDocumentTCS.SetResult(DocumentTabs.SelectedDocument);
                });
            }
            else
            {
                await Dispatcher.UIThread.InvokeTaskAsync(() => { DocumentTabs.SelectedDocument = currentTab; });

                selectedDocumentTCS.SetResult(DocumentTabs.SelectedDocument);
            }

            await selectedDocumentTCS.Task;

            if (DocumentTabs.SelectedDocument is EditorViewModel)
            {
                if (debugHighlight)
                {
                    (DocumentTabs.SelectedDocument as EditorViewModel).DebugLineHighlighter.Line = line;
                }

                if (selectLine || debugHighlight)
                {
                    Dispatcher.UIThread.InvokeAsync(() => (DocumentTabs.SelectedDocument as EditorViewModel).Model.ScrollToLine(line));
                    (DocumentTabs.SelectedDocument as EditorViewModel).GotoPosition(line, column);
                }
            }

            return DocumentTabs.SelectedDocument as EditorViewModel;
        }
コード例 #46
0
		public void StartEditorFullscreenWhenNoRegistryKeyIsSetAndSaveStateInRegistry()
		{
			MakeSureToDeleteStartMaximizedRegistryEntry();
			var mockPlugins = GetEditorPluginLoaderMock();
			var model = new EditorViewModel(mockPlugins, new MockSettings());
			Assert.IsTrue(model.StartEditorMaximized);
		}