loupedeck-commander 1.2.11 → 1.3.0

package/common/button.mjs

@@ -0,0 +1,457 @@
+
+import { loadImage } from 'canvas'
+//import { loadImage } from "https://deno.land/x/canvas/mod.ts";
+import { calcDelta, invertColor } from './utils.mjs'
+import format from 'string-template'
+
+import { shellinterface, httpinterface, opcuainterface, profileEmitter } from '../interfaces/interfaces.mjs'
+
+export const ButtonType = {
+  NONE: '',
+  TOGGLE: 'TOGGLE',
+  PUSH: 'PUSH'
+}
+
+
+
+export class Button {
+  #profile
+  #params
+  //#data
+  #index = 0
+  #enforcedIndex = -1
+  #event
+  #keys
+  #states 
+  // Timestamp when button was pressed
+  timeStampPressed
+  // Timestamp when button was released
+  timeStampReleased
+  // Time actually hold the button in ms
+  timeHold
+  #counter = 0
+
+  constructor (id, width, height, data={},key,profile = {}) {
+    this.#states = {}
+    this.#keys = []
+    
+    this.id = id
+    this.#index = 0
+    this.#enforcedIndex = -1
+
+    this.#profile = profile
+    this.#params = {
+        "key" : key,
+        "state" : '',
+        "width" : width,
+        "height" : height,
+        "min" : 0,
+        "max" : 100,
+        "x" : 0,
+        "y" : 0,
+        "color" : '#000000',
+        "text" : '',
+        "textColor" : '#ffffff',
+        "textAlign" : 'center',
+        "textBaseline": 'top',
+        "font" :'16px Arial',
+        "value" : 50,
+        "minPressed": 25,
+        "moveLeft" : false,
+        "moveRight" : false,
+        "moveUp" : false,
+        "moveDown" : false,
+        "nodeid" : '',
+        "type" : ButtonType.TOGGLE,
+        "group" : key,
+        "filter" : "",
+        "blink" : false,
+        "vibrate" : false,
+        "profile" : "",
+        "brightness" : undefined,
+        "default" : "0"
+      }
+    
+    if (profile.parameters){
+      let params = Object.keys(profile.parameters)
+      for (let i = 0; i < params.length; i++) {
+        const k = params[i]
+        this.#params[k] = profile.parameters[k]
+      }
+    }
+    // enforce key, so it's not oveerwritten somewhere else
+    this.#params.key = key
+
+    // New approach: Use all data from data.params:
+    if (data.params){
+      this.#params = {
+        ...this.#params,
+        ...data.params
+      }
+
+      // Format the params:
+      this.#params.group = format(this.#params.group, this.getParams({}))
+      this.#params.nodeid = format(this.#params.nodeid, this.getParams({}))
+    }
+
+    if (data.states) {
+      this.#states = data.states
+      this.#keys = Object.keys(this.#states)
+
+      var defaultIndex = this.#keys.indexOf(this.#params.default) 
+      if (defaultIndex >= 0) {
+        this.#index = defaultIndex
+      } else {
+        this.#params.default = this.#keys[0]
+        console.info(`  button ${id} default set to ${this.#params.default}, available states`, this.#keys)
+      }
+      this.#params.state = this.#keys[this.#index]
+    }
+    
+    // Set the default value for the button:
+
+    // Legacy approach: Use data directly:
+    if (data.minPressed) {
+      console.warn("Legacy approach: minPressed is deprecated, use params.minPressed instead")
+      this.#params.minPressed = data.minPressed
+    }
+    if (data.text) {
+      console.warn("Legacy approach: text is deprecated, use params.text instead")
+      this.#params.text = data.text
+    }
+    if (data.nodeid){
+      this.#params.nodeid = format(data.nodeid, this.getParams({}))
+      console.warn("Legacy approach: nodeid is deprecated, use params.nodeid instead",this.#params.nodeid)
+    }
+    if (data.type){
+      console.warn("Legacy approach: type is deprecated, use params.type instead")
+      this.#params.type = data.type
+    }
+
+    if (data.default) {
+      console.warn("Legacy approach: default is deprecated, use params.default instead")
+      this.#index = this.#keys.indexOf(data.default)
+    }
+
+    if (data.group){  
+      console.warn("Legacy approach: group is deprecated, use params.group instead")
+      this.#params.group = format(data.group, this.getParams({}))
+    }
+    // End Legacy approach
+  }
+
+  setState (index = 0) {
+    this.#index = index
+  }
+
+  async drawPhysical (device, id) {
+    const elem = this.getCurrentElement()
+    if (!elem || !elem.color) { return }
+
+    const r = parseInt(elem.color.slice(1, 3), 16)
+    const g = parseInt(elem.color.slice(3, 5), 16)
+    const b = parseInt(elem.color.slice(5, 7), 16)
+
+    try {
+      var idx = parseInt(id, 10);
+
+      const val = {
+        id:idx,
+        color: `rgba(${r}, ${g}, ${b})`
+      }
+//      console.log(' Set Button Color',id, val.id,elem.color, val.color)
+      device.setButtonColor(val)
+    } catch (error) {
+      console.error(' Error', error)
+    }
+  }
+
+  async draw (row, column, ctx) {
+    const x = column * this.#params.width
+    const y = row * this.#params.height
+
+    const elem = this.getCurrentElement()
+    let params = this.getParams(elem)
+    
+    if (elem) {
+      if(elem.blink && this.#counter % 2 == 0) {
+        // If blink is set, we switch the color to inverted color
+        let oldColor = elem.color
+        elem.color = params.textColor
+        elem.textColor = oldColor
+        //console.log("Blinking Button",this.#index,elem.color) 
+      }
+
+      ctx.fillStyle = params.color
+      ctx.fillRect(x, y, params.width, params.height)
+      
+      if (elem.imgBuffer) {
+        ctx.drawImage(elem.imgBuffer, x, y, params.width, params.height)
+      }
+    }
+    if (params.text != undefined && params.text != '') {      
+      ctx.fillStyle = params.textColor
+      ctx.font = params.font
+      ctx.textBaseline = params.textBaseline;
+      ctx.textAlign = params.textAlign;
+      let dynamicText = format(params.text, this.getParams(elem))
+      ctx.fillText(dynamicText,x+6,y+6)  
+    }
+
+    this.#counter = this.#counter + 1
+  }
+
+  async load (globalConfig) {
+    this.#profile = globalConfig
+    for (let i = 0; i < this.#keys.length; i++) {
+      const key = this.#keys[i]
+      const elem = this.#states[key]
+      const file = elem.image
+      if (file !== undefined && file !== '') {
+        try {
+          this.#states[key].imgBuffer = await loadImage(file)
+        } catch (e) {
+          console.error('No such image', file)
+          return false
+        }
+      }
+    }
+  }
+
+  getCurrentElement () {
+    const state = this.#keys[this.#index]
+    return this.#states[state]
+  }
+
+  getLastElement () {
+    let i=this.#index-1 
+    if (i < 0) { i = this.#keys.length - 1 }
+
+    const lastState = this.#keys[i]
+    return this.#states[lastState]
+  }
+
+  pressed () {
+    this.timeStampPressed = Date.now()
+
+    this.#index++
+
+    if (this.#enforcedIndex>=0){
+      console.log("Enforced Index",this.#enforcedIndex )
+      this.#index = this.#enforcedIndex
+    }
+
+    this.updateState(this.#index,"pressed",true)
+    return true
+  }
+
+  released () {
+    let elem = this.getCurrentElement()
+    if (!elem) { return false }
+    this.timeStampReleased = Date.now()
+    this.timeHold = this.timeStampReleased - this.timeStampPressed
+
+    let bExecute = true
+    if (this.timeHold < this.#params.minPressed) {
+      // Update the State according to the not correct pressed state
+      console.log('Did not hold minimum time of ', this.#params.minPressed, 'only', this.timeHold)
+      //if (this.#index < 0) { this.#index = this.#keys.length - 1 }
+      bExecute = false
+    }
+
+    // Update the State according to the correctly pressed state
+    switch (this.#params.type) {
+      case ButtonType.TOGGLE:
+        // do nothing
+        break
+      default:
+        this.#index--
+        //if (this.#index < 0) { this.#index = this.#keys.length - 1 }
+        break
+    }
+
+    if (this.#enforcedIndex>=0){
+      console.log("Enforced Index",this.#enforcedIndex )
+      this.#index = this.#enforcedIndex
+    }
+    
+    
+    this.updateState(this.#index,"released",bExecute)
+    
+    return true // this.runCommand()
+  }
+
+  updateState(index,eventType,bExecute){
+    this.#index = index
+    this.#event = eventType    
+    // Update the State according to the correctly pressed state
+    if (this.#index < 0) { this.#index = this.#keys.length - 1 }
+    this.#index %= this.#keys.length
+    if (bExecute)
+      this.runCommand()
+    //console.log("TODO: expect newState", newState)
+    return true // this.runCommand()
+  }
+
+  async rotated (delta) {
+    if (!this.getCurrentElement()) { return false }
+
+    this.#event = "rotated"
+    this.#params.value = calcDelta(this.#params.value, delta, this.#params.min, this.#params.max)
+    return this.runCommand()
+  }
+
+  async changed(buttonID,nodeid,val){
+    // Only handle updates within the same group identified by nodeid
+    if (nodeid !== this.#params.nodeid){
+        return
+    }
+
+    this.#index = 0;
+    this.#enforcedIndex = -1;
+    for (let i = 0; i < this.#keys.length; i++) {
+      let key = this.#keys[i]
+      // check if the state-name is same as the value we get from outside:
+      if (val == key){
+        this.#index = i;
+        console.info("enforce index", buttonID,nodeid,val,i)
+        this.#enforcedIndex = this.#index;
+        break;
+      }
+
+      // check if the nodeid is the same and the value is one of the states
+      // todo überarbeiten
+        let state = this.#states[key]
+        if (state.value === undefined)
+          continue
+
+        const params = {
+          id: buttonID,
+          key: buttonID,
+          state : key,
+          ...state
+        }
+        if (state && state.value !== undefined){
+          let strVal = state.value.toString()
+          let val1 = format(strVal,params)
+          if (val1 === val?.toString()){
+            this.#index = i;
+            break;
+          }
+        }
+        //break;
+    }
+  }
+
+  async touchmove (x, y) {
+    // if (!this.getCurrentElement()) { return false }
+
+    let delta = 0
+    if (x > this.#params.x) {
+      this.#params.moveRight = true
+      this.#params.moveLeft = false
+    } else if (x < this.#params.x) {
+      this.#params.moveRight = false
+      this.#params.moveLeft = true
+    }
+
+    if (y > this.#params.y) {
+      this.#params.moveDown = true
+      this.#params.moveUp = false
+      delta = -1
+    } else if (y < this.#params.y) {
+      this.#params.moveDown = false
+      this.#params.moveUp = true
+      delta = 1
+    }
+
+    this.#params.x = (x%100) 
+    this.#params.y = (y%100)
+
+    // Calculate delta for value no touchmove up/down
+    this.#params.value = calcDelta(this.#params.value, delta, this.#params.min, this.#params.max)
+
+    // console.log(`d: ${this.#params.moveDown}  r: ${this.#params.moveRight} `)
+    return false
+  }
+
+  getParams(elem){
+    // Call an action - include dynamic parameters
+    // and also all attributes of elem + global config
+    const params = {
+      ...this.#profile.parameters,
+      ...this.#params,
+      ...elem,
+      id: this.id,
+      //key: this.key,
+      event: this.#event,
+      pressed : this.#event == "pressed",
+      released : this.#event == "released",
+      rotated : this.#event == "rotated",
+//      state: this.#keys[this.#index]
+    }
+    return params
+  }
+
+  async runCommand () {
+    const elem = this.getCurrentElement()
+    // Only continue, if we have an element:    
+    if (!elem) {
+      return
+    }
+    // Filter for Event Type:
+    if (elem.filter && elem.filter != this.#event){
+      return
+    }
+
+    if (elem.profile !== undefined) {
+      profileEmitter.emit("profileChanged", elem.profile)
+    }
+
+    if (elem.brightness !== undefined) {
+      profileEmitter.emit("brightnessChanged", elem.brightness)
+    }
+
+    if (elem.vibrate !== undefined) {
+      profileEmitter.emit("vibrate", elem.vibrate)
+    }
+
+    // Only continue, if we have an element, that contains some kind of command:    
+    if (!elem.cmd && !elem.http && !elem.opcua) {
+      return
+    }
+
+    let params = this.getParams(elem)
+    let res = ''
+    if ('cmd' in elem) {
+      if (shellinterface){
+        res = await shellinterface.call(elem.cmd, params)
+      }else{
+        console.warn("shellinterface not started")
+      }
+    }
+    if ('http' in elem) {
+      if (httpinterface){
+        res = await httpinterface.call(elem.http, params)
+      }else{
+        console.warn("httpinterface not started")
+      }
+    }
+    if ('opcua' in elem) {
+      if (opcuainterface){
+        res = await opcuainterface.call(elem.opcua, params)
+
+        /** TODO: CHECK THIS - don't think it's ever used any more */
+        /*if (this.#data.statenodeid){
+          let stateParams = params
+          params.value = params.state
+          res = await opcuainterface.call(this.#data.statenodeid, params)
+        }*/
+      }else{
+        console.warn("opcuainterface not started")
+      }
+    }
+
+    return res
+  }
+}

package/interfaces/httpif.mjs

@@ -25,7 +25,7 @@ export class HTTPif extends BaseIf {
   }
 
   async stop(){
-    this.LogInfo("HTTPif: Stopping\n")
+    this.LogInfo("HTTPif: Stopped\n")
     
   }
 

package/interfaces/interfaces.mjs

@@ -0,0 +1,34 @@
+import * as shellif from '../interfaces/shellif.mjs'
+import * as httpif from '../interfaces/httpif.mjs'
+import * as opcuaif from '../interfaces/opcuaif.mjs'
+import { EventEmitter } from 'node:events'
+
+export var opcuainterface = undefined
+export var httpinterface = undefined
+export var shellinterface = undefined
+export var profileEmitter = undefined
+
+export async function InitializeInterfaces(appConfig){
+  if (opcuainterface === undefined ){
+    opcuainterface = new opcuaif.OPCUAIf()
+  }
+  // the opcua interface needs the profile to register nodes with subscriptions:
+  opcuainterface.init(appConfig.parameters,appConfig)
+  if (httpinterface === undefined) 
+    httpinterface = new httpif.HTTPif()
+  if (shellinterface === undefined)
+    shellinterface = new shellif.SHELLif()
+  if (profileEmitter === undefined)
+    profileEmitter = new EventEmitter()
+}
+
+export async function StopInterfaces(){
+  if (opcuainterface !== undefined )
+    await opcuainterface.stop()
+  if (httpinterface !== undefined) 
+    await httpinterface.stop()
+  if (shellinterface !== undefined)
+    await shellinterface.stop()
+  
+  }
+

package/interfaces/opcuaif.mjs

@@ -79,28 +79,24 @@ export class OPCUAIf extends BaseIf {
             for (let f = 0; f < fieldKeys.length; f++) {
                 let field = fields[f]
                 const keys = Object.keys(field)
+
+                // Iterate over buttons:
                 for (let i = 0; i < keys.length; i++) {
                     const key = keys[i]
                     const elem = field[key]
+                    options["key"] = key        // we have to know the key of the button
                     // groupnode
-                    if (elem.nodeid) {
-                        options["key"] = key
-                        let formattedNodeId = this.formatString(elem.nodeid, options)
+                    if (elem.params && elem.params.nodeid) {
+                        let formattedNodeId = this.formatString(elem.params.nodeid, options)
                         let monitoredItemId = await this.Subscribe(formattedNodeId)
-                        console.log("Subscribe to",formattedNodeId)
-                        this.buttons[monitoredItemId] = i
-                    }
-                    // statenode
-                    if (elem.statenodeid) {
-                        let format = this.formatString(elem.statenodeid, options)
-                        let monitoredItemId = await this.Subscribe(format)
+                        console.log("Subscribe to",monitoredItemId,formattedNodeId)
                         this.buttons[monitoredItemId] = i
                     }
                     await this.monitorStates(elem, options)
                 }
             }
         } catch (error) {
-            this.LogError(`OPCUAIf: Error $error\n`)
+            this.LogError(`OPCUAIf: Error\n`,error)
         }
     }
 
@@ -115,8 +111,9 @@ export class OPCUAIf extends BaseIf {
             const key2 = stateKeys[i]
             const state = elem.states[key2]
             if (state.opcua) {
-                let format = this.formatString(state.opcua, options)
-                let monitoredItemId = await this.Subscribe(format)
+                let formattedNodeId = this.formatString(state.opcua, options)
+                let monitoredItemId = await this.Subscribe(formattedNodeId)
+                console.log("Subscribe to",monitoredItemId,formattedNodeId)
                 this.buttons[monitoredItemId] = i
             }
         }

package/interfaces/shellif.mjs

@@ -16,7 +16,7 @@ export class SHELLif extends BaseIf {
   }
 
   async stop() {
-    this.LogInfo("SHELLif: Stopping")
+    this.LogInfo("SHELLif: Stopped")
   }
 
   Check(options) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "loupedeck-commander",
-  "version": "1.2.11",
+  "version": "1.3.0",
   "description": "A system to ease working with LoupeDeck devices using CMD-line, OPC/UA or HTTP-client interfaces",
   "main": "index.mjs",
   "scripts": {