Beispiel #1
0
        internal static TextEditor OpenDocument(FilePath filename)
        {
            IDockingService dockingService = DependencyFactory.Resolve <IDockingService>();
            var             child          = dockingService.Documents.OfType <TextEditor>()
                                             .SingleOrDefault(e => e.FileName == filename);

            if (child != null)
            {
                child.Show();
                child.Activate();
                return(child);
            }

            TextEditor doc = new TextEditor
            {
                Text        = Path.GetFileName(filename),
                TabText     = Path.GetFileName(filename),
                ToolTipText = filename
            };

            doc.OpenFile(filename);

            dockingService.ShowDockPanel(doc);
            return(doc);
        }
Beispiel #2
0
 public FindAllReferencesAction()
 {
     _dockingService   = DependencyFactory.Resolve <IDockingService>();
     _projectService   = DependencyFactory.Resolve <IProjectService>();
     _activeTextEditor = _dockingService.ActiveDocument as ITextEditor;
     _findResults      = _dockingService.GetDockingWindow <FindResultsWindow>();
 }
Beispiel #3
0
        internal static ImageViewer OpenImage(FilePath fileName)
        {
            IDockingService dockingService = DependencyFactory.Resolve <IDockingService>();
            var             child          = dockingService.Documents.OfType <ImageViewer>()
                                             .SingleOrDefault(e => e.FileName == fileName);

            if (child != null)
            {
                child.Show();
                return(child);
            }

            ImageViewer doc = new ImageViewer
            {
                Text        = Path.GetFileName(fileName),
                TabText     = Path.GetFileName(fileName),
                ToolTipText = fileName
            };

            doc.OpenFile(fileName);

            if (!Settings.Default.RecentFiles.Contains(fileName))
            {
                Settings.Default.RecentFiles.Add(fileName);
            }

            dockingService.ShowDockPanel(doc);
            return(doc);
        }
        public ObjectsPanel()
        {
            InitializeComponent();

            _dockingService = DependencyFactory.Resolve <IDockingService>();
            _dockingService.ActiveDocumentChanged += DockingService_ActiveDocumentChanged;

            DockingService_ActiveDocumentChanged(this, EventArgs.Empty);
        }
        public void ShowProgressTest()
        {
            IDockingService            dockingService = null;                                                      // TODO: Initialize to an appropriate value
            WabbitcodeStatusBar        statusBar      = null;                                                      // TODO: Initialize to an appropriate value
            WabbitcodeStatusBarService target         = new WabbitcodeStatusBarService(dockingService, statusBar); // TODO: Initialize to an appropriate value

            target.ShowProgress();
            Assert.Inconclusive("A method that does not return a value cannot be verified.");
        }
        public void SetInsertModeTest()
        {
            IDockingService            dockingService = null;                                                      // TODO: Initialize to an appropriate value
            WabbitcodeStatusBar        statusBar      = null;                                                      // TODO: Initialize to an appropriate value
            WabbitcodeStatusBarService target         = new WabbitcodeStatusBarService(dockingService, statusBar); // TODO: Initialize to an appropriate value
            bool insertMode = false;                                                                               // TODO: Initialize to an appropriate value

            target.SetInsertMode(insertMode);
            Assert.Inconclusive("A method that does not return a value cannot be verified.");
        }
        private FindAndReplaceForm()
        {
            _dockingService = DependencyFactory.Resolve <IDockingService>();
            _projectService = DependencyFactory.Resolve <IProjectService>();
            _dockingService.ActiveDocumentChanged += DockingServiceActiveDocumentChanged;

            _results = _dockingService.GetDockingWindow <FindResultsWindow>();

            InitializeComponent();
        }
        public void SetMessageTest()
        {
            IDockingService            dockingService = null;                                                      // TODO: Initialize to an appropriate value
            WabbitcodeStatusBar        statusBar      = null;                                                      // TODO: Initialize to an appropriate value
            WabbitcodeStatusBarService target         = new WabbitcodeStatusBarService(dockingService, statusBar); // TODO: Initialize to an appropriate value
            string message     = string.Empty;                                                                     // TODO: Initialize to an appropriate value
            bool   highlighted = false;                                                                            // TODO: Initialize to an appropriate value

            target.SetMessage(message, highlighted);
            Assert.Inconclusive("A method that does not return a value cannot be verified.");
        }
Beispiel #9
0
 public GotoDefinitionAction(FilePath fileName, string text, int currentLine)
 {
     _fileName       = fileName;
     _text           = text;
     _currentLine    = currentLine;
     _dockingService = DependencyFactory.Resolve <IDockingService>();
     _fileService    = DependencyFactory.Resolve <IFileService>();
     _parserService  = DependencyFactory.Resolve <IParserService>();
     _projectService = DependencyFactory.Resolve <IProjectService>();
     _findResults    = _dockingService.GetDockingWindow <FindResultsWindow>();
 }
        public Editor()
        {
            InitializeComponent();
            editor.TextArea.Caret.PositionChanged     += Caret_PositionChanged;
            editor.Document.UndoStack.PropertyChanged += UndoStack_PropertyChanged;

            foldingManager  = FoldingManager.Install(editor.TextArea);
            foldingStrategy = new AsmFoldingStrategy();

            documentService = ServiceFactory.Instance.GetServiceInstance <DocumentService>();
            dockingService  = ServiceFactory.Instance.GetServiceInstance <DockingService>();
        }
        public void SetProgressTest()
        {
            IDockingService            dockingService = null;                                                      // TODO: Initialize to an appropriate value
            WabbitcodeStatusBar        statusBar      = null;                                                      // TODO: Initialize to an appropriate value
            WabbitcodeStatusBarService target         = new WabbitcodeStatusBarService(dockingService, statusBar); // TODO: Initialize to an appropriate value
            double          progress = 0F;                                                                         // TODO: Initialize to an appropriate value
            string          name     = string.Empty;                                                               // TODO: Initialize to an appropriate value
            OperationStatus status   = new OperationStatus();                                                      // TODO: Initialize to an appropriate value

            target.SetProgress(progress, name, status);
            Assert.Inconclusive("A method that does not return a value cannot be verified.");
        }
Beispiel #12
0
        protected override void Execute()
        {
            IDockingService dockingService   = DependencyFactory.Resolve <IDockingService>();
            var             activeTextEditor = dockingService.ActiveDocument as ITextEditor;

            if (activeTextEditor == null)
            {
                return;
            }

            activeTextEditor.SelectedTextToSentenceCase();
        }
        public void SetCaretPositionTest()
        {
            IDockingService            dockingService = null;                                                      // TODO: Initialize to an appropriate value
            WabbitcodeStatusBar        statusBar      = null;                                                      // TODO: Initialize to an appropriate value
            WabbitcodeStatusBarService target         = new WabbitcodeStatusBarService(dockingService, statusBar); // TODO: Initialize to an appropriate value
            int x          = 0;                                                                                    // TODO: Initialize to an appropriate value
            int y          = 0;                                                                                    // TODO: Initialize to an appropriate value
            int charOffset = 0;                                                                                    // TODO: Initialize to an appropriate value

            target.SetCaretPosition(x, y, charOffset);
            Assert.Inconclusive("A method that does not return a value cannot be verified.");
        }
        public void VisibleTest()
        {
            IDockingService            dockingService = null;                                                      // TODO: Initialize to an appropriate value
            WabbitcodeStatusBar        statusBar      = null;                                                      // TODO: Initialize to an appropriate value
            WabbitcodeStatusBarService target         = new WabbitcodeStatusBarService(dockingService, statusBar); // TODO: Initialize to an appropriate value
            bool expected = false;                                                                                 // TODO: Initialize to an appropriate value
            bool actual;

            target.Visible = expected;
            actual         = target.Visible;
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }
		public WabbitcodeStatusBarService(IDockingService dockingService, WabbitcodeStatusBar statusBar)
		{
			if (dockingService == null)
			{
				throw new ArgumentNullException("dockingService");
			}
			if (statusBar == null)
			{
				throw new ArgumentNullException("statusBar");
			}
			this.dockingService = dockingService;
			this.statusBar = statusBar;
			this.statusBar.DockingService = dockingService;
		}
        public void WabbitcodeStatusBarServiceConstructorTest_Invalid_DockingService()
        {
            IDockingService     dockingService = null;
            WabbitcodeStatusBar statusBar      = new WabbitcodeStatusBar();

            try
            {
                WabbitcodeStatusBarService target = new WabbitcodeStatusBarService(dockingService, statusBar);
            }
            catch (ArgumentNullException ex)
            {
                Assert.IsTrue(ex.ParamName == "dockingService");
                return;
            }
            Assert.Fail("No Exception thrown");
        }
Beispiel #17
0
        public void Loaded()
        {
            _dockingService = DependencyFactory.Resolve <IDockingService>();
            _projectService = DependencyFactory.Resolve <IProjectService>();
            _toolbarService = DependencyFactory.Resolve <IToolBarService>();

            _toolStrip = new MapLayerToolStrip();
            _toolbarService.RegisterToolbar(MapLayerToolStrip.StripName, _toolStrip);

            _projectService.ProjectOpened += ProjectService_ProjectOpened;


            if (_projectService.Project != null)
            {
                Initialize();
            }
        }
Beispiel #18
0
        public void Loaded()
        {
            _dockingService = DependencyFactory.Resolve <IDockingService>();
            _projectService = DependencyFactory.Resolve <IProjectService>();
            _toolbarService = DependencyFactory.Resolve <IToolBarService>();

            _toolStrip = new MapLayerToolStrip();
            _toolbarService.RegisterToolbar(MapLayerToolStrip.StripName, _toolStrip);

            _projectService.ProjectOpened += ProjectService_ProjectOpened;

            Initialize();

            if (_projectService.Project != null)
            {
                MapEditorControl.ZeldaFolder = _projectService.Project.ProjectDirectory;
            }
        }
Beispiel #19
0
        public MainToolBar()
        {
            AllowItemReorder = true;
            Items.AddRange(new ToolStripItem[]
            {
                _newToolStripButton,
                _openToolStripButton,
                _saveToolStripButton,
                _saveAllToolButton,
                _printToolStripButton,
                _toolStripSeparator,
                _cutToolStripButton,
                _copyToolStripButton,
                _pasteToolStripButton,
                _toolStripSeparator3,
                _findBox,
                _toolStripSeparator2,
                _runToolButton,
                _configBox
            });
            Dock        = DockStyle.Left;
            RenderMode  = ToolStripRenderMode.System;
            LayoutStyle = ToolStripLayoutStyle.Flow;
            GripStyle   = ToolStripGripStyle.Visible;
            Text        = "Main Toolbar";

            _dockingService = DependencyFactory.Resolve <IDockingService>();
            _fileService    = DependencyFactory.Resolve <IFileService>();
            _projectService = DependencyFactory.Resolve <IProjectService>();

            _newToolStripButton.Click       += newToolButton_Click;
            _openToolStripButton.Click      += openToolButton_Click;
            _saveToolStripButton.Click      += saveToolButton_Click;
            _saveAllToolButton.Click        += saveAllToolButton_Click;
            _cutToolStripButton.Click       += cutToolButton_Click;
            _copyToolStripButton.Click      += copyToolButton_Click;
            _pasteToolStripButton.Click     += pasteToolButton_Click;
            _runToolButton.Click            += RunToolButton_Click;
            _configBox.SelectedIndexChanged += configBox_SelectedIndexChanged;
            _findBox.KeyPress += findBox_KeyPress;
            _dockingService.ActiveDocumentChanged += DockingServiceActiveDocumentChanged;
            _projectService.ProjectOpened         += ProjectService_ProjectOpened;
        }
Beispiel #20
0
 public ToggleBookmark()
 {
     _dockingService = DependencyFactory.Resolve <IDockingService>();
 }
Beispiel #21
0
 public SetNextStatementAction()
 {
     _dockingService  = DependencyFactory.Resolve <IDockingService>();
     _debuggerService = DependencyFactory.Resolve <IDebuggerService>();
 }
Beispiel #22
0
 public ToggleBreakpointAction()
 {
     _dockingService = DependencyFactory.Resolve <IDockingService>();
 }
Beispiel #23
0
 public RefactorExtractMethodAction()
 {
     _dockingService = DependencyFactory.Resolve <IDockingService>();
     _projectService = DependencyFactory.Resolve <IProjectService>();
 }
Beispiel #24
0
 public RefactorRenameAction()
 {
     _dockingService = DependencyFactory.Resolve <IDockingService>();
     _fileService    = DependencyFactory.Resolve <IFileService>();
     _projectService = DependencyFactory.Resolve <IProjectService>();
 }
Beispiel #25
0
 public GotoPreviousBookmark()
 {
     _dockingService = DependencyFactory.Resolve <IDockingService>();
 }
Beispiel #26
0
        public PasteAction()
        {
            IDockingService dockingService = DependencyFactory.Resolve <IDockingService>();

            _activeContent = dockingService.ActiveContent as IClipboardOperation;
        }
Beispiel #27
0
        public MainMenuStrip()
        {
            Items.AddRange(new ToolStripItem[]
            {
                _fileMenuItem,
                _editMenuItem,
                _viewMenuItem,
                _refactorMenuItem,
                _projectMenuItem,
                _buildMenuItem,
                _debugMenuItem,
                _macrosMenuItem,
                _windowMenuItem,
                _helpMenuItem
            });

            LayoutStyle = ToolStripLayoutStyle.Flow;

            _debuggerService  = DependencyFactory.Resolve <IDebuggerService>();
            _dockingService   = DependencyFactory.Resolve <IDockingService>();
            _projectService   = DependencyFactory.Resolve <IProjectService>();
            _statusBarService = DependencyFactory.Resolve <IStatusBarService>();
            _toolBarService   = DependencyFactory.Resolve <IToolBarService>();
            EnableDocumentMenus();

            _debuggerService.OnDebuggingStarted        += DebuggerService_OnDebuggingStarted;
            _debuggerService.OnDebuggingEnded          += DebuggerService_OnDebuggingEnded;
            _dockingService.ActiveDocumentChanged      += DockingServiceActiveDocumentChanged;
            _projectService.ProjectOpened              += ProjectService_OnProjectOpened;
            _projectService.ProjectClosed              += ProjectService_OnProjectClosed;
            _toolBarService.OnToolBarVisibilityChanged += ToolBarService_OnToolBarVisibilityChanged;
            _toolBarService.OnToolbarRegistered        += ToolBarService_OnToolbarRegistered;
            ToolWindow.OnDockStateChanged              += ToolWindow_OnDockStateChanged;

            UndoMenuItem.Click                += undoMenuItem_Click;
            RedoMenuItem.Click                += redoMenuItem_Click;
            CutMenuItem.Click                 += cutMenuItem_Click;
            CopyMenuItem.Click                += copyMenuItem_Click;
            PasteMenuItem.Click               += pasteMenuItem_Click;
            SelectAllMenuItem.Click           += selectAllMenuItem_Click;
            FindMenuItem.Click                += findMenuItem_Click;
            ReplaceMenuItem.Click             += replaceMenuItem_Click;
            FindInFilesMenuItem.Click         += findInFilesMenuItem_Click;
            ReplaceInFilesMenuItem.Click      += replaceInFilesMenuItem_Click;
            FindAllRefsMenuItem.Click         += findAllRefsMenuItem_Click;
            MakeUpperMenuItem.Click           += makeUpperMenuItem_Click;
            MakeLowerMenuItem.Click           += makeLowerMenuItem_Click;
            InvertCaseMenuItem.Click          += invertCaseMenuItem_Click;
            SentenceCaseMenuItem.Click        += sentenceCaseMenuItem_Click;
            FormatDocMenuItem.Click           += formatDocMenuItem_Click;
            ToggleBookmarkMenuItem.Click      += toggleBookmarkMenuItem_Click;
            NextBookmarkMenuItem.Click        += nextBookmarkMenuItem_Click;
            PrevBookmarkMenuItem.Click        += prevBookmarkMenuItem_Click;
            ConvertSpacesToTabsMenuItem.Click += convertSpacesToTabsMenuItem_Click;
            GLineMenuItem.Click               += gLineMenuItem_Click;
            GSymbolMenuItem.Click             += gLabelMenuItem_Click;
            PrefsMenuItem.Click               += prefsMenuItem_Click;

            LabelListMenuItem.Click    += panelMenuItem_Click;
            ProjViewMenuItem.Click     += panelMenuItem_Click;
            MacroManagerMenuItem.Click += panelMenuItem_Click;
            OutputWindowMenuItem.Click += panelMenuItem_Click;
            ErrorListMenuItem.Click    += panelMenuItem_Click;
            FindResultsMenuItem.Click  += panelMenuItem_Click;

            DebugPanelMenuItem.Click   += panelMenuItem_Click;
            CallStackMenuItem.Click    += panelMenuItem_Click;
            StackViewerMenuItem.Click  += panelMenuItem_Click;
            VarTrackMenuItem.Click     += panelMenuItem_Click;
            BreakManagerMenuItem.Click += panelMenuItem_Click;

            StatusBarMenuItem.Click += statusBarMenuItem_Click;

            RenameMenuItem.Click        += renameMenuItem_Click;
            ExtractMethodMenuItem.Click += extractMethodMenuItem_Click;

            AddNewFileMenuItem.Click     += addNewFileMenuItem_Click;
            ExistingFileMenuItem.Click   += existingFileMenuItem_Click;
            BuildOrderButton.Click       += buildOrderButton_Click;
            IncludeDirProjMenuItem.Click += includeDirButton_Click;
            CloseProjMenuItem.Click      += closeProjMenuItem_Click;

            BuildProjectMenuItem.Click += buildMenuItem_Click;

            StartDebugMenuItem.Click        += startDebugMenuItem_Click;
            StartWithoutDebugMenuItem.Click += startWithoutDebugMenuItem_Click;
            StopDebugMenuItem.Click         += stopDebugMenuItem_Click;
            RunMenuItem.Click      += runMenuItem_Click;
            StepMenuItem.Click     += stepMenuItem_Click;
            StepOverMenuItem.Click += stepOverMenuItem_Click;
            StepOutMenuItem.Click  += stepOutMenuItem_Click;

            NewBreakpointMenuItem.Click    += newBreakpointMenuItem_Click;
            ToggleBreakpointMenuItem.Click += toggleBreakpointMenuItem_Click;


            UpdateMenuItem.Click += updateMenuItem_Click;
            AboutMenuItem.Click  += aboutMenuItem_Click;

            foreach (string file in GetRecentFiles())
            {
                string fileCopy = file;
                AddRecentItem(fileCopy);
            }
        }
Beispiel #28
0
 public DockingController(IDockingService dockingService, IBayService bayService, ILogger <DockingController> logger)
 {
     _dockingService = dockingService;
     _bayService     = bayService;
     _logger         = logger;
 }
Beispiel #29
0
        public UndoAction()
        {
            IDockingService dockingService = DependencyFactory.Resolve <IDockingService>();

            _activeContent = dockingService.ActiveContent as IUndoable;
        }
Beispiel #30
0
        public SelectAllAction()
        {
            IDockingService dockingService = DependencyFactory.Resolve <IDockingService>();

            _activeContent = dockingService.ActiveContent as ISelectable;
        }