Viewport now sends mediator notify

src/dataEditor/include/omegaEdit/Session.ts

@@ -11,6 +11,8 @@ import {
   getClient,
   getContentType,
   getLanguage,
+  getLogger,
+  getViewportData,
 } from '@omega-edit/client'
 import EventEmitter from 'events'
 import { Viewport } from './Viewport'
@@ -31,8 +33,8 @@ export class Session {
 
   private metadata = SessionMetadata
   private metadataEventEmitter = new EventEmitter()
-  private viewports: Map<string, Viewport> = new Map()
-
+  // private viewports: Map<Viewport, (viewport: Viewport) => void> = new Map()
+  private viewports: Viewport[] = []
   constructor(
     response: CreateSessionResponse,
     public onMetadataUpdate: (data: typeof SessionMetadata) => void
@@ -46,30 +48,44 @@ export class Session {
       this.onMetadataUpdate(this.metadata)
     })
   }
+  getViewports() {
+    return this.viewports
+  }
   async createViewport(
-    client: EditorClient,
+    // 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
-                )
+          this.viewports.push(
+            new Viewport(
+              response.getViewportId(),
+              response.getData_asU8(),
+              capacity,
+              onDataEvent
             )
-            .on('data', async (event: ViewportEvent) => {
-              onDataEvent(new Viewport(event.getData_asU8(), 1024))
-            })
+          )
+          // client
+          //   .subscribeToViewportEvents(
+          //     new EventSubscriptionRequest()
+          //       .setId(response.getViewportId())
+          //       .setInterest(
+          //         ALL_EVENTS & ~ViewportEventKind.VIEWPORT_EVT_MODIFY
+          //       )
+          //   )
+          //   .on('data', async (event: ViewportEvent) => {
+          //     getLogger().debug({
+          //       viewportId: event.getViewportId(),
+          //       event: event.getViewportEventKind(),
+          //     })
+          //     const viewport = this.viewports.find((viewport) => {
+          //       return viewport.id == event.getViewportId()
+          //     })
+          //     onDataEvent(viewport!)
+          //   })
           resolve()
         })
         .catch((err) => {

src/dataEditor/include/omegaEdit/Viewport.ts

@@ -1,11 +1,19 @@
-import { ViewportDataResponse } from '@omega-edit/client'
+import { createViewport, modifyViewport } from '@omega-edit/client'
 
 export class Viewport {
   constructor(
+    readonly id: string,
     protected data: Uint8Array,
-    protected capacity: number
+    protected capacity: number,
+    public onDataUpdate: (viewport: Viewport) => void
   ) {}
   length() {
     return this.data.length
   }
+  setOffset(offset: number) {
+    modifyViewport(this.id, offset, this.capacity).then((response) => {
+      this.data = response.getData_asU8()
+      this.onDataUpdate(this)
+    })
+  }
 }

src/dataEditor/include/omegaEdit/omegaEditService.ts

@@ -1,8 +1,15 @@
-import { EditorClient, createSession, getClient } from '@omega-edit/client'
+import {
+  EditorClient,
+  createSession,
+  getClient,
+  modifyViewport,
+} from '@omega-edit/client'
 import { IEditService, IServiceMediator } from '../service/editorService'
 import { Session } from './Session'
+import { Viewport } from './Viewport'
 
 export class OmegaEditService extends IEditService {
+  static ViewportCapacity = 1024
   private session: Session | undefined = undefined
 
   constructor(
@@ -19,16 +26,40 @@ export class OmegaEditService extends IEditService {
           data: data,
         })
       })
-      this.session.createViewport(this.client, 0, 1024, (event) => {
-        this.mediator.notify({
-          id: 'viewport-updated',
-          data: event,
-        })
-      })
+      this.session.createViewport(
+        0,
+        OmegaEditService.ViewportCapacity,
+        (event) => {
+          this.mediator.notify({
+            id: 'viewport-updated',
+            data: event,
+          })
+        }
+      )
     } catch {
       throw new Error('Could not setup Omegaeditservice')
     }
   }
   async destroy() {}
+  getViewport(byId: string): Viewport | undefined {
+    if (byId === '') return this.session?.getViewports()[0]
+    return this.session?.getViewports().find((vp) => {
+      return vp.id === byId
+    })
+  }
+  // async scrollViewport(
+  //   offset: number,
+  //   onViewportUpdate: (viewport: Viewport) => void
+  // ) {
+  //   const first = this.session?.getViewports()[0]
+  //   modifyViewport(first!.id, offset, OmegaEditService.ViewportCapacity).then(
+  //     (response) => {
+  //       const viewport = this.session?.getViewports().find((vp) => {
+  //         return vp.id == response.getViewportId()
+  //       })
+  //       onViewportUpdate(viewport!)
+  //     }
+  //   )
+  // }
 }
 // service requires a running server

src/dataEditor/standalone/standaloneEditor.ts

@@ -27,6 +27,18 @@ export class StandaloneEditor extends DataEditor implements vscode.Disposable {
   }
   initializeUI(ui: DataEditorWebviewPanel): void {
     this.ui = ui
+    setTimeout(() => {
+      // Simulate UI Request to scroll viewport
+      const request = {
+        type: 'scroll',
+        viewportId: '',
+        offset: 2000,
+      }
+      console.debug('Sending scrollViewport request')
+      this.editService!.getViewport(request.viewportId)?.setOffset(
+        request.offset
+      )
+    }, 4000)
   }
   async getFile(): Promise<void> {
     const fileUri = await vscode.window.showOpenDialog({