private void ActivatePlugin() { DocumentType documentTypeHtml = new DocumentType(Constants.DOCUMENT_TYPE_HTML); DocumentType documentTypeHtm = new DocumentType(Constants.DOCUMENT_TYPE_HTM); DocumentType documentTypeCss = new DocumentType(Constants.DOCUMENT_TYPE_CSS); DocumentManager documentManager = DocumentManager.GetInstance(); documentManager.RegisterDocumentLanguage( documentTypeHtml, Constants.SCINTILLA_LANGUAGE_HTML); documentManager.RegisterDocumentLanguage( documentTypeHtm, Constants.SCINTILLA_LANGUAGE_HTML); documentManager.RegisterDocumentLanguage( documentTypeCss, Constants.SCINTILLA_LANGUAGE_CSS); ApplicationManager applicationManager = ApplicationManager.GetInstance(); OpenDocumentHandler openHandler = applicationManager.GetOpenDocumentHandler( QuickSharp.TextEditor.Constants.DOCUMENT_TYPE_TXT); if (openHandler != null) { applicationManager.RegisterOpenDocumentHandler( documentTypeHtml, openHandler); applicationManager.RegisterOpenDocumentHandler( documentTypeHtm, openHandler); applicationManager.RegisterOpenDocumentHandler( documentTypeCss, openHandler); } /* * Add to the non-source tools list (create if necessary). */ ApplicationStorage appStore = ApplicationStorage.GetInstance(); List <String> nonToolSourceTypes = appStore.Get( Constants.APP_STORE_KEY_NON_TOOL_SOURCE_TYPES, typeof(List <String>)) as List <String>; if (nonToolSourceTypes != null) { nonToolSourceTypes.Add(Constants.DOCUMENT_TYPE_HTML); nonToolSourceTypes.Add(Constants.DOCUMENT_TYPE_HTM); nonToolSourceTypes.Add(Constants.DOCUMENT_TYPE_CSS); } }
private void ActivatePlugin() { /* * Define the document handling. */ _documentType = new DocumentType(Constants.DOCUMENT_TYPE_VB); DocumentManager.GetInstance().RegisterDocumentLanguage( _documentType, Constants.SCINTILLA_LANGUAGE_VB); ApplicationManager applicationManager = ApplicationManager.GetInstance(); OpenDocumentHandler openHandler = applicationManager.GetOpenDocumentHandler( QuickSharp.TextEditor.Constants.DOCUMENT_TYPE_TXT); if (openHandler != null) { applicationManager.RegisterOpenDocumentHandler( _documentType, openHandler); } /* * Define the build tools. */ _buildToolManager = BuildToolManager.GetInstance(); _buildToolManager.RegisterBuildCommand( _documentType, QuickSharp.BuildTools.Constants.ACTION_COMPILE, CompileBuildCommand); _buildToolManager.RegisterBuildCommand( _documentType, QuickSharp.BuildTools.Constants.ACTION_RUN, RunBuildCommand); _buildToolManager.RegisterLineParser( Resources.MicrosoftVBLineParser, _documentType, QuickSharp.BuildTools.Constants.ACTION_COMPILE, new VBNetOutputLineParser()); if (_buildToolManager.BuildTools.GetToolCount( _documentType) == 0) { CreateDefaultTools(); } _buildToolManager.UpdateTools(_documentType); _buildToolManager.BuildTools.SortTools(); }
/// <summary> /// Registers an open document handler for a document type provided as a string. /// A handler will be rejected if a handler has already been registered for the document type. /// </summary> /// <param name="documentType">The document type to be opened by the handler.</param> /// <param name="handler">The handler used to open documents of the registered type.</param> /// <returns>True if the handler was registered successfully.</returns> public bool RegisterOpenDocumentHandler( string documentType, OpenDocumentHandler handler) { if (_openDocumentHandlers.ContainsKey(documentType)) { return(false); } _openDocumentHandlers[documentType] = handler; return(true); }
/// <summary> /// Constructor /// </summary> public SordListView() { this.ColumnHeaderName.Text = EloixClientUI.Properties.Resources.Name; this.ColumnHeaderXDate.Text = EloixClientUI.Properties.Resources.DocumentDate; this.ColumnHeaderIDate.Text = EloixClientUI.Properties.Resources.FilingDate; this.ColumnHeaderOwner.Text = EloixClientUI.Properties.Resources.Onwer; this.ColumnHeaderMaskName.Text = EloixClientUI.Properties.Resources.DocMask; this.ColumnHeaderVersion.Text = EloixClientUI.Properties.Resources.Version; this.ColumnHeaderFileSize.Text = EloixClientUI.Properties.Resources.Size; this.ColumnHeaderFileSize.TextAlign = System.Windows.Forms.HorizontalAlignment.Right; this.ColumnHeaderVersionDate.Text = EloixClientUI.Properties.Resources.CreateDate; this.ColumnHeaderVersionUser.Text = EloixClientUI.Properties.Resources.CreateBy; this.ColumnHeaderArcPath.Text = EloixClientUI.Properties.Resources.ArcPath; this.ColumnHeaderLockId.Text = EloixClientUI.Properties.Resources.LockId; this.ColumnHeaderLockName.Text = EloixClientUI.Properties.Resources.LockName; this.ColumnHeaderName.Name = "Name"; this.ColumnHeaderXDate.Name = "XDate"; this.ColumnHeaderIDate.Name = "IDate"; this.ColumnHeaderOwner.Name = "Owner"; this.ColumnHeaderMaskName.Name = "MaskName"; this.ColumnHeaderVersion.Name = "Version"; this.ColumnHeaderFileSize.Name = "FileSize"; this.ColumnHeaderVersionDate.Name = "VersionDate"; this.ColumnHeaderVersionUser.Name = "VersionUser"; this.ColumnHeaderArcPath.Name = "ArcPath"; this.ColumnHeaderLockId.Name = "LockId"; this.ColumnHeaderLockName.Name = "LockName"; // some columns should be displayed in design mode base.Columns.Add(ColumnHeaderName); base.Columns.Add(ColumnHeaderXDate); base.Columns.Add(ColumnHeaderIDate); base.Columns.Add(ColumnHeaderMaskName); base.Columns.Add(ColumnHeaderVersion); base.Columns.Add(ColumnHeaderFileSize); base.Columns.Add(ColumnHeaderOwner); base.Columns.Add(ColumnHeaderVersionDate); base.Columns.Add(ColumnHeaderVersionUser); base.Columns.Add(ColumnHeaderArcPath); base.Columns.Add(ColumnHeaderLockName); openDocumentHandler = new OpenDocumentHandler(); }
/// <summary> /// Constructor /// </summary> public TaskListView() { this.ColumnHeaderTaskType.Text = EloixClientUI.Properties.Resources.TaskType; this.ColumnHeaderPriority.Text = EloixClientUI.Properties.Resources.Priority; this.ColumnHeaderName.Text = EloixClientUI.Properties.Resources.Name; this.ColumnHeaderOwner.Text = EloixClientUI.Properties.Resources.Onwer; this.ColumnHeaderDate.Text = EloixClientUI.Properties.Resources.TaskDate; this.ColumnHeaderMemo.Text = EloixClientUI.Properties.Resources.TaskMemo; // some columns should be displayed in design mode base.Columns.Add(ColumnHeaderName); base.Columns.Add(ColumnHeaderPriority); base.Columns.Add(ColumnHeaderTaskType); base.Columns.Add(ColumnHeaderDate); base.Columns.Add(ColumnHeaderOwner); base.Columns.Add(ColumnHeaderMemo); openDocumentHandler = new OpenDocumentHandler(); }
/// <summary> /// Unregisters the handler registered for a document type specified as a /// string. /// </summary> /// <param name="documentType">The document type.</param> /// <returns>The open document handler or null if the document type is invalid or /// no handler exists for the type.</returns> public OpenDocumentHandler RemoveOpenDocumentHandler( string documentType) { if (String.IsNullOrEmpty(documentType)) { return(null); } if (!_openDocumentHandlers.ContainsKey(documentType)) { return(null); } OpenDocumentHandler handler = _openDocumentHandlers[documentType]; _openDocumentHandlers.Remove(documentType); return(handler); }
/// <summary> /// Loads a document from the specified path. This performs several steps in the following /// order. The path is converted to a DocumentType. Next, each of the registered /// document preload handlers is called, if any return false the load is cancelled. /// The document type is used to retrieve the open document handler registered for that /// type and the handler is used to open the document. /// If no handler is available the document is (otionally) passed to the Windows shell /// to be opened externally. If this fails the unknown document handler is /// retrieved and used to open the document. If this is not available /// an optional message is shown and the load fails. /// </summary> /// <param name="path">The path of the document.</param> /// <returns>The loaded document.</returns> public IDockContent LoadDocument(string path) { ClientProfile profile = _applicationManager.ClientProfile; /* * Look for readonly flag - path will end with '?'. This is really * only for the benefit of the document serialisation which needs * to be able to restore a readonly file from the save document * configuration. */ bool readOnly = false; if (path.EndsWith("?")) { readOnly = true; path = path.TrimEnd('?'); } DocumentType documentType = new DocumentType(path); /* * Document PreLoad Handlers * * The idea here is to allow applications to create a chain * of filters each being responsible for performing some * action on a particular document type. Each handler * should immediately return true if it's not interested * in the document type passed. The chain will end when the * first handler returns false and the document load will be * cancelled. Since there is no guarantee of the order in * which the handlers are called (registration order will * depend on plugin load order which can vary) there should * be only one handler for a particular type unless they are * completely independent. */ foreach (DocumentPreLoadHandler d in _applicationManager.DocumentPreLoadHandlers) { if (!d(documentType)) { return(null); } } OpenDocumentHandler handler = _applicationManager.GetOpenDocumentHandler(documentType); if (handler == null && _allowShellOpen) { try { FileTools.ShellOpenFile(path); return(null); } catch { /* * Suppress error - if the load fails the document * gets passed to the unknown document handler. */ } } if (handler == null) { handler = _applicationManager.UnknownDocumentHandler; } if (handler == null) { if (_showNoHandlerMessage) { MessageBox.Show( Resources.NoHandlerMessage, Resources.NoHandlerTitle, MessageBoxButtons.OK, MessageBoxIcon.Error); } return(null); } else { return(handler(path, readOnly)); } }
/* * Registration. */ /// <summary> /// Registers an open document handler for a document type provided as a DocumentType object. /// A handler will be rejected if a handler has already been registered for the document type. /// </summary> /// <param name="documentType">The document type to be opened by the handler.</param> /// <param name="handler">The handler used to open documents of the registered type.</param> /// <returns>True if the handler was registered successfully.</returns> public bool RegisterOpenDocumentHandler( DocumentType documentType, OpenDocumentHandler handler) { return(RegisterOpenDocumentHandler( documentType.ToString(), handler)); }
private void ActivatePlugin() { /* * Register the document types. */ DocumentManager documentManager = DocumentManager.GetInstance(); documentManager.RegisterDocumentLanguage( Constants.DOCUMENT_TYPE_ASAX, Constants.SCINTILLA_LANGUAGE_ASPX); documentManager.RegisterDocumentLanguage( Constants.DOCUMENT_TYPE_ASCX, Constants.SCINTILLA_LANGUAGE_ASPX); documentManager.RegisterDocumentLanguage( Constants.DOCUMENT_TYPE_ASHX, Constants.SCINTILLA_LANGUAGE_CS); documentManager.RegisterDocumentLanguage( Constants.DOCUMENT_TYPE_ASMX, Constants.SCINTILLA_LANGUAGE_CS); documentManager.RegisterDocumentLanguage( Constants.DOCUMENT_TYPE_ASPX, Constants.SCINTILLA_LANGUAGE_ASPX); documentManager.RegisterDocumentLanguage( Constants.DOCUMENT_TYPE_MASTER, Constants.SCINTILLA_LANGUAGE_ASPX); documentManager.RegisterDocumentLanguage( Constants.DOCUMENT_TYPE_CONFIG, Constants.SCINTILLA_LANGUAGE_XML); documentManager.RegisterDocumentLanguage( Constants.DOCUMENT_TYPE_SITEMAP, Constants.SCINTILLA_LANGUAGE_XML); /* * Define the document handlers. */ ApplicationManager applicationManager = ApplicationManager.GetInstance(); OpenDocumentHandler openHandler = applicationManager.GetOpenDocumentHandler( QuickSharp.TextEditor.Constants.DOCUMENT_TYPE_TXT); if (openHandler != null) { applicationManager.RegisterOpenDocumentHandler( Constants.DOCUMENT_TYPE_ASAX, openHandler); applicationManager.RegisterOpenDocumentHandler( Constants.DOCUMENT_TYPE_ASCX, openHandler); applicationManager.RegisterOpenDocumentHandler( Constants.DOCUMENT_TYPE_ASHX, openHandler); applicationManager.RegisterOpenDocumentHandler( Constants.DOCUMENT_TYPE_ASMX, openHandler); applicationManager.RegisterOpenDocumentHandler( Constants.DOCUMENT_TYPE_ASPX, openHandler); applicationManager.RegisterOpenDocumentHandler( Constants.DOCUMENT_TYPE_MASTER, openHandler); applicationManager.RegisterOpenDocumentHandler( Constants.DOCUMENT_TYPE_CONFIG, openHandler); applicationManager.RegisterOpenDocumentHandler( Constants.DOCUMENT_TYPE_SITEMAP, openHandler); } /* * We don't have any build tools but we want ASP.NET files * recognised as source files. Register with the * non-tool source files list in the application store. */ ApplicationStorage appStore = ApplicationStorage.GetInstance(); /* * We have no dependency on the BuildTools plugin so we * can't assume the non-tool source list has been created. * Use the Get method to create the list if it doesn't exist. */ List <String> nonToolSourceTypes = appStore.Get( Constants.APP_STORE_KEY_NON_TOOL_SOURCE_TYPES, typeof(List <String>)) as List <String>; if (nonToolSourceTypes != null) { nonToolSourceTypes.Add(Constants.DOCUMENT_TYPE_ASAX); nonToolSourceTypes.Add(Constants.DOCUMENT_TYPE_ASCX); nonToolSourceTypes.Add(Constants.DOCUMENT_TYPE_ASHX); nonToolSourceTypes.Add(Constants.DOCUMENT_TYPE_ASMX); nonToolSourceTypes.Add(Constants.DOCUMENT_TYPE_ASPX); nonToolSourceTypes.Add(Constants.DOCUMENT_TYPE_CONFIG); nonToolSourceTypes.Add(Constants.DOCUMENT_TYPE_MASTER); nonToolSourceTypes.Add(Constants.DOCUMENT_TYPE_SITEMAP); } }