refactor to use events

src/app/debugger/debuggerUI/VmDebugger.js

@@ -10,9 +10,8 @@ var StepDetail = require('./vmDebugger/StepDetail')
 
 var DebuggerSolidityState = require('../solidityState')
 var SolidityState = require('./vmDebugger/SolidityState')
-
-// var SolidityLocals = require('../remix-debugger/src/ui/SolidityLocals')
 var SolidityLocals = require('./vmDebugger/SolidityLocals')
+
 var FullStoragesChangesPanel = require('../remix-debugger/src/ui/FullStoragesChanges')
 var DropdownPanel = require('./vmDebugger/DropdownPanel')
 var remixDebug = require('remix-debug')

src/app/debugger/debuggerUI/vmDebugger/SolidityLocals.js

@@ -1,4 +1,6 @@
 'use strict'
+var remixLib = require('remix-lib')
+var EventManager = remixLib.EventManager
 var DropdownPanel = require('./DropdownPanel')
 var remixDebug = require('remix-debug')
 var localDecoder = remixDebug.SolidityDecoder.localDecoder
@@ -6,9 +8,19 @@ var solidityTypeFormatter = require('./utils/SolidityTypeFormatter')
 var StorageViewer = remixDebug.storage.StorageViewer
 var yo = require('yo-yo')
 
+// class DebuggerSolidityLocals {
+// 
+//   constructor (_parent, _traceManager, _internalTreeCall) {
+// 
+//   }
+// 
+// }
+
 class SolidityLocals {
 
   constructor (_parent, _traceManager, _internalTreeCall) {
+    const self = this
+    this.event = new EventManager()
     this.parent = _parent
     this.internalTreeCall = _internalTreeCall
     this.storageResolver = null
@@ -19,66 +31,85 @@ class SolidityLocals {
       extractData: solidityTypeFormatter.extractData
     })
     this.init()
+
+    this.event.register('solidityLocals', this, function (state) {
+      self.update(state)
+    })
+    this.event.register('solidityLocalsMessage', this, function (message) {
+      self.setMessage(message)
+    })
+    this.event.register('solidityLocalsUpdating', this, function () {
+      self.setUpdating()
+    })
+
     this.view
   }
 
+  update (data) {
+    this.basicPanel.update(data)
+  }
+
+  setMessage (message) {
+    this.basicPanel.setMessage(message)
+  }
+
+  setUpdating () {
+    this.basicPanel.setUpdating()
+  }
+
   render () {
-    this.view = yo`<div id='soliditylocals' >
+    this.view = yo`<div id='soliditylocals'>${this.basicPanel.render()}</div>`
-    ${this.basicPanel.render()}
-    </div>`
     return this.view
   }
 
   init () {
+    const self = this
     var decodeTimeout = null
     this.parent.event.register('sourceLocationChanged', this, (sourceLocation) => {
       if (!this.storageResolver) {
-        this.basicPanel.setMessage('storage not ready')
+        return self.event.trigger('solidityLocalsMessage', ['storage not ready'])
-        return
       }
       if (decodeTimeout) {
         window.clearTimeout(decodeTimeout)
       }
-      this.basicPanel.setUpdating()
+      self.event.trigger('solidityLocalsUpdating')
-      decodeTimeout = setTimeout(() => {
+      decodeTimeout = setTimeout(function () {
-        decode(this, sourceLocation)
+        self.decode(sourceLocation)
       }, 500)
     })
   }
-}
 
-function decode (self, sourceLocation) {
+  decode (sourceLocation) {
-  self.basicPanel.setMessage('')
+    const self = this
-  self.traceManager.waterfall([
+    self.event.trigger('solidityLocalsMessage', [''])
-    self.traceManager.getStackAt,
+    self.traceManager.waterfall([
-    self.traceManager.getMemoryAt,
+      self.traceManager.getStackAt,
-    self.traceManager.getCurrentCalledAddressAt],
+      self.traceManager.getMemoryAt,
-    self.parent.currentStepIndex,
+      self.traceManager.getCurrentCalledAddressAt],
-    (error, result) => {
+      self.parent.currentStepIndex,
-      if (!error) {
+      (error, result) => {
-        var stack = result[0].value
+        if (!error) {
-        var memory = result[1].value
+          var stack = result[0].value
-        try {
+          var memory = result[1].value
-          var storageViewer = new StorageViewer({
+          try {
-            stepIndex: self.parent.currentStepIndex,
+            var storageViewer = new StorageViewer({ stepIndex: self.parent.currentStepIndex, tx: self.parent.tx, address: result[2].value }, self.storageResolver, self.traceManager)
-            tx: self.parent.tx,
+            localDecoder.solidityLocals(self.parent.currentStepIndex, self.internalTreeCall, stack, memory, storageViewer, sourceLocation).then((locals) => {
-            address: result[2].value
+              if (!locals.error) {
-          }, self.storageResolver, self.traceManager)
+                self.event.trigger('solidityLocals', [locals])
-          localDecoder.solidityLocals(self.parent.currentStepIndex, self.internalTreeCall, stack, memory, storageViewer, sourceLocation).then((locals) => {
+              }
-            if (!locals.error) {
+              if (!Object.keys(locals).length) {
-              self.basicPanel.update(locals)
+                self.event.trigger('solidityLocalsMessage', ['no locals'])
-            }
+              }
-            if (!Object.keys(locals).length) {
+            })
-              self.basicPanel.setMessage('no locals')
+          } catch (e) {
-            }
+            self.event.trigger('solidityLocalsMessage', [e.message])
-          })
+          }
-        } catch (e) {
+        } else {
-          self.basicPanel.setMessage(e.message)
+          console.log(error)
         }
-      } else {
+      })
-        console.log(error)
+  }
-      }
-    })
 }
+
 module.exports = SolidityLocals