From c7211da53f7c7cedb480d0d23547735422e7d4c5 Mon Sep 17 00:00:00 2001
From: Rik Bos <rik.bos@timeseries.nl>
Date: Wed, 24 Jun 2020 11:23:39 -0600
Subject: [PATCH 1/3] Preventing the microflow timer to trigger a new action
 before the previous one is finished

---
 src/MicroflowTimer/widget/MicroflowTimer.js | 571 +++++++++++---------
 1 file changed, 307 insertions(+), 264 deletions(-)

diff --git a/src/MicroflowTimer/widget/MicroflowTimer.js b/src/MicroflowTimer/widget/MicroflowTimer.js
index 187006d..aa0daa6 100644
--- a/src/MicroflowTimer/widget/MicroflowTimer.js
+++ b/src/MicroflowTimer/widget/MicroflowTimer.js
@@ -1,275 +1,318 @@
 define([
-    "dojo/_base/declare",
-    "mxui/widget/_WidgetBase",
-    "dojo/_base/lang",
-    "dojo/_base/array"
-], function(declare, _WidgetBase, lang, dojoArray) {
-    "use strict";
-
-    return declare("MicroflowTimer.widget.MicroflowTimer", [_WidgetBase], {
-
-        // Parameters configured in the Modeler.
-        interval: 30000,
-        once: false,
-        startatonce: true,
-        callEvent: "", // "callMicroflow" | "callNanoflow"
-        microflow: "",
-        nanoflow: null,
-        firstIntervalAttr: null,
-        intervalAttr: null,
-        timerStatusAttr: null,
-
-        // Internal variables. Non-primitives created in the prototype are shared between all widget instances.
-        _handles: null,
-        _contextObj: null,
-        _timer: null,
-        _timeout: null,
-        _timerStarted: false,
-
-        postCreate: function() {
-            this._handles = [];
-
-            if(!(this.microflow && this.callEvent == "callMicroflow" || this.nanoflow.nanoflow && this.callEvent == "callNanoflow")) {
-                mx.ui.error("No action specified for " + this.callEvent)
-            }
-        },
-
-        update: function (obj, callback) {
-            logger.debug(this.id + ".update");
-
-            this._contextObj = obj;
-            this._resetSubscriptions();
-
-            //changes the interval to the attribute value, if set
-            if (this._contextObj && this.intervalAttr) {
-                this.interval = this._contextObj.get(this.intervalAttr);
-            }
-
-            if (!this._timerStarted) {
-                this._runTimer();
-            }
-
-            this._executeCallback(callback, "update");
-        },
-
-        resize: function(box) {},
-
-        uninitialize: function() {
-            this._stopTimer();
-        },
-
-        _checkTimerStatus: function() {
-            logger.debug(this.id + "._checkStatus");
-
-            var running, newInterval;
-
-            //both optional attributes are used
-            if (this.intervalAttr && this.timerStatusAttr) {
-                //get the running state
-                running = this._contextObj.get(this.timerStatusAttr);
-                //change the interval if it was set in the attribute
-                newInterval = this._contextObj.get(this.intervalAttr);
-                if (this.interval !== newInterval) {
-                    this.interval = newInterval;
-                    //stop and start the timer if it's running and will keep running
-                    if (running && this._timerStarted) {
-                        this._intervalChange(newInterval);
-                    }
-                }
-
-                this._timerStatusChange(running);
-
-                //just timer status is used
-            } else if (this.timerStatusAttr) {
-                running = this._contextObj.get(this.timerStatusAttr);
-                this._timerStatusChange(running);
-
-                //just interval is used
-            } else if (this.intervalAttr) {
-                newInterval = this._contextObj.get(this.intervalAttr);
-                if (this.interval !== newInterval) {
-                    this.interval = newInterval;
-                    this._intervalChange(newInterval);
-                }
-            }
-
-        },
-
-        _timerStatusChange: function (running) {
-            if (running !== this._timerStarted) {
-                if (running) {
-                    this._runTimer();
-                } else {
-                    this._stopTimer();
-                }
-            }
-        },
-
-        //Called when the optional timer interval attribute is changed
-        _intervalChange: function (newInterval) {
-            logger.debug(this.id + "._intervalChange");
-
-            this.interval = newInterval;
-
-            if (this._timerStarted) {
-                this._stopTimer();
-                this._runTimer();
-            }
-        },
-
-        _runTimer: function() {
-            logger.debug(this.id + "._runTimer", this.interval);
-            if (this.callEvent !== "" && this._contextObj) {
-                this._timerStarted = true;
-
-                //if there's a first interval, get and use that first, then use the regular interval
-                if (this.firstIntervalAttr) {
-                    var firstInterval = this._contextObj.get(this.firstIntervalAttr);
-
-                    if (this.once) {
-                        this._timeout = setTimeout(lang.hitch(this, this._executeEvent), firstInterval);
-                    } else {
-                        if (this.startatonce) {
-                            this._executeEvent();
-                        }
-                        this._timeout = setTimeout(lang.hitch(this, function() {
-                            this._executeEvent();
-                            this._timer = setInterval(lang.hitch(this, this._executeEvent), this.interval);
-                        }), firstInterval);
-                    }
-                    //otherwise just use the regulat interval
-                } else {
-                    if (this.once) {
-                        this._timeout = setTimeout(lang.hitch(this, this._executeEvent), this.interval);
-                    } else {
-                        if (this.startatonce) {
-                            this._executeEvent();
-                        }
-                        this._timer = setInterval(lang.hitch(this, this._executeEvent), this.interval);
-                    }
-                }
-            }
-        },
-
-        _stopTimer: function() {
-            logger.debug(this.id + "._stopTimer");
-            this._timerStarted = false;
+  "dojo/_base/declare",
+  "mxui/widget/_WidgetBase",
+  "dojo/_base/lang",
+  "dojo/_base/array",
+], function (declare, _WidgetBase, lang, dojoArray) {
+  "use strict";
+
+  return declare("MicroflowTimer.widget.MicroflowTimer", [_WidgetBase], {
+    // Parameters configured in the Modeler.
+    interval: 30000,
+    once: false,
+    startatonce: true,
+    callEvent: "", // "callMicroflow" | "callNanoflow"
+    microflow: "",
+    nanoflow: null,
+    firstIntervalAttr: null,
+    intervalAttr: null,
+    timerStatusAttr: null,
+
+    // Internal variables. Non-primitives created in the prototype are shared between all widget instances.
+    _handles: null,
+    _contextObj: null,
+    _timer: null,
+    _timeout: null,
+    _timerStarted: false,
+
+    _flowRunning: false,
+
+    postCreate: function () {
+      this._handles = [];
+
+      if (
+        !(
+          (this.microflow && this.callEvent == "callMicroflow") ||
+          (this.nanoflow.nanoflow && this.callEvent == "callNanoflow")
+        )
+      ) {
+        mx.ui.error("No action specified for " + this.callEvent);
+      }
+    },
+
+    update: function (obj, callback) {
+      logger.debug(this.id + ".update");
+
+      this._contextObj = obj;
+      this._resetSubscriptions();
+
+      //changes the interval to the attribute value, if set
+      if (this._contextObj && this.intervalAttr) {
+        this.interval = this._contextObj.get(this.intervalAttr);
+      }
+
+      if (!this._timerStarted) {
+        this._runTimer();
+      }
+
+      this._executeCallback(callback, "update");
+    },
+
+    resize: function (box) {},
+
+    uninitialize: function () {
+      this._stopTimer();
+    },
+
+    _checkTimerStatus: function () {
+      logger.debug(this.id + "._checkStatus");
+
+      var running, newInterval;
+
+      //both optional attributes are used
+      if (this.intervalAttr && this.timerStatusAttr) {
+        //get the running state
+        running = this._contextObj.get(this.timerStatusAttr);
+        //change the interval if it was set in the attribute
+        newInterval = this._contextObj.get(this.intervalAttr);
+        if (this.interval !== newInterval) {
+          this.interval = newInterval;
+          //stop and start the timer if it's running and will keep running
+          if (running && this._timerStarted) {
+            this._intervalChange(newInterval);
+          }
+        }
 
-            if (this._timer !== null) {
-                logger.debug(this.id + "._stopTimer timer cleared");
-                clearInterval(this._timer);
-                this._timer = null;
-            }
-            if (this._timeout !== null) {
-                logger.debug(this.id + "._stopTimer timeout cleared");
-                clearTimeout(this._timeout);
-                this._timeout = null;
-            }
-        },
-
-        _executeEvent: function() {
-            if(this.callEvent === "callMicroflow" && this.microflow) {
-                this._execMf()
-            } else if (this.callEvent === "callNanoflow" && this.nanoflow.nanoflow){
-                this._executeNanoFlow()
-            } else {
-                return;
-            }
-        },
+        this._timerStatusChange(running);
 
-        _execMf: function() {
-            logger.debug(this.id + "._execMf");
-            if (!this._contextObj) {
-                return;
-            }
+        //just timer status is used
+      } else if (this.timerStatusAttr) {
+        running = this._contextObj.get(this.timerStatusAttr);
+        this._timerStatusChange(running);
 
-            if (this.microflow) {
-                var mfObject = {
-                    params: {
-                        actionname: this.microflow,
-                        applyto: "selection",
-                        guids: [this._contextObj.getGuid()]
-                    },
-                    callback: lang.hitch(this, function(result) {
-                        if (!result) {
-                            logger.debug(this.id + "._execMf callback, stopping timer");
-                            this._stopTimer();
-                        }
-                    }),
-                    error: lang.hitch(this, function(error) {
-                        logger.error(this.id + ": An error ocurred while executing microflow: ", error);
-                    })
-                };
-
-                if (!mx.version || mx.version && parseInt(mx.version.split(".")[0]) < 6) {
-                    mfObject.store = {
-                        caller: this.mxform
-                    };
-                } else {
-                    mfObject.origin = this.mxform;
-                }
-
-                mx.data.action(mfObject, this);
+        //just interval is used
+      } else if (this.intervalAttr) {
+        newInterval = this._contextObj.get(this.intervalAttr);
+        if (this.interval !== newInterval) {
+          this.interval = newInterval;
+          this._intervalChange(newInterval);
+        }
+      }
+    },
+
+    _timerStatusChange: function (running) {
+      if (running !== this._timerStarted) {
+        if (running) {
+          this._runTimer();
+        } else {
+          this._stopTimer();
+        }
+      }
+    },
+
+    //Called when the optional timer interval attribute is changed
+    _intervalChange: function (newInterval) {
+      logger.debug(this.id + "._intervalChange");
+
+      this.interval = newInterval;
+
+      if (this._timerStarted) {
+        this._stopTimer();
+        this._runTimer();
+      }
+    },
+
+    _runTimer: function () {
+      logger.debug(this.id + "._runTimer", this.interval);
+      if (this.callEvent !== "" && this._contextObj) {
+        this._timerStarted = true;
+
+        //if there's a first interval, get and use that first, then use the regular interval
+        if (this.firstIntervalAttr) {
+          var firstInterval = this._contextObj.get(this.firstIntervalAttr);
+
+          if (this.once) {
+            this._timeout = setTimeout(
+              lang.hitch(this, this._executeEvent),
+              firstInterval
+            );
+          } else {
+            if (this.startatonce) {
+              this._executeEvent();
             }
-        },
-
-        _executeNanoFlow: function() {
-            if (this.nanoflow.nanoflow && this.mxcontext) {
-                mx.data.callNanoflow({
-                    nanoflow: this.nanoflow,
-                    origin: this.mxform,
-                    context: this.mxcontext,
-                    callback: lang.hitch(this, function(result) {
-                        if (!result) {
-                            logger.debug(this.id + "._executeNanoFlow callback, stopping timer");
-                            this._stopTimer();
-                        }
-                    }),
-                    error: lang.hitch(this, function(error) {
-                        logger.error(this.id + ": An error ocurred while executing nanoflow: ", error);
-                    })
-                });
+            this._timeout = setTimeout(
+              lang.hitch(this, function () {
+                this._executeEvent();
+                this._timer = setInterval(
+                  lang.hitch(this, this._executeEvent),
+                  this.interval
+                );
+              }),
+              firstInterval
+            );
+          }
+          //otherwise just use the regulat interval
+        } else {
+          if (this.once) {
+            this._timeout = setTimeout(
+              lang.hitch(this, this._executeEvent),
+              this.interval
+            );
+          } else {
+            if (this.startatonce) {
+              this._executeEvent();
             }
-        },
-
-        // Reset subscriptions.
-        _resetSubscriptions: function() {
-            this.unsubscribeAll();
-
-            // When a mendix object exists create subscribtions.
-            if (this._contextObj && this.timerStatusAttr) {
-                this.subscribe({
-                    guid: this._contextObj.getGuid(),
-                    callback: lang.hitch(this, function(guid) {
-                        this._checkTimerStatus();
-                    })
-                });
-
-                this.subscribe({
-                    guid: this._contextObj.getGuid(),
-                    attr: this.timerStatusAttr,
-                    callback: lang.hitch(this, function(guid, attr, attrValue) {
-                        this._checkTimerStatus();
-                    })
-                });
-
-                this.subscribe({
-                    guid: this._contextObj.getGuid(),
-                    attr: this.intervalAttr,
-                    callback: lang.hitch(this, function(guid, attr, attrValue) {
-                        this._intervalChange();
-                    })
-                });
+            this._timer = setInterval(
+              lang.hitch(this, this._executeEvent),
+              this.interval
+            );
+          }
+        }
+      }
+    },
+
+    _stopTimer: function () {
+      logger.debug(this.id + "._stopTimer");
+      this._timerStarted = false;
+
+      if (this._timer !== null) {
+        logger.debug(this.id + "._stopTimer timer cleared");
+        clearInterval(this._timer);
+        this._timer = null;
+      }
+      if (this._timeout !== null) {
+        logger.debug(this.id + "._stopTimer timeout cleared");
+        clearTimeout(this._timeout);
+        this._timeout = null;
+      }
+    },
+
+    _executeEvent: function () {
+      if (this._flowRunning === true) {
+        return;
+      }
+
+      this._flowRunning = true;
+
+      if (this.callEvent === "callMicroflow" && this.microflow) {
+        this._execMf();
+      } else if (this.callEvent === "callNanoflow" && this.nanoflow.nanoflow) {
+        this._executeNanoFlow();
+      } else {
+        return;
+      }
+    },
+
+    _execMf: function () {
+      logger.debug(this.id + "._execMf");
+      if (!this._contextObj) {
+        return;
+      }
+
+      if (this.microflow) {
+        var mfObject = {
+          params: {
+            actionname: this.microflow,
+            applyto: "selection",
+            guids: [this._contextObj.getGuid()],
+          },
+          callback: lang.hitch(this, function (result) {
+            if (!result) {
+              logger.debug(this.id + "._execMf callback, stopping timer");
+              this._stopTimer();
             }
-        },
+            this._flowRunning = false;
+          }),
+          error: lang.hitch(this, function (error) {
+            logger.error(
+              this.id + ": An error ocurred while executing microflow: ",
+              error
+            );
+            this._flowRunning = false;
+          }),
+        };
+
+        if (
+          !mx.version ||
+          (mx.version && parseInt(mx.version.split(".")[0]) < 6)
+        ) {
+          mfObject.store = {
+            caller: this.mxform,
+          };
+        } else {
+          mfObject.origin = this.mxform;
+        }
 
-        _executeCallback: function (cb, from) {
-            logger.debug(this.id + "._executeCallback" + (from ? " from " + from : ""));
-            if (cb && typeof cb === "function") {
-                cb();
+        mx.data.action(mfObject, this);
+      }
+    },
+
+    _executeNanoFlow: function () {
+      if (this.nanoflow.nanoflow && this.mxcontext) {
+        mx.data.callNanoflow({
+          nanoflow: this.nanoflow,
+          origin: this.mxform,
+          context: this.mxcontext,
+          callback: lang.hitch(this, function (result) {
+            if (!result) {
+              logger.debug(
+                this.id + "._executeNanoFlow callback, stopping timer"
+              );
+              this._stopTimer();
             }
-        }
-    });
+            this._flowRunning = false;
+          }),
+          error: lang.hitch(this, function (error) {
+            logger.error(
+              this.id + ": An error ocurred while executing nanoflow: ",
+              error
+            );
+            this._flowRunning = false;
+          }),
+        });
+      }
+    },
+
+    // Reset subscriptions.
+    _resetSubscriptions: function () {
+      this.unsubscribeAll();
+
+      // When a mendix object exists create subscribtions.
+      if (this._contextObj && this.timerStatusAttr) {
+        this.subscribe({
+          guid: this._contextObj.getGuid(),
+          callback: lang.hitch(this, function (guid) {
+            this._checkTimerStatus();
+          }),
+        });
+
+        this.subscribe({
+          guid: this._contextObj.getGuid(),
+          attr: this.timerStatusAttr,
+          callback: lang.hitch(this, function (guid, attr, attrValue) {
+            this._checkTimerStatus();
+          }),
+        });
+
+        this.subscribe({
+          guid: this._contextObj.getGuid(),
+          attr: this.intervalAttr,
+          callback: lang.hitch(this, function (guid, attr, attrValue) {
+            this._intervalChange();
+          }),
+        });
+      }
+    },
+
+    _executeCallback: function (cb, from) {
+      logger.debug(
+        this.id + "._executeCallback" + (from ? " from " + from : "")
+      );
+      if (cb && typeof cb === "function") {
+        cb();
+      }
+    },
+  });
 });
 
-require(["MicroflowTimer/widget/MicroflowTimer"])
+require(["MicroflowTimer/widget/MicroflowTimer"]);

From 9f10e24de94bcd59e64e5836bc2084900e965d82 Mon Sep 17 00:00:00 2001
From: Rik Bos <rik.bos@timeseries.nl>
Date: Wed, 24 Jun 2020 11:24:17 -0600
Subject: [PATCH 2/3] Added latest mpk

---
 test/widgets/MicroflowTimer.mpk | Bin 3777 -> 3812 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)

diff --git a/test/widgets/MicroflowTimer.mpk b/test/widgets/MicroflowTimer.mpk
index c78f57cd74dd803fd06886e6e97dabe7b503adfd..ce82dab12d07edfa5c75cb5cea00589638540f75 100644
GIT binary patch
literal 3812
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
G?*9N>q{rL<

literal 3777
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


From a0e0ca2e43fa0963c1545c2cff4fed68462ddddd Mon Sep 17 00:00:00 2001
From: Rik Bos <rik.bos@timeseries.nl>
Date: Wed, 24 Jun 2020 11:28:45 -0600
Subject: [PATCH 3/3] Undo prettier changes

---
 src/MicroflowTimer/widget/MicroflowTimer.js | 583 +++++++++-----------
 1 file changed, 276 insertions(+), 307 deletions(-)

diff --git a/src/MicroflowTimer/widget/MicroflowTimer.js b/src/MicroflowTimer/widget/MicroflowTimer.js
index aa0daa6..362dabf 100644
--- a/src/MicroflowTimer/widget/MicroflowTimer.js
+++ b/src/MicroflowTimer/widget/MicroflowTimer.js
@@ -1,318 +1,287 @@
 define([
-  "dojo/_base/declare",
-  "mxui/widget/_WidgetBase",
-  "dojo/_base/lang",
-  "dojo/_base/array",
-], function (declare, _WidgetBase, lang, dojoArray) {
-  "use strict";
-
-  return declare("MicroflowTimer.widget.MicroflowTimer", [_WidgetBase], {
-    // Parameters configured in the Modeler.
-    interval: 30000,
-    once: false,
-    startatonce: true,
-    callEvent: "", // "callMicroflow" | "callNanoflow"
-    microflow: "",
-    nanoflow: null,
-    firstIntervalAttr: null,
-    intervalAttr: null,
-    timerStatusAttr: null,
-
-    // Internal variables. Non-primitives created in the prototype are shared between all widget instances.
-    _handles: null,
-    _contextObj: null,
-    _timer: null,
-    _timeout: null,
-    _timerStarted: false,
-
-    _flowRunning: false,
-
-    postCreate: function () {
-      this._handles = [];
-
-      if (
-        !(
-          (this.microflow && this.callEvent == "callMicroflow") ||
-          (this.nanoflow.nanoflow && this.callEvent == "callNanoflow")
-        )
-      ) {
-        mx.ui.error("No action specified for " + this.callEvent);
-      }
-    },
-
-    update: function (obj, callback) {
-      logger.debug(this.id + ".update");
-
-      this._contextObj = obj;
-      this._resetSubscriptions();
-
-      //changes the interval to the attribute value, if set
-      if (this._contextObj && this.intervalAttr) {
-        this.interval = this._contextObj.get(this.intervalAttr);
-      }
-
-      if (!this._timerStarted) {
-        this._runTimer();
-      }
-
-      this._executeCallback(callback, "update");
-    },
-
-    resize: function (box) {},
-
-    uninitialize: function () {
-      this._stopTimer();
-    },
-
-    _checkTimerStatus: function () {
-      logger.debug(this.id + "._checkStatus");
-
-      var running, newInterval;
-
-      //both optional attributes are used
-      if (this.intervalAttr && this.timerStatusAttr) {
-        //get the running state
-        running = this._contextObj.get(this.timerStatusAttr);
-        //change the interval if it was set in the attribute
-        newInterval = this._contextObj.get(this.intervalAttr);
-        if (this.interval !== newInterval) {
-          this.interval = newInterval;
-          //stop and start the timer if it's running and will keep running
-          if (running && this._timerStarted) {
-            this._intervalChange(newInterval);
-          }
-        }
+    "dojo/_base/declare",
+    "mxui/widget/_WidgetBase",
+    "dojo/_base/lang",
+    "dojo/_base/array"
+], function(declare, _WidgetBase, lang, dojoArray) {
+    "use strict";
+
+    return declare("MicroflowTimer.widget.MicroflowTimer", [_WidgetBase], {
+
+        // Parameters configured in the Modeler.
+        interval: 30000,
+        once: false,
+        startatonce: true,
+        callEvent: "", // "callMicroflow" | "callNanoflow"
+        microflow: "",
+        nanoflow: null,
+        firstIntervalAttr: null,
+        intervalAttr: null,
+        timerStatusAttr: null,
+
+        // Internal variables. Non-primitives created in the prototype are shared between all widget instances.
+        _handles: null,
+        _contextObj: null,
+        _timer: null,
+        _timeout: null,
+        _timerStarted: false,
+
+        _flowRunning: false,
+
+        postCreate: function() {
+            this._handles = [];
+
+            if(!(this.microflow && this.callEvent == "callMicroflow" || this.nanoflow.nanoflow && this.callEvent == "callNanoflow")) {
+                mx.ui.error("No action specified for " + this.callEvent)
+            }
+        },
 
-        this._timerStatusChange(running);
+        update: function (obj, callback) {
+            logger.debug(this.id + ".update");
 
-        //just timer status is used
-      } else if (this.timerStatusAttr) {
-        running = this._contextObj.get(this.timerStatusAttr);
-        this._timerStatusChange(running);
+            this._contextObj = obj;
+            this._resetSubscriptions();
 
-        //just interval is used
-      } else if (this.intervalAttr) {
-        newInterval = this._contextObj.get(this.intervalAttr);
-        if (this.interval !== newInterval) {
-          this.interval = newInterval;
-          this._intervalChange(newInterval);
-        }
-      }
-    },
-
-    _timerStatusChange: function (running) {
-      if (running !== this._timerStarted) {
-        if (running) {
-          this._runTimer();
-        } else {
-          this._stopTimer();
-        }
-      }
-    },
-
-    //Called when the optional timer interval attribute is changed
-    _intervalChange: function (newInterval) {
-      logger.debug(this.id + "._intervalChange");
-
-      this.interval = newInterval;
-
-      if (this._timerStarted) {
-        this._stopTimer();
-        this._runTimer();
-      }
-    },
-
-    _runTimer: function () {
-      logger.debug(this.id + "._runTimer", this.interval);
-      if (this.callEvent !== "" && this._contextObj) {
-        this._timerStarted = true;
-
-        //if there's a first interval, get and use that first, then use the regular interval
-        if (this.firstIntervalAttr) {
-          var firstInterval = this._contextObj.get(this.firstIntervalAttr);
-
-          if (this.once) {
-            this._timeout = setTimeout(
-              lang.hitch(this, this._executeEvent),
-              firstInterval
-            );
-          } else {
-            if (this.startatonce) {
-              this._executeEvent();
+            //changes the interval to the attribute value, if set
+            if (this._contextObj && this.intervalAttr) {
+                this.interval = this._contextObj.get(this.intervalAttr);
             }
-            this._timeout = setTimeout(
-              lang.hitch(this, function () {
-                this._executeEvent();
-                this._timer = setInterval(
-                  lang.hitch(this, this._executeEvent),
-                  this.interval
-                );
-              }),
-              firstInterval
-            );
-          }
-          //otherwise just use the regulat interval
-        } else {
-          if (this.once) {
-            this._timeout = setTimeout(
-              lang.hitch(this, this._executeEvent),
-              this.interval
-            );
-          } else {
-            if (this.startatonce) {
-              this._executeEvent();
+
+            if (!this._timerStarted) {
+                this._runTimer();
             }
-            this._timer = setInterval(
-              lang.hitch(this, this._executeEvent),
-              this.interval
-            );
-          }
-        }
-      }
-    },
-
-    _stopTimer: function () {
-      logger.debug(this.id + "._stopTimer");
-      this._timerStarted = false;
-
-      if (this._timer !== null) {
-        logger.debug(this.id + "._stopTimer timer cleared");
-        clearInterval(this._timer);
-        this._timer = null;
-      }
-      if (this._timeout !== null) {
-        logger.debug(this.id + "._stopTimer timeout cleared");
-        clearTimeout(this._timeout);
-        this._timeout = null;
-      }
-    },
-
-    _executeEvent: function () {
-      if (this._flowRunning === true) {
-        return;
-      }
-
-      this._flowRunning = true;
-
-      if (this.callEvent === "callMicroflow" && this.microflow) {
-        this._execMf();
-      } else if (this.callEvent === "callNanoflow" && this.nanoflow.nanoflow) {
-        this._executeNanoFlow();
-      } else {
-        return;
-      }
-    },
-
-    _execMf: function () {
-      logger.debug(this.id + "._execMf");
-      if (!this._contextObj) {
-        return;
-      }
-
-      if (this.microflow) {
-        var mfObject = {
-          params: {
-            actionname: this.microflow,
-            applyto: "selection",
-            guids: [this._contextObj.getGuid()],
-          },
-          callback: lang.hitch(this, function (result) {
-            if (!result) {
-              logger.debug(this.id + "._execMf callback, stopping timer");
-              this._stopTimer();
+
+            this._executeCallback(callback, "update");
+        },
+
+        resize: function(box) {},
+
+        uninitialize: function() {
+            this._stopTimer();
+        },
+
+        _checkTimerStatus: function() {
+            logger.debug(this.id + "._checkStatus");
+
+            var running, newInterval;
+
+            //both optional attributes are used
+            if (this.intervalAttr && this.timerStatusAttr) {
+                //get the running state
+                running = this._contextObj.get(this.timerStatusAttr);
+                //change the interval if it was set in the attribute
+                newInterval = this._contextObj.get(this.intervalAttr);
+                if (this.interval !== newInterval) {
+                    this.interval = newInterval;
+                    //stop and start the timer if it's running and will keep running
+                    if (running && this._timerStarted) {
+                        this._intervalChange(newInterval);
+                    }
+                }
+
+                this._timerStatusChange(running);
+
+                //just timer status is used
+            } else if (this.timerStatusAttr) {
+                running = this._contextObj.get(this.timerStatusAttr);
+                this._timerStatusChange(running);
+
+                //just interval is used
+            } else if (this.intervalAttr) {
+                newInterval = this._contextObj.get(this.intervalAttr);
+                if (this.interval !== newInterval) {
+                    this.interval = newInterval;
+                    this._intervalChange(newInterval);
+                }
             }
-            this._flowRunning = false;
-          }),
-          error: lang.hitch(this, function (error) {
-            logger.error(
-              this.id + ": An error ocurred while executing microflow: ",
-              error
-            );
-            this._flowRunning = false;
-          }),
-        };
-
-        if (
-          !mx.version ||
-          (mx.version && parseInt(mx.version.split(".")[0]) < 6)
-        ) {
-          mfObject.store = {
-            caller: this.mxform,
-          };
-        } else {
-          mfObject.origin = this.mxform;
-        }
 
-        mx.data.action(mfObject, this);
-      }
-    },
-
-    _executeNanoFlow: function () {
-      if (this.nanoflow.nanoflow && this.mxcontext) {
-        mx.data.callNanoflow({
-          nanoflow: this.nanoflow,
-          origin: this.mxform,
-          context: this.mxcontext,
-          callback: lang.hitch(this, function (result) {
-            if (!result) {
-              logger.debug(
-                this.id + "._executeNanoFlow callback, stopping timer"
-              );
-              this._stopTimer();
+        },
+
+        _timerStatusChange: function (running) {
+            if (running !== this._timerStarted) {
+                if (running) {
+                    this._runTimer();
+                } else {
+                    this._stopTimer();
+                }
+            }
+        },
+
+        //Called when the optional timer interval attribute is changed
+        _intervalChange: function (newInterval) {
+            logger.debug(this.id + "._intervalChange");
+
+            this.interval = newInterval;
+
+            if (this._timerStarted) {
+                this._stopTimer();
+                this._runTimer();
+            }
+        },
+
+        _runTimer: function() {
+            logger.debug(this.id + "._runTimer", this.interval);
+            if (this.callEvent !== "" && this._contextObj) {
+                this._timerStarted = true;
+
+                //if there's a first interval, get and use that first, then use the regular interval
+                if (this.firstIntervalAttr) {
+                    var firstInterval = this._contextObj.get(this.firstIntervalAttr);
+
+                    if (this.once) {
+                        this._timeout = setTimeout(lang.hitch(this, this._executeEvent), firstInterval);
+                    } else {
+                        if (this.startatonce) {
+                            this._executeEvent();
+                        }
+                        this._timeout = setTimeout(lang.hitch(this, function() {
+                            this._executeEvent();
+                            this._timer = setInterval(lang.hitch(this, this._executeEvent), this.interval);
+                        }), firstInterval);
+                    }
+                    //otherwise just use the regulat interval
+                } else {
+                    if (this.once) {
+                        this._timeout = setTimeout(lang.hitch(this, this._executeEvent), this.interval);
+                    } else {
+                        if (this.startatonce) {
+                            this._executeEvent();
+                        }
+                        this._timer = setInterval(lang.hitch(this, this._executeEvent), this.interval);
+                    }
+                }
+            }
+        },
+
+        _stopTimer: function() {
+            logger.debug(this.id + "._stopTimer");
+            this._timerStarted = false;
+
+            if (this._timer !== null) {
+                logger.debug(this.id + "._stopTimer timer cleared");
+                clearInterval(this._timer);
+                this._timer = null;
+            }
+            if (this._timeout !== null) {
+                logger.debug(this.id + "._stopTimer timeout cleared");
+                clearTimeout(this._timeout);
+                this._timeout = null;
+            }
+        },
+
+        _executeEvent: function() {
+            if (this._flowRunning === true) {
+                return;
+              }
+  
+              this._flowRunning = true;
+  
+            if(this.callEvent === "callMicroflow" && this.microflow) {
+                this._execMf()
+            } else if (this.callEvent === "callNanoflow" && this.nanoflow.nanoflow){
+                this._executeNanoFlow()
+            } else {
+                return;
+            }
+        },
+
+        _execMf: function() {
+            logger.debug(this.id + "._execMf");
+            if (!this._contextObj) {
+                return;
             }
-            this._flowRunning = false;
-          }),
-          error: lang.hitch(this, function (error) {
-            logger.error(
-              this.id + ": An error ocurred while executing nanoflow: ",
-              error
-            );
-            this._flowRunning = false;
-          }),
-        });
-      }
-    },
-
-    // Reset subscriptions.
-    _resetSubscriptions: function () {
-      this.unsubscribeAll();
-
-      // When a mendix object exists create subscribtions.
-      if (this._contextObj && this.timerStatusAttr) {
-        this.subscribe({
-          guid: this._contextObj.getGuid(),
-          callback: lang.hitch(this, function (guid) {
-            this._checkTimerStatus();
-          }),
-        });
-
-        this.subscribe({
-          guid: this._contextObj.getGuid(),
-          attr: this.timerStatusAttr,
-          callback: lang.hitch(this, function (guid, attr, attrValue) {
-            this._checkTimerStatus();
-          }),
-        });
-
-        this.subscribe({
-          guid: this._contextObj.getGuid(),
-          attr: this.intervalAttr,
-          callback: lang.hitch(this, function (guid, attr, attrValue) {
-            this._intervalChange();
-          }),
-        });
-      }
-    },
-
-    _executeCallback: function (cb, from) {
-      logger.debug(
-        this.id + "._executeCallback" + (from ? " from " + from : "")
-      );
-      if (cb && typeof cb === "function") {
-        cb();
-      }
-    },
-  });
+
+            if (this.microflow) {
+                var mfObject = {
+                    params: {
+                        actionname: this.microflow,
+                        applyto: "selection",
+                        guids: [this._contextObj.getGuid()]
+                    },
+                    callback: lang.hitch(this, function(result) {
+                        if (!result) {
+                            logger.debug(this.id + "._execMf callback, stopping timer");
+                            this._stopTimer();
+                        }
+                        this._flowRunning = false;
+                    }),
+                    error: lang.hitch(this, function(error) {
+                        logger.error(this.id + ": An error ocurred while executing microflow: ", error);
+                        this._flowRunning = false;
+                    })
+                };
+
+                if (!mx.version || mx.version && parseInt(mx.version.split(".")[0]) < 6) {
+                    mfObject.store = {
+                        caller: this.mxform
+                    };
+                } else {
+                    mfObject.origin = this.mxform;
+                }
+
+                mx.data.action(mfObject, this);
+            }
+        },
+
+        _executeNanoFlow: function() {
+            if (this.nanoflow.nanoflow && this.mxcontext) {
+                mx.data.callNanoflow({
+                    nanoflow: this.nanoflow,
+                    origin: this.mxform,
+                    context: this.mxcontext,
+                    callback: lang.hitch(this, function(result) {
+                        if (!result) {
+                            logger.debug(this.id + "._executeNanoFlow callback, stopping timer");
+                            this._stopTimer();
+                        }
+                        this._flowRunning = false;
+                    }),
+                    error: lang.hitch(this, function(error) {
+                        logger.error(this.id + ": An error ocurred while executing nanoflow: ", error);
+                        this._flowRunning = false;
+                    })
+                });
+            }
+        },
+
+        // Reset subscriptions.
+        _resetSubscriptions: function() {
+            this.unsubscribeAll();
+
+            // When a mendix object exists create subscribtions.
+            if (this._contextObj && this.timerStatusAttr) {
+                this.subscribe({
+                    guid: this._contextObj.getGuid(),
+                    callback: lang.hitch(this, function(guid) {
+                        this._checkTimerStatus();
+                    })
+                });
+
+                this.subscribe({
+                    guid: this._contextObj.getGuid(),
+                    attr: this.timerStatusAttr,
+                    callback: lang.hitch(this, function(guid, attr, attrValue) {
+                        this._checkTimerStatus();
+                    })
+                });
+
+                this.subscribe({
+                    guid: this._contextObj.getGuid(),
+                    attr: this.intervalAttr,
+                    callback: lang.hitch(this, function(guid, attr, attrValue) {
+                        this._intervalChange();
+                    })
+                });
+            }
+        },
+
+        _executeCallback: function (cb, from) {
+            logger.debug(this.id + "._executeCallback" + (from ? " from " + from : ""));
+            if (cb && typeof cb === "function") {
+                cb();
+            }
+        }
+    });
 });
 
-require(["MicroflowTimer/widget/MicroflowTimer"]);
+require(["MicroflowTimer/widget/MicroflowTimer"])