Feature insert time

keymaps/veda.json

@@ -5,7 +5,8 @@
     "ctrl-alt-enter": "veda:watch-active-shader",
     "ctrl-.": "veda:stop-watching",
     "alt-enter": "veda:load-sound-shader",
-    "alt-.": "veda:stop-sound-shader"
+    "alt-.": "veda:stop-sound-shader",
+    "ctrl-shift-t": "veda:insert-time"
   },
   ".veda-enabled": {
     "ctrl-escape": "veda:toggle-fullscreen",

src/app.ts

@@ -376,4 +376,19 @@ export default class App {
     setRecordingMode(mode: RecordingMode): void {
         this.recorder.setRecordingMode(mode);
     }
+
+    insertTime(): void {
+        this.player.query('TIME').then(
+            (time: number) => {
+                const editor = atom.workspace.getActiveTextEditor();
+                if (editor) {
+                    editor.insertText(time.toString());
+                }
+            },
+            (err: string) => {
+                console.error(err);
+                atom.notifications.addError('[VEDA] Failed to get time.');
+            },
+        );
+    }
 }

src/constants.ts

@@ -63,3 +63,8 @@ export interface ICommand {
     type: CommandType;
     data: CommandData;
 }
+
+export type QueryType = 'TIME';
+export interface IQuery {
+    type: QueryType;
+}

src/playable.ts

@@ -1,8 +1,9 @@
-import { CommandType, CommandData } from './constants';
+import { CommandType, CommandData, QueryType } from './constants';
 import { IRcDiff } from './config';
 
 export interface IPlayable {
     destroy: () => void;
     onChange: (rcDiff: IRcDiff) => void;
     command(type: CommandType, payload?: CommandData): void;
+    query(type: QueryType): Promise<any>;
 }

src/player-client.ts

@@ -2,7 +2,7 @@ import * as io from 'socket.io-client';
 import Player from './player';
 import View from './view';
 import { IRc, IRcDiff } from './config';
-import { IShader, ICommand } from './constants';
+import { IShader, ICommand, IQuery } from './constants';
 
 interface ICreateOpts {
     rc: IRc;
@@ -42,6 +42,21 @@ export default class PlayerClient {
         this.socket.on('command', (data: ICommand) => {
             this.player && this.player.command(data.type, data.data);
         });
+        this.socket.on(
+            'query',
+            (
+                data: IQuery,
+                callback: (err: string | null, value?: any) => void,
+            ) => {
+                if (!this.player) {
+                    return callback('[VEDA] Player is not initialized.');
+                }
+
+                this.player
+                    .query(data.type)
+                    .then(value => callback(null, value), callback);
+            },
+        );
         this.socket.on('connect', () => {
             console.log('[VEDA] Connected to the server');
             this.poll();

src/player-server.ts

@@ -5,7 +5,7 @@ import { cloneDeep } from 'lodash';
 import { ChildProcess } from 'child_process';
 import { IRc, IRcDiff, IImportedHash } from './config';
 import { IPlayable } from './playable';
-import { IShader, CommandType, CommandData } from './constants';
+import { IShader, CommandType, CommandData, QueryType } from './constants';
 import { convertPathForServer } from './utils';
 
 interface IPlayerState {
@@ -80,6 +80,22 @@ export default class PlayerServer implements IPlayable {
         }
     }
 
+    query(type: QueryType) {
+        return new Promise<any>((resolve, reject) => {
+            this.io.emit(
+                'query',
+                { type },
+                (err: string | null, value?: any) => {
+                    if (err) {
+                        return reject(err);
+                    } else {
+                        return resolve(value);
+                    }
+                },
+            );
+        });
+    }
+
     private convertPaths(IMPORTED: IImportedHash) {
         Object.keys(IMPORTED).forEach(key => {
             IMPORTED[key].PATH = convertPathForServer(

src/player.ts

@@ -2,7 +2,13 @@ import Veda from 'vedajs';
 import View from './view';
 import { IRc, IRcDiff } from './config';
 import { IPlayable } from './playable';
-import { IShader, IOscData, CommandType, CommandData } from './constants';
+import {
+    IShader,
+    IOscData,
+    CommandType,
+    CommandData,
+    QueryType,
+} from './constants';
 import * as THREE from 'three';
 
 export default class Player implements IPlayable {
@@ -134,6 +140,16 @@ export default class Player implements IPlayable {
         }
     }
 
+    query(type: QueryType): Promise<any> {
+        switch (type) {
+            case 'TIME':
+                return Promise.resolve(this.veda.getTime());
+            default:
+                console.error('>> Unsupported query', type);
+                return Promise.reject('Unsupported query');
+        }
+    }
+
     private play(): void {
         this.view.show();
         this.veda.play();

src/server.ts

@@ -29,6 +29,17 @@
         socket.on('command', (msg: any) => {
             socket.broadcast.emit('command', msg);
         });
+        socket.on('query', (msg: any, callback: any) => {
+            const socketIds = Object.keys(io.sockets.sockets).filter(
+                socketId => socketId !== socket.id,
+            );
+
+            if (socketIds.length !== 1) {
+                return callback('[VEDA] A unique browser should be open.');
+            }
+
+            io.sockets.sockets[socketIds[0]].emit('query', msg, callback);
+        });
     });
 
     server.listen(PORT, () => {

src/utils.ts

@@ -16,7 +16,11 @@ export function convertPathForServer(
     }
 
     // Get relative path from projectPath
-    const relativePath = path.relative(projectPath, target);
+    let relativePath = path.relative(projectPath, target);
+
+    if (path.sep === '\\') {
+        relativePath = relativePath.replace(/\\/g, '/');
+    }
 
     return `http://localhost:${port}/link/${relativePath}`;
 }

src/wrapper.ts

@@ -71,6 +71,7 @@ export default class Wrapper {
                 'veda:toggle-fullscreen': () => this.app.toggleFullscreen(),
                 'veda:start-recording': () => this.app.startRecording(),
                 'veda:stop-recording': () => this.app.stopRecording(),
+                'veda:insert-time': () => this.app.insertTime(),
             }),
         );