Add window state API (#21)

packages/plugin-ext/src/api/plugin-api.ts

@@ -80,6 +80,10 @@ export interface QuickOpenMain {
  $input(options: theia.InputBoxOptions, validateInput: boolean): PromiseLike<string>;
 }
 
+export interface WindowStateExt {
+ $onWindowStateChanged(focus: boolean): void;
+}
+
 export const PLUGIN_RPC_CONTEXT = {
  COMMAND_REGISTRY_MAIN: <ProxyIdentifier<CommandRegistryMain>>createProxyIdentifier<CommandRegistryMain>('CommandRegistryMain'),
  QUICK_OPEN_MAIN: createProxyIdentifier<QuickOpenMain>('QuickOpenMain'),
@@ -89,5 +93,6 @@ export const PLUGIN_RPC_CONTEXT = {
 export const MAIN_RPC_CONTEXT = {
  HOSTED_PLUGIN_MANAGER_EXT: createProxyIdentifier<HostedPluginManagerExt>('HostedPluginManagerExt'),
  COMMAND_REGISTRY_EXT: createProxyIdentifier<CommandRegistryExt>('CommandRegistryExt'),
- QUICK_OPEN_EXT: createProxyIdentifier<QuickOpenExt>('QuickOpenExt')
+ QUICK_OPEN_EXT: createProxyIdentifier<QuickOpenExt>('QuickOpenExt'),
+ WINDOW_STATE_EXT: createProxyIdentifier<WindowStateExt>('WindowStateExt')
 };

packages/plugin-ext/src/main/browser/main-context.ts

@@ -10,6 +10,7 @@ import { QuickOpenMainImpl } from './quick-open-main';
 import { RPCProtocol } from '../../api/rpc-protocol';
 import { PLUGIN_RPC_CONTEXT } from '../../api/plugin-api';
 import { MessageRegistryMainImpl } from './message-registry-main';
+import { WindowStateMain } from './window-state-main';
 
 export function setUpPluginApi(rpc: RPCProtocol, container: interfaces.Container): void {
  const commandRegistryMain = new CommandRegistryMainImpl(rpc, container);
@@ -20,4 +21,8 @@ export function setUpPluginApi(rpc: RPCProtocol, container: interfaces.Container
 
  const messageRegistryMain = new MessageRegistryMainImpl(container);
  rpc.set(PLUGIN_RPC_CONTEXT.MESSAGE_REGISTRY_MAIN, messageRegistryMain);
+
+ // tslint:disable-next-line:no-unused-variable
+ // @ts-ignore
+ const windowStateMain = new WindowStateMain(rpc);
 }

packages/plugin-ext/src/main/browser/plugin-worker.ts

@@ -19,10 +19,13 @@ export class PluginWorker {
  this.worker.onmessage = (message) => {
  emmitter.fire(message.data);
  };
+ this.worker.onerror = e => console.error(e);
 
  this.rpc = new RPCProtocolImpl({
  onMessage: emmitter.event,
- send: (m: {}) => this.worker.postMessage(m)
+ send: (m: {}) => {
+ this.worker.postMessage(m);
+ }
  });
 
  }

packages/plugin-ext/src/main/browser/window-state-main.ts

@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2018 Red Hat, Inc. and others.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ */
+
+import { WindowStateExt, MAIN_RPC_CONTEXT } from "../../api/plugin-api";
+import { RPCProtocol } from "../../api/rpc-protocol";
+
+export class WindowStateMain {
+
+ private proxy: WindowStateExt;
+
+ constructor(rpc: RPCProtocol) {
+ this.proxy = rpc.getProxy(MAIN_RPC_CONTEXT.WINDOW_STATE_EXT);
+
+ window.addEventListener("focus", () => this.onFocusChanged(true));
+ window.addEventListener("blur", () => this.onFocusChanged(false));
+ }
+
+ private onFocusChanged(focused: boolean): void {
+ this.proxy.$onWindowStateChanged(focused);
+ }
+
+}

packages/plugin-ext/src/plugin/plugin-context.ts

@@ -14,11 +14,13 @@ import { RPCProtocol } from '../api/rpc-protocol';
 import { getPluginId } from '../common/plugin-protocol';
 import { Disposable } from './types-impl';
 import { MessageRegistryExt } from './message-registry';
+import { WindowStateExtImpl } from './window-state';
 
 export function createAPI(rpc: RPCProtocol): typeof theia {
  const commandRegistryExt = rpc.set(MAIN_RPC_CONTEXT.COMMAND_REGISTRY_EXT, new CommandRegistryImpl(rpc));
  const quickOpenExt = rpc.set(MAIN_RPC_CONTEXT.QUICK_OPEN_EXT, new QuickOpenExtImpl(rpc));
  const messageRegistryExt = new MessageRegistryExt(rpc);
+ const windowStateExt = rpc.set(MAIN_RPC_CONTEXT.WINDOW_STATE_EXT, new WindowStateExtImpl(rpc));
 
  const commands: typeof theia.commands = {
  registerCommand(command: theia.Command, handler?: <T>(...args: any[]) => T | Thenable<T>): Disposable {
@@ -53,6 +55,13 @@ export function createAPI(rpc: RPCProtocol): typeof theia {
  optionsOrFirstItem: theia.MessageOptions | string | theia.MessageItem,
  ...items: any[]): PromiseLike<any> {
  return messageRegistryExt.showErrorMessage(message, optionsOrFirstItem, items);
+ },
+
+ get state(): theia.WindowState {
+ return windowStateExt.getWindowState();
+ },
+ onDidChangeWindowState(listener, thisArg?, disposables?): theia.Disposable {
+ return windowStateExt.onDidChangeWindowState(listener, thisArg, disposables);
  }
  };
 

packages/plugin-ext/src/plugin/window-state.ts

@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2018 Red Hat, Inc. and others.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ */
+
+import { WindowState } from "@theia/plugin";
+import { WindowStateExt } from "../api/plugin-api";
+import { RPCProtocol } from "../api/rpc-protocol";
+import { Event, Emitter } from "@theia/core/lib/common/event";
+
+export class WindowStateExtImpl implements WindowStateExt {
+
+ private windowStateCached: WindowState;
+
+ private windowStateChangedEmitter = new Emitter<WindowState>();
+ public readonly onDidChangeWindowState: Event<WindowState> = this.windowStateChangedEmitter.event;
+
+ constructor(rpc: RPCProtocol) {
+ this.windowStateCached = { focused: true }; // supposed tab is active on start
+ }
+
+ getWindowState(): WindowState {
+ return this.windowStateCached;
+ }
+
+ $onWindowStateChanged(focused: boolean): void {
+ const state = { focused: focused };
+ if (state === this.windowStateCached) {
+ return;
+ }
+
+ this.windowStateCached = state;
+ this.windowStateChangedEmitter.fire(state);
+ }
+
+}

packages/plugin/API.md

@@ -1,20 +1,21 @@
 # Introduction
+
 ## Theia Plugin system description
 
 ### Command API
+
  A command is a unique identifier of a function which
  can be executed by a user via a keyboard shortcut, a
  menu action or directly.
 
 Commands can be added using the [registerCommand](#commands.registerCommand) and
 [registerTextEditorCommand](#commands.registerTextEditorCommand) functions.
-Registration can be split in two step: first register command without handler, 
-second register handler by command id.
+Registration can be split in two step: first register command without handler, second register handler by command id.
 
-Any contributed command are available to any plugin, command can be invoked 
-by [executeCommand](#commands.executeCommand) function.
+Any contributed command are available to any plugin, command can be invoked by [executeCommand](#commands.executeCommand) function.
 
 Simple example that register command:
+
 ```javascript
 theia.commands.registerCommand({id:'say.hello.command'}, ()=>{
  console.log("Hello World!");
@@ -51,22 +52,49 @@ theia.window.showQuickPick(["foo", "bar", "foobar"], option).then((val: string[]
  console.log(`Quick Pick Selected: ${val}`);
  });
 ```
+
 #### Notification API
+
  A notification shows an information message to users.
  Optionally provide an array of items which will be presented as clickable buttons.
- 
+
  Notifications can be shown using the [showInformationMessage](#window.showInformationMessage),
  [showWarningMessage](#window.showWarningMessage) and [showErrorMessage](#window.showErrorMessage) functions.
-
 
 Simple example that show an information message:
+
 ```javascript
 theia.window.showInformationMessage('Information message');
 ```
 
 Simple example that show an information message with buttons:
+
 ```javascript
 theia.window.showInformationMessage('Information message', 'Btn1', 'Btn2').then(result => {
  console.log("Click button", result);
 });
 ```
+
+#### Window State API
+
+It is possible to track state of the IDE window inside a plugin. Window state is defined as:
+
+```javascript
+interface WindowState {
+ readonly focused: boolean;
+}
+```
+
+To read a state on demand one can use readonly variable:
+
+```javascript
+theia.window.state
+```
+
+To track window activity subscribe on `onDidChangeWindowState` event:
+
+```javascript
+const disposable = theia.window.onDidChangeWindowState((windowState: theia.WindowState) => {
+ console.log('Window focus changed: ', windowState.focused);
+});
+```

packages/plugin/src/theia.d.ts

@@ -272,6 +272,16 @@ declare module '@theia/plugin' {
  modal?: boolean;
  }
 
+ /**
+ * Represents the state of a window.
+ */
+ export interface WindowState {
+ /**
+ * Whether the current window is focused.
+ */
+ readonly focused: boolean;
+ }
+
  /**
  * Common namespace for dealing with window and editor, showing messages and user input.
  */
@@ -416,5 +426,18 @@ declare module '@theia/plugin' {
  * @return A promise that resolves to the selected item or `undefined` when being dismissed.
  */
  export function showErrorMessage<T extends MessageItem>(message: string, options: MessageOptions, ...items: T[]): PromiseLike<T | undefined>;
+
+ /**
+ * Represents the current window's state.
+ *
+ * @readonly
+ */
+ export let state: WindowState;
+
+ /**
+ * An event which fires when the focus state of the current window changes.
+ * The value of the event represents whether the window is focused.
+ */
+ export const onDidChangeWindowState: Event<WindowState>;
  }
 }