TypeScript workspace.onWillSaveTextDocument方法代码示例

    constructor() {
        const subscriptions: Disposable[] = [];
        window.onDidChangeActiveTextEditor(Display.updateEditor, this, subscriptions);

        var config = workspace.getConfiguration('perforce');

        if(config && PerforceCommands.checkFolderOpened()) {
            if(config['editOnFileSave']) {
                workspace.onWillSaveTextDocument(e => {
                    e.waitUntil(this.onWillSaveFile(e.document));
                }, this, subscriptions);
            }
            
            if(config['editOnFileModified']) {
                workspace.onDidChangeTextDocument(this.onFileModified, this, subscriptions);
            }

            if(config['addOnFileCreate'] || config['deleteOnFileDelete']) {
                this._watcher = workspace.createFileSystemWatcher('**/*', false, true, false);

                if(config['addOnFileCreate']) {
                    this._watcher.onDidCreate(this.onFileCreated, this, subscriptions);
                }

                if(config['deleteOnFileDelete']) {
                    this._watcher.onDidDelete(this.onFileDeleted, this, subscriptions);
                }
            }
        }

        this._disposable = Disposable.from.apply(this, subscriptions);
    }

export function activateFormatOnSaveProvider(languageFilter: vscode.DocumentFilter, settings: settings.IPythonSettings, outputChannel: vscode.OutputChannel, workspaceRootPath?: string): vscode.Disposable {
    let formatters = new Map<string, BaseFormatter>();
    let pythonSettings = settings;

    let yapfFormatter = new YapfFormatter(outputChannel, settings, workspaceRootPath);
    let autoPep8 = new AutoPep8Formatter(outputChannel, settings, workspaceRootPath);

    formatters.set(yapfFormatter.Id, yapfFormatter);
    formatters.set(autoPep8.Id, autoPep8);

    return vscode.workspace.onWillSaveTextDocument(e => {
        const document = e.document;
        if (document.languageId !== languageFilter.language) {
            return;
        }
        let textEditor = vscode.window.activeTextEditor;
        let editorConfig = vscode.workspace.getConfiguration('editor');
        const globalEditorFormatOnSave = editorConfig && editorConfig.has('formatOnSave') && editorConfig.get('formatOnSave') === true;
        if ((pythonSettings.formatting.formatOnSave || globalEditorFormatOnSave) && textEditor.document === document) {
            let formatter = formatters.get(pythonSettings.formatting.provider);
            telemetryHelper.sendTelemetryEvent(telemetryContracts.IDE.Format, { Format_Provider: formatter.Id, Format_OnSave: "true" });
            e.waitUntil(formatter.formatDocument(document, null, null));
        }
    }, null, null);
}

	function configurationChanged() {
		let config = workspace.getConfiguration('tslint');
		let autoFix = config.get('autoFixOnSave', false);
		if (autoFix && !willSaveTextDocument) {
			willSaveTextDocument = workspace.onWillSaveTextDocument((event) => {
				let document = event.document;
				// only auto fix when the document was not auto saved
				if (!isTypeScriptDocument(document.languageId) || event.reason === TextDocumentSaveReason.AfterDelay) {
					return;
				}
				const version = document.version;
				event.waitUntil(
					client.sendRequest(AllFixesRequest.type, { textDocument: { uri: document.uri.toString() } }).then((result) => {
						if (result && version === result.documentVersion) {
							return Protocol2Code.asTextEdits(result.edits);
						} else {
							return [];
						}
					})
				);
			});
		} else if (!autoFix && willSaveTextDocument) {
			willSaveTextDocument.dispose();
			willSaveTextDocument = undefined;
		}
	}

export function activate(context: vscode.ExtensionContext) {
    const formatter = new TidyFormatter();

    context.subscriptions.push(vscode.workspace.onDidChangeConfiguration(formatter.readSettings, formatter));
    context.subscriptions.push(vscode.workspace.onWillSaveTextDocument(formatter.formatAuto, formatter));
    context.subscriptions.push(vscode.languages.registerDocumentFormattingEditProvider(HTMLFilter, formatter));
    context.subscriptions.push(vscode.languages.registerDocumentRangeFormattingEditProvider(HTMLFilter, formatter));
    context.subscriptions.push(vscode.commands.registerTextEditorCommand('extension.tidyHtml', formatter.formatTextEditor, formatter));

    return formatter;
}

    private registerEventListeners(): void {
        let disposables: vscode.Disposable[] = []
        if (this.settings.liveMatching) {
            disposables.push(
                vscode.window.onDidChangeActiveTextEditor((editor: vscode.TextEditor | undefined) => {
                    if (editor !== undefined) {
                        this.logger.log(`onDidChangeActiveTextEditor event called - ${editor.document.fileName}`);
                        this.trailingSpaces.highlight(editor);
                    }
                }),
                vscode.workspace.onDidChangeTextDocument((event: vscode.TextDocumentChangeEvent) => {
                    if (vscode.window.activeTextEditor !== undefined && vscode.window.activeTextEditor.document == event.document) {
                        this.logger.log(`onDidChangeTextDocument event called - ${event.document.fileName}`);
                        this.trailingSpaces.highlight(vscode.window.activeTextEditor);
                    }
                }),
                vscode.workspace.onDidOpenTextDocument((document: vscode.TextDocument) => {
                    if (vscode.window.activeTextEditor !== undefined && vscode.window.activeTextEditor.document == document) {
                        this.logger.log(`onDidOpenTextDocument event called - ${document.fileName}`);
                        this.trailingSpaces.highlight(vscode.window.activeTextEditor);
                    }
                })
            );

            if (!this.settings.highlightCurrentLine) {
                disposables.push(
                    vscode.window.onDidChangeTextEditorSelection((event: vscode.TextEditorSelectionChangeEvent) => {
                        let editor: vscode.TextEditor = event.textEditor;
                        this.logger.log(`onDidChangeTextEditorSelection event called - ${editor.document.fileName}`);
                        this.trailingSpaces.highlight(editor);
                    })
                );
            }
        }

        if (this.settings.trimOnSave) {
            disposables.push(
                vscode.workspace.onWillSaveTextDocument((event: vscode.TextDocumentWillSaveEvent) => {
                    this.logger.log(`onWillSaveTextDocument event called - ${event.document.fileName}`);
                    vscode.window.visibleTextEditors.forEach((editor: vscode.TextEditor) => {
                        if (event.document.uri === editor.document.uri) {
                            event.waitUntil(Promise.resolve(this.trailingSpaces.getEditsForDeletingTralingSpaces(editor.document)));
                        }
                    });
                })
            );
        }
        this.listenerDisposables = disposables;
    }

	constructor() {
		const subscriptions: Disposable[] = [];

		// Listen for changes in the active text editor
		subscriptions.push(window.onDidChangeActiveTextEditor(textEditor => {
			if (textEditor && textEditor.document) {
				this._onDidOpenDocument(textEditor.document);
			}
		}));

		// Listen for changes in the configuration
		subscriptions.push(workspace.onDidChangeConfiguration(
			this._onConfigChanged.bind(this)
		));

		// Listen for saves to ".editorconfig" files and rebuild the map
		subscriptions.push(workspace.onDidSaveTextDocument(savedDocument => {
			if (path.basename(savedDocument.fileName) === '.editorconfig') {
				// Saved an .editorconfig file => rebuild map entirely and then
				// apply the changes to the .editorconfig file itself
				this._rebuildConfigMap();
				// TODO The transformations should be applied to the `.editorconfig` file as well after the config
				// has been rebuilt
				// this._rebuildConfigMap().then(applyOnSaveTransformations.bind(
				// 	undefined,
				// 	savedDocument,
				// 	this
				// ));
				return;
			}
		}));

		subscriptions.push(workspace.onWillSaveTextDocument(e => {
			const edits = calculatePreSaveTransformations(e.document, this);

			e.waitUntil(Promise.resolve(edits));
		}));

		// dispose event subscriptons upon disposal
		this._disposable = Disposable.from.apply(this, subscriptions);

		// Build the map (cover the case that documents were opened before
		// my activation)
		this._rebuildConfigMap();

		// Load the initial workspace configuration
		this._onConfigChanged();
	}

export const maybeActivateFormatOnSave = () => {
    vscode.workspace.onWillSaveTextDocument(e => {
        const document = e.document;
        if (document.languageId !== "clojure") {
            return;
        }
        let textEditor = vscode.window.activeTextEditor;
        if (!textEditor) {
            return
        }
        let editorConfig = vscode.workspace.getConfiguration('editor');
        const globalEditorFormatOnSave = editorConfig && editorConfig.has('formatOnSave') && editorConfig.get('formatOnSave') === true;
        let clojureConfig = vscode.workspace.getConfiguration('clojureVSCode');
        if ((clojureConfig.formatOnSave || globalEditorFormatOnSave) && textEditor.document === document) {
            formatFile(textEditor, undefined);
        }
    });
}

export function activate(context: vscode.ExtensionContext) {

    var docType: Array<string> = ['css', 'scss', 'javascript', 'html', 'json'];

    for (var i = 0, l = docType.length; i < l; i++) {
        registerDocType(docType[i]);
    }

    let formatter = new Formatter();

    context.subscriptions.push(vscode.commands.registerCommand('Lonefy.formatting', () => {
        formatter.beautify();
    }));


    context.subscriptions.push(vscode.commands.registerCommand('Lonefy.formatterConfig', () => {

        formatter.openConfig(
            path.join(getRootPath(), '.vscode', 'formatter.json'),
            function () {
                showMesage('[Local]  After editing the file, remember to Restart VScode');
            },
            function () {
                var fileName = path.join(__dirname, 'formatter.json');
                formatter.openConfig(
                    fileName,
                    function () {
                        showMesage('[Golbal]  After editing the file, remember to Restart VScode');
                    },
                    function () {
                        showMesage('Not found file: ' + fileName);
                    })
            })
    }));


    context.subscriptions.push(vscode.commands.registerCommand('Lonefy.formatterCreateLocalConfig', () => {
        formatter.generateLocalConfig();
    }));

    context.subscriptions.push(vscode.workspace.onWillSaveTextDocument(e => {
        formatter.onSave(e)
    }));


    function registerDocType(type) {
        context.subscriptions.push(vscode.languages.registerDocumentFormattingEditProvider(type, {
            provideDocumentFormattingEdits: (document, options, token) => {
                return formatter.registerBeautify(null)
            }
        }));
        context.subscriptions.push(vscode.languages.registerDocumentRangeFormattingEditProvider(type, {
            provideDocumentRangeFormattingEdits: (document, range, options, token) => {
                var start = new vscode.Position(0, 0);
                var end = new vscode.Position(document.lineCount - 1, document.lineAt(document.lineCount - 1).text.length);
                return formatter.registerBeautify(new vscode.Range(start, end))
            }
        }));
    }



}

export function activate(context: ExtensionContext) {
  extensionContext = context
  outputChannel = vscode.window.createOutputChannel("Dotty");

  const sbtArtifact = "org.scala-sbt:sbt-launch:1.2.3"
  const buildSbtFile = `${vscode.workspace.rootPath}/build.sbt`
  const dottyPluginSbtFile = path.join(extensionContext.extensionPath, './out/dotty-plugin.sbt')
  const disableDottyIDEFile = `${vscode.workspace.rootPath}/.dotty-ide-disabled`
  const languageServerArtifactFile = `${vscode.workspace.rootPath}/.dotty-ide-artifact`
  const languageServerDefaultConfigFile = path.join(extensionContext.extensionPath, './out/default-dotty-ide-config')
  const coursierPath = path.join(extensionContext.extensionPath, './out/coursier');

  vscode.workspace.onWillSaveTextDocument(worksheet.prepareWorksheet)
  vscode.workspace.onDidSaveTextDocument(document => {
    if (worksheet.isWorksheet(document)) {
      worksheet.evaluateWorksheet(document)
    }
  })
  vscode.workspace.onDidCloseTextDocument(document => {
    if (worksheet.isWorksheet(document)) {
      worksheet.removeWorksheet(document)
    }
  })

  if (process.env['DLS_DEV_MODE']) {
    const portFile = `${vscode.workspace.rootPath}/.dotty-ide-dev-port`
    fs.readFile(portFile, (err, port) => {
      if (err) {
        outputChannel.appendLine(`Unable to parse ${portFile}`)
        throw err
      }

      run({
        module: context.asAbsolutePath('out/src/passthrough-server.js'),
        args: [ port.toString() ]
      }, false)
    })

  } else {
    // Check whether `.dotty-ide-artifact` exists. If it does, start the language server,
    // otherwise, try propose to start it if there's no build.sbt
    if (fs.existsSync(languageServerArtifactFile)) {
      runLanguageServer(coursierPath, languageServerArtifactFile)
    } else if (!fs.existsSync(disableDottyIDEFile) && !fs.existsSync(buildSbtFile)) {
      vscode.window.showInformationMessage(
          "This looks like an unconfigured Scala project. Would you like to start the Dotty IDE?",
          "Yes", "No"
      ).then(choice => {
        if (choice == "Yes") {
          fs.readFile(languageServerDefaultConfigFile, (err, data) => {
            if (err) throw err
            else {
              const languageServerScalaVersion = data.toString().trim()
              fetchAndConfigure(coursierPath, sbtArtifact, languageServerScalaVersion, dottyPluginSbtFile).then(() => {
                runLanguageServer(coursierPath, languageServerArtifactFile)
              })
            }
          })
        } else {
          fs.appendFile(disableDottyIDEFile, "", _ => {})
        }
      })
    }
  }
}