TypeScript window.createTerminal方法代码示例

 public async startTask(
     executable: string,
     preCommandArgs: string[],
     command: string,
     args: string[],
     cwd: string
 ): Promise<void> {
     args = preCommandArgs.concat(command, ...args);
     const terminal = window.createTerminal('Cargo Task');
     this._runningTerminal = terminal;
     const shell = await this._shellProvider.getValue();
     if (shell === undefined) {
         return;
     }
     const setEnvironmentVariables = () => {
         const cargoEnv = this._configuration.getCargoEnv();
         // Set environment variables
         for (const name in cargoEnv) {
             if (name in cargoEnv) {
                 const value = cargoEnv[name];
                 terminal.sendText(getCommandToSetEnvVar(shell, name, value));
             }
         }
     };
     setEnvironmentVariables();
     // Change the current directory to a specified directory
     this._runningTerminal.sendText(getCommandToChangeWorkingDirectory(shell, cwd));
     // Start a requested command
     this._runningTerminal.sendText(getCommandForArgs(shell, [executable, ...args]));
     this._runningTerminal.show(true);
 }

function execCommand(tool: string, compileMode: boolean, fileState: {filePath: string, redsystem: boolean}, guiMode?: boolean, toolChain?: boolean) {
	let redConfigs = RedConfiguration.getInstance();
	let text: string;

	terminal = terminal ? terminal : vscode.window.createTerminal(`Red`);

	if (compileMode || fileState.redsystem) {
		let buildDir: string;
		let outputFilename: string;
		buildDir = redConfigs.redWorkSpace || vscode.workspace.rootPath || path.dirname(fileState.filePath);
		outputFilename = path.join(buildDir, path.parse(fileState.filePath).name);
		if (guiMode && (process.platform == 'win32' || process.platform == 'darwin')) {
			let target: string;
			if (process.platform == 'win32') {
				target = "Windows";
			} else {
				target = "macOS";
			}
			text = `${tool} -t ${target} -o "${outputFilename}" -c "${fileState.filePath}"`;
		} else {
			text = `${tool} -o "${outputFilename}" -c "${fileState.filePath}"`;
		}
	} else {
			if (toolChain) {
				text = `${tool} --cli "${fileState.filePath}"`;
			} else {
				text = `${tool} "${fileState.filePath}"`
			}
	}
	terminal.sendText(text);
	terminal.show();
}

    return getPythonInterpreterDirectory().then(pyPath => {
        let commands = [];
        if (IS_WINDOWS) {
            commands.push(`set ${PATH_VARIABLE_NAME}=%${PATH_VARIABLE_NAME}%;${pyPath}`);
        }
        else {
            commands.push(`export ${PATH_VARIABLE_NAME}=$${PATH_VARIABLE_NAME}:${pyPath}`);
        }
        if (cwd !== workspace.rootPath && typeof cwd === 'string') {
            commands.push(`cd ${cwd}`);
        }
        commands.push(`${file} ${args.join(' ')}`);
        terminal = window.createTerminal(`Python Test Log`);

        return new Promise<any>((resolve) => {
            setTimeout(function () {
                terminal.show();
                terminal.sendText(commands.join(' && '));

                // Bug, we cannot resolve this
                // Resolving here means that tests have completed
                // We need a way to determine that the tests have completed succefully.. hmm
                resolve();
            }, 1000);
        });
    });

function execSelectionInTerminal() {
    const currentPythonPath = settings.PythonSettings.getInstance().pythonPath;
    const activeEditor = vscode.window.activeTextEditor;
    if (!activeEditor) {
        return;
    }

    const selection = vscode.window.activeTextEditor.selection;
    if (selection.isEmpty) {
        return;
    }
    const code = vscode.window.activeTextEditor.document.getText(new vscode.Range(selection.start, selection.end));
    terminal = terminal ? terminal : vscode.window.createTerminal(`Python`);
    const launchArgs = settings.PythonSettings.getInstance().terminal.launchArgs;
    const launchArgsString = launchArgs.length > 0 ? " ".concat(launchArgs.join(" ")) : "";
    if (IS_WINDOWS) {
        // Multi line commands don't work the same way on windows terminals as it does on other OS
        // So just start the Python REPL, then send the commands
        terminal.sendText(`"${currentPythonPath}"${launchArgsString}`);
        terminal.sendText(code);
    }
    else {
        terminal.sendText(`${currentPythonPath}${launchArgsString} -c "${code}"`);
    }
    terminal.show();
}

		test('processId immediately after createTerminal should fetch the pid', (done) => {
			const terminal = window.createTerminal();
			terminal.processId.then(id => {
				assert.ok(id > 0);
				terminal.dispose();
				done();
			});
		});

	test('createTerminal, Terminal.name', () => {
		var terminal = window.createTerminal('foo');
		assert.equal(terminal.name, 'foo');

		assert.throws(() => {
			terminal.name = 'bar';
		}, 'Terminal.name should be readonly');
	});

 vscode.commands.registerCommand('ocaml.utop', async () => {
     if (utopTerm) {
         utopTerm.dispose();
     }
     utopTerm = vscode.window.createTerminal('OCaml UTop');
     utopTerm.sendText('utop', true);
     utopTerm.show();
 })

 const runCommandInIntegratedTerminal = (args: string[], cwd: string) => {
   if (terminal === null) {
     terminal = window.createTerminal('sbt');
     // start sbt
     terminal.sendText('sbt', true);
   }
   terminal.show();
   terminal.sendText(args.join(' '));
 };

		test('runInBackground terminal: should be available to terminals API', done => {
			const terminal = window.createTerminal({ name: 'bg', runInBackground: true });
			window.onDidOpenTerminal(t => {
				assert.equal(t, terminal);
				assert.equal(t.name, 'bg');
				assert.ok(window.terminals.indexOf(terminal) !== -1);
				done();
			});
		});