Viewport events are not being mediated.

src/dataEditor/dataEditorClient.ts

@@ -89,9 +89,13 @@ import {
   ServerStopPredicate,
 } from './include/server/ServerInfo'
 import { isDFDLDebugSessionActive } from './include/utils'
-import { OmegaEditServer, ServiceHeartbeat } from './include/server/Server'
-import { DataEditor, DataEditorUI } from './include/client/dataEditorClient'
-import { StandaloneEditor } from './standalone/standaloneEditor'
+import { DataEditor } from './include/client/dataEditorClient'
+import {
+  DataEditorWebviewPanel,
+  StandaloneEditor,
+} from './standalone/standaloneEditor'
+import { IStatusUpdater } from './include/status/IStatus'
+import { OmegaEditServer } from './include/omegaEdit/omegaEditServer'
 
 // *****************************************************************************
 // global constants
@@ -127,39 +131,56 @@ let omegaEditPort: number = 0
 // const vscodeInfoHeartbeat = new ServiceHeartbeat('test', (hb) => {
 //   vscode.window.showInformationMessage(`Got heartbeat w/ ${hb.latency} latency`)
 // })
-class DataEditorWebviewPanel implements DataEditorUI {
-  protected panel: vscode.WebviewPanel
-  private view: string = 'dataeditor'
-  private constructor(title: string) {
-    this.panel = vscode.window.createWebviewPanel(
-      this.view,
-      title,
-      vscode.ViewColumn.Active,
-      { enableScripts: true, retainContextWhenHidden: true }
-    )
+class StatusBar implements IStatusUpdater {
+  private tag: string = ''
+  private item = vscode.window.createStatusBarItem(
+    vscode.StatusBarAlignment.Left
+  )
+  update(status: string) {
+    this.item.text = this.tag + status
+    this.item.show()
   }
-  static async create(title: string): Promise<DataEditorWebviewPanel> {
-    return new Promise((resolve, reject) => {
-      resolve(new DataEditorWebviewPanel(title))
-    })
+  setTag(tag: string) {
+    this.tag = '[' + tag + '] '
   }
-  async show(): Promise<void> {
-    this.panel.reveal()
+  dispose() {
+    this.item.dispose()
   }
 }
+interface DataEditorInitializer {
+  initialize(params: any): Promise<DataEditor>
+}
+const StandaloneInitializer: DataEditorInitializer = {
+  initialize: (params: { ctx: vscode.ExtensionContext }) => {
+    return new Promise(async (resolve) => {
+      const statusBar = new StatusBar()
+      statusBar.update('[Data Editor]: Extracting Configuration Variables')
+      let configVars = editor_config.extractConfigurationVariables()
+      let server = new OmegaEditServer('127.0.0.1', configVars.port)
+
+      await server.start(statusBar)
+      statusBar.update('[Data Editor]: Server Startup Complete!')
+      /* Moving on w/ assumption that server is up and running */
+      const editor = new StandaloneEditor(params.ctx, configVars)
+      await editor.getServiceFrom(server)
+      editor.initializeUI(new DataEditorWebviewPanel(editor.filePath()))
+      statusBar.dispose()
+      resolve(editor)
+    })
+  },
+}
 export function activate(ctx: vscode.ExtensionContext): void {
   ctx.subscriptions.push(
     vscode.commands.registerCommand(
       DATA_EDITOR_COMMAND,
-      async (fileToEdit: string = '') => {
-        let configVars = editor_config.extractConfigurationVariables()
-        let server = new OmegaEditServer('127.0.0.1', configVars.port)
-        await server.start()
-        /* Moving on w/ assumption that server is up and running */
-        const editor = new StandaloneEditor(ctx, configVars)
-        await editor.initialize(server)
-        // await server.register(editor.heatbeat)
-        // return await createDataEditorWebviewPanel(ctx, configVars, fileToEdit)
+      async (
+        initializer: DataEditorInitializer = StandaloneInitializer,
+        params: any = {
+          ctx: ctx,
+        }
+      ) => {
+        const editor = await initializer.initialize(params)
+        return editor
       }
     )
   )

src/dataEditor/include/client/dataEditorClient.ts

@@ -1,14 +1,21 @@
 import { IEditServiceProvider } from '../server/Server'
-import { IEditService } from '../service/editorService'
-export abstract class DataEditor {
+import { IEditService, IServiceMediator } from '../service/editorService'
+import { DataEditorUI } from './dataEditorUI'
+export abstract class DataEditor implements IServiceMediator {
   protected abstract fileToEdit: string
+  protected abstract ui: DataEditorUI | undefined
+
   protected editService: IEditService | undefined = undefined
-  async initialize(provider: IEditServiceProvider) {
+
+  abstract initializeUI(ui: DataEditorUI): void
+  abstract notify(notification: { id: string; data: any }): void
+  protected abstract getFile(): Promise<void>
+
+  filePath() {
+    return this.fileToEdit
+  }
+  async getServiceFrom(provider: IEditServiceProvider) {
     await this.getFile()
-    this.editService = await provider.getService(this.fileToEdit)
+    this.editService = await provider.getService(this, this.fileToEdit)
   }
-  protected abstract getFile(): Promise<void>
-}
-export interface DataEditorUI {
-  show(): Promise<void>
 }

src/dataEditor/include/client/dataEditorUI.ts

@@ -0,0 +1,4 @@
+export interface DataEditorUI {
+  show(): Promise<void>
+  sendMessage(msg: any): void
+}

src/dataEditor/include/omegaEdit/Session.ts

@@ -0,0 +1,102 @@
+import {
+  ALL_EVENTS,
+  CreateSessionResponse,
+  EditorClient,
+  EventSubscriptionRequest,
+  ViewportDataResponse,
+  ViewportEvent,
+  ViewportEventKind,
+  createViewport,
+  getByteOrderMark,
+  getClient,
+  getContentType,
+  getLanguage,
+} from '@omega-edit/client'
+import EventEmitter from 'events'
+import { Viewport } from './Viewport'
+
+/* OmegaEditService Implementation */
+const SessionMetadata = {
+  byteOrderMark: '',
+  changeCount: 0,
+  computedFileSize: 0,
+  diskFileSize: 0,
+  fileName: '',
+  language: '',
+  type: '',
+  undoCount: 0,
+}
+export class Session {
+  readonly id: string
+
+  private metadata = SessionMetadata
+  private metadataEventEmitter = new EventEmitter()
+  private viewports: Map<string, Viewport> = new Map()
+
+  constructor(
+    response: CreateSessionResponse,
+    public onMetadataUpdate: (data: typeof SessionMetadata) => void
+  ) {
+    this.id = response.getSessionId()
+    if (response.hasFileSize()) {
+      this.metadata.diskFileSize = this.metadata.computedFileSize =
+        response.getFileSize()!
+    }
+    this.populateAsyncMetadata().then(() => {
+      this.onMetadataUpdate(this.metadata)
+    })
+  }
+  async createViewport(
+    client: EditorClient,
+    offset: number,
+    capacity: number,
+    onDataEvent: (event: Viewport) => void
+  ): Promise<void> {
+    return new Promise((resolve, reject) => {
+      createViewport(undefined, this.id, offset, capacity)
+        .then((response) => {
+          this.viewports.set(
+            response.getViewportId(),
+            new Viewport(response.getData_asU8(), capacity)
+          )
+          client
+            .subscribeToViewportEvents(
+              new EventSubscriptionRequest()
+                .setId(response.getViewportId())
+                .setInterest(
+                  ALL_EVENTS & ~ViewportEventKind.VIEWPORT_EVT_MODIFY
+                )
+            )
+            .on('data', async (event: ViewportEvent) => {
+              onDataEvent(new Viewport(event.getData_asU8(), 1024))
+            })
+          resolve()
+        })
+        .catch((err) => {
+          reject(err)
+        })
+    })
+  }
+  info() {
+    return { ...this.metadata }
+  }
+  private async populateAsyncMetadata() {
+    const contentTypeResponse = await getContentType(
+      this.id,
+      0,
+      Math.min(1024, this.metadata.computedFileSize)
+    )
+    this.metadata.type = contentTypeResponse.getContentType()
+
+    const byteOrderMarkResponse = await getByteOrderMark(this.id, 0)
+    this.metadata.byteOrderMark = byteOrderMarkResponse.getByteOrderMark()
+
+    const languageResponse = await getLanguage(
+      this.id,
+      0,
+      Math.min(1024, this.metadata.computedFileSize),
+      this.metadata.byteOrderMark
+    )
+    this.metadata.language = languageResponse.getLanguage()
+  }
+}

src/dataEditor/include/omegaEdit/Viewport.ts

@@ -0,0 +1,11 @@
+import { ViewportDataResponse } from '@omega-edit/client'
+
+export class Viewport {
+  constructor(
+    protected data: Uint8Array,
+    protected capacity: number
+  ) {}
+  length() {
+    return this.data.length
+  }
+}