MMDevice: adds functions to XYStage and Stage to let them signal whether they use callbacks

DeviceAdapters/ASIStage/ASIZStage.h

@@ -37,6 +37,8 @@ class ZStage : public CStageBase<ZStage>, public ASIBase
 
 	bool IsContinuousFocusDrive() const { return false; }
 
+	int UsesOnStagePositionChanged(bool& result) const { result = true; return DEVICE_OK; }
+
 	// action interface
 	int OnPort(MM::PropertyBase* pProp, MM::ActionType eAct);
 	int OnAxis(MM::PropertyBase* pProp, MM::ActionType eAct);

DeviceAdapters/CNCMicroscope/RAMPSStage/XYStage.h

@@ -66,6 +66,7 @@ class RAMPSXYStage : public CXYStageBase<RAMPSXYStage>
 
   int IsXYStageSequenceable(bool& isSequenceable) const;
 
+  int UsesOnXYStagePositionChanged(bool& result) const { result = true; return DEVICE_OK; }
 
   // action interface
   // ----------------

DeviceAdapters/CNCMicroscope/RAMPSStage/ZStage.h

@@ -66,6 +66,8 @@ class RAMPSZStage : public CStageBase<RAMPSZStage>
 
   bool IsContinuousFocusDrive() const;
 
+  int UsesOnStagePositionChanged(bool& result) const { result = true; return DEVICE_OK; }
+
   // action interface
   // ----------------
   int OnPosition(MM::PropertyBase* pProp, MM::ActionType eAct);

DeviceAdapters/Cephla/Squid.h

@@ -284,6 +284,7 @@ class SquidXYStage : public CXYStageBase<SquidXYStage>
 
    int IsXYStageSequenceable(bool& isSequenceable) const { isSequenceable = false; return DEVICE_OK; }
 
+   int UsesOnXYStagePositionChanged(bool& result) const { result = true; return DEVICE_OK; }
 
    // action interface
    // ----------------
@@ -354,6 +355,8 @@ class SquidZStage : public CStageBase<SquidZStage>
    }
    bool IsContinuousFocusDrive() const { return false; };
 
+   int UsesOnStagePositionChanged(bool& result) const { result = true; return DEVICE_OK; }
+
    int OnAcceleration(MM::PropertyBase* pProp, MM::ActionType eAct);
    int OnMaxVelocity(MM::PropertyBase* pProp, MM::ActionType eAct);
 

DeviceAdapters/ChuoSeiki_MD5000/ChuoSeiki_MD_XYZ.h

@@ -119,6 +119,7 @@ class MD_SingleStage:
 // Checking device functions
 	int IsStageSequenceable(bool& isSequenceable) const {isSequenceable = false; return DEVICE_OK;}
 	bool IsContinuousFocusDrive() const {return DEVICE_OK;}
+	int UsesOnStagePositionChanged(bool& result) const { result = true; return DEVICE_OK; }
 	bool SupportsDeviceDetection(void);
 	MM::DeviceDetectionStatus DetectDevice(void);
 
@@ -227,6 +228,7 @@ public CXYStageBase<MD_TwoStages>
 	double GetStepSizeYUm() { return stepSize_umY_; }
 
 	int IsXYStageSequenceable(bool& isSequenceable) const	{isSequenceable = false; return DEVICE_OK;	}
+	int UsesOnXYStagePositionChanged(bool& result) const { result = true; return DEVICE_OK; }
 	MM::DeviceDetectionStatus DetectDevice(void);
 protected:
 	// check controller

DeviceAdapters/ChuoSeiki_QT/ChuoSeiki_QT_XYZ.h

@@ -251,6 +251,7 @@ class ChuoSeikiZStage : public CStageBase<ChuoSeikiZStage>
 	bool IsContinuousFocusDrive() const {return DEVICE_OK;}
 	bool SupportsDeviceDetection(void){return DEVICE_OK;}
 	MM::DeviceDetectionStatus DetectDevice(void);
+	int UsesOnStagePositionChanged(bool& result) const { result = true; return DEVICE_OK; }
 
 private:
 

DeviceAdapters/DemoCamera/DemoCamera.h

@@ -498,6 +498,8 @@ class CDemoStage : public CStageBase<CDemoStage>
 
    bool IsContinuousFocusDrive() const {return false;}
 
+   int UsesOnStagePositionChanged(bool& result) const { result = true; return DEVICE_OK; }
+
    // action interface
    // ----------------
    int OnPosition(MM::PropertyBase* pProp, MM::ActionType eAct);
@@ -578,6 +580,7 @@ class CDemoXYStage : public CXYStageBase<CDemoXYStage>
 
    int IsXYStageSequenceable(bool& isSequenceable) const {isSequenceable = false; return DEVICE_OK;}
 
+   int UsesOnXYStagePositionChanged(bool& result) const { result = true; return DEVICE_OK; }
 
    // action interface
    // ----------------

DeviceAdapters/ESP32/esp32.h

@@ -325,6 +325,8 @@ class CESP32Stage : public CStageBase<CESP32Stage>
         nrEvents = 0; return DEVICE_OK;
     }
 
+    int UsesOnStagePositionChanged(bool& result) const { result = true; return DEVICE_OK; }
+
 private:
     double stepSizeUm_;
     double pos_um_;
@@ -389,6 +391,8 @@ class CESP32XYStage : public CXYStageBase<CESP32XYStage>
 
     int IsXYStageSequenceable(bool& isSequenceable) const { isSequenceable = false; return DEVICE_OK; }
 
+    int UsesOnXYStagePositionChanged(bool& result) const { result = true; return DEVICE_OK; }
+
     int OnXStageMinPos(MM::PropertyBase* pProp, MM::ActionType eAct);
     int OnXStageMaxPos(MM::PropertyBase* pProp, MM::ActionType eAct);
     int OnYStageMinPos(MM::PropertyBase* pProp, MM::ActionType eAct);

DeviceAdapters/MCL_NanoDrive/MCL_NanoDrive_XYStage.h

@@ -46,6 +46,8 @@ class MCL_NanoDrive_XYStage : public CXYStageBase<MCL_NanoDrive_XYStage>
 	virtual double GetStepSizeYUm();
 	virtual int IsXYStageSequenceable(bool& isSequenceable) const;
 
+	int UsesOnXYStagePositionChanged(bool& result) const { result = true; return DEVICE_OK; }
+
 	// Action interface
 	int OnLowerLimitX(MM::PropertyBase* pProp, MM::ActionType eAct);
 	int OnUpperLimitX(MM::PropertyBase* pProp, MM::ActionType eAct);

DeviceAdapters/MCL_NanoDrive/MCL_NanoDrive_ZStage.h

@@ -51,6 +51,8 @@ class MCL_NanoDrive_ZStage : public CStageBase<MCL_NanoDrive_ZStage>
 	virtual int SendStageSequence();
 	virtual bool IsContinuousFocusDrive() const;
 
+	int UsesOnStagePositionChanged(bool& result) const { result = true; return DEVICE_OK; }
+
 	// Action interface
 	int OnLowerLimit(MM::PropertyBase* pProp, MM::ActionType eAct);
 	int OnUpperLimit(MM::PropertyBase* pProp, MM::ActionType eAct);

DeviceAdapters/MoticMicroscope/MoticMicroscope.h

@@ -128,6 +128,8 @@ class XYStage : public CXYStageBase<XYStage>, public EventReceiver
 
 	virtual int IsXYStageSequenceable(bool& isSequenceable) const;
 
+	int UsesOnXYStagePositionChanged(bool& result) const { result = true; return DEVICE_OK; }
+
 	void EventHandler(int eventId, int data);
 private:
 	int _init;
@@ -166,6 +168,8 @@ class ZStage : public CStageBase<ZStage>, public EventReceiver
 
 	virtual bool IsContinuousFocusDrive() const;
 
+	int UsesOnStagePositionChanged(bool& result) const { result = true; return DEVICE_OK; }
+
 	void EventHandler(int eventId, int data);
 private:
 	int _init;

DeviceAdapters/NewportCONEX/Conex_Axis.h

@@ -118,6 +118,8 @@ class Axis : public CStageBase<Axis>, public Conex_AxisBase
 
    bool IsContinuousFocusDrive() const {return false;}
 
+   int UsesOnStagePositionChanged(bool& result) const { result = true; return DEVICE_OK; }
+
    // action interface
    // ----------------
    int OnPort     (MM::PropertyBase* pProp, MM::ActionType eAct);

DeviceAdapters/NotificationTester/NotificationTester.cpp

@@ -395,6 +395,11 @@ class NTestStage : public CStageBase<NTestStage<ProcModel>>
    bool IsContinuousFocusDrive() const final {
       return false;
    }
+
+   int UsesOnStagePositionChanged(bool& result) const final {
+      result = true;
+      return DEVICE_OK;
+   }
 };
 
 template <typename ProcModel>
@@ -610,6 +615,11 @@ class NTestXYStage : public CXYStageBase<NTestXYStage<ProcModel>>
       flag = false;
       return DEVICE_OK;
    }
+
+   int UsesOnXYStagePositionChanged(bool& result) const final {
+      result = true;
+      return DEVICE_OK;
+   }
 };
 
 MODULE_API void InitializeModuleData()

DeviceAdapters/OpenFlexure/OpenFlexure.h

@@ -123,6 +123,8 @@ class XYStage : public  CXYStageBase<XYStage>
 	int GetLimitsUm(double& xMin, double& xMax, double& yMin, double& yMax);
 	int IsXYStageSequenceable(bool& isSequenceable) const { isSequenceable = false; return DEVICE_OK; }
 
+	int UsesOnXYStagePositionChanged(bool& result) const { result = true; return DEVICE_OK; }
+
 	bool Busy() { return false; }
 	void GetName(char*) const;
 
@@ -165,6 +167,9 @@ class ZStage : public CStageBase<ZStage>
 	int GetLimits(double& lower, double& upper) { return DEVICE_UNSUPPORTED_COMMAND;} // nah 
 	int IsStageSequenceable(bool& isSequenceable) const { isSequenceable = false;  return DEVICE_OK;}
 	bool IsContinuousFocusDrive() const  { return false; }
+
+	int UsesOnStagePositionChanged(bool& result) const { result = true; return DEVICE_OK; }
+
 	bool Busy() { return false; }
 
 	// Helper functions

DeviceAdapters/PIEZOCONCEPT/PIEZOCONCEPT.h

@@ -119,6 +119,8 @@ class CPiezoConceptStage : public CStageBase<CPiezoConceptStage>
    int GetStageSequenceMaxLength(long& nrEvents) const
    { nrEvents = 0; return DEVICE_OK; }
 
+   int UsesOnStagePositionChanged(bool& result) const { result = true; return DEVICE_OK; }
+
 private:
    double stepSizeUm_;
    double pos_um_;
@@ -182,6 +184,8 @@ class CPiezoConceptXYStage : public CXYStageBase<CPiezoConceptXYStage>
 
    int IsXYStageSequenceable(bool& isSequenceable) const { isSequenceable = false; return DEVICE_OK; }
 
+   int UsesOnXYStagePositionChanged(bool& result) const { result = true; return DEVICE_OK; }
+
    int OnXStageMinPos(MM::PropertyBase* pProp, MM::ActionType eAct);
    int OnXStageMaxPos(MM::PropertyBase* pProp, MM::ActionType eAct);
    int OnYStageMinPos(MM::PropertyBase* pProp, MM::ActionType eAct);

DeviceAdapters/PriorPureFocus/PureFocus.h

@@ -170,6 +170,9 @@ class PureFocusOffset : public CStageBase<PureFocusOffset> {
    bool IsContinuousFocusDrive() const {
       return false;
    };
+
+   int UsesOnStagePositionChanged(bool& result) const { result = true; return DEVICE_OK; }
+
    void CallbackPositionSteps(long steps);
    void RemoveHub() { pHub_ = 0; };
 

DeviceAdapters/PyDevice/PyStage.h

@@ -32,6 +32,10 @@ class CPyStage : public PyStageClass {
     bool IsContinuousFocusDrive() const override {
         return true;
     }
+    int UsesOnStagePositionChanged(bool& result) const override {
+        result = true;
+        return DEVICE_OK;
+    }
 protected:
     double StepSizeUm() const;
     double origin_ = 0.0;
@@ -118,6 +122,11 @@ class CPyXYStage : public PyXYStageClass {
         return DEVICE_UNSUPPORTED_COMMAND;
     }
 
+    int UsesOnXYStagePositionChanged(bool& result) const override {
+        result = true;
+        return DEVICE_OK;
+    }
+
 protected:
     double origin_x_ = 0.0;
     double origin_y_ = 0.0;

DeviceAdapters/SouthPort/microz.h

@@ -53,6 +53,8 @@ class MicroZStage : public CStageBase<MicroZStage>
 
 	bool IsContinuousFocusDrive() const;
 
+	int UsesOnStagePositionChanged(bool& result) const { result = true; return DEVICE_OK; }
+
 	// Sequence functions
 	int IsStageSequenceable(bool& isSequenceable) const;
 	int GetStageSequenceMaxLength(long& nrEvents) const;

DeviceAdapters/Standa/Standa.h

@@ -62,6 +62,8 @@ class StandaZStage : public CStageBase<StandaZStage>
    int IsStageSequenceable(bool& isSequenceable) const {isSequenceable = false; return DEVICE_OK;}
    bool IsContinuousFocusDrive() const {return false;}
 
+   int UsesOnStagePositionChanged(bool& result) const { result = true; return DEVICE_OK; }
+
    // action interface
    // ----------------
    int OnAxisLimit(MM::PropertyBase* pProp, MM::ActionType eAct);

DeviceAdapters/Standa8SMC4/Standa8SMC4.h

@@ -58,6 +58,8 @@ class Standa8SMC4Z : public CStageBase<Standa8SMC4Z>
 
    virtual bool IsContinuousFocusDrive() const;
 
+   int UsesOnStagePositionChanged(bool& result) const { result = true; return DEVICE_OK; }
+
    // action interface
    // ----------------
    int OnPort(MM::PropertyBase* pProp, MM::ActionType eAct);
@@ -110,6 +112,8 @@ class Standa8SMC4XY : public CXYStageBase<Standa8SMC4XY>
 
    virtual bool IsContinuousFocusDrive() const;
 
+   int UsesOnXYStagePositionChanged(bool& result) const { result = true; return DEVICE_OK; }
+
    // action interface
    // ----------------
    int OnPortX(MM::PropertyBase* pProp, MM::ActionType eAct);

DeviceAdapters/StandaStage/StandaStage.h

@@ -116,6 +116,8 @@ class CStandaStage : public CStageBase<CStandaStage>
 
    bool IsContinuousFocusDrive() const {return false;}
 
+   int UsesOnStagePositionChanged(bool& result) const { result = true; return DEVICE_OK; }
+
    // action interface
    // ----------------
 
@@ -266,6 +268,7 @@ class CStandaXYStage : public CXYStageBase<CStandaXYStage>
 
    int IsXYStageSequenceable(bool& isSequenceable) const {isSequenceable = false; return DEVICE_OK;}
 
+   int UsesOnXYStagePositionChanged(bool& result) const { result = true; return DEVICE_OK; }
 
    // action interface
    // ----------------

DeviceAdapters/ThorlabsAPTStage/ThorlabsAPTStage.h

@@ -80,6 +80,8 @@ class ThorlabsAPTStage : public CStageBase<ThorlabsAPTStage>
     int IsStageSequenceable(bool& isSequenceable) const {isSequenceable = false; return DEVICE_OK;}
     bool IsContinuousFocusDrive() const {return false;}
 
+    int UsesOnStagePositionChanged(bool& result) const { result = true; return DEVICE_OK; }
+
     // action interface
     // ----------------
     int OnSerialNumber(MM::PropertyBase* pProp, MM::ActionType eAct);

DeviceAdapters/TriggerScope/TriggerScope.h

@@ -348,6 +348,8 @@ class CTriggerScopeFocus : public CStageBase<CTriggerScopeFocus>
 
    bool IsContinuousFocusDrive() const {return false;}
 
+   int UsesOnStagePositionChanged(bool& result) const { result = true; return DEVICE_OK; }
+
    int OnSequence(MM::PropertyBase* pProp, MM::ActionType eAct);
    int OnDACNumber(MM::PropertyBase* pProp, MM::ActionType eAct);
    int OnUpperLimit(MM::PropertyBase* pProp, MM::ActionType eAct);

DeviceAdapters/WOSM/WOSM.h

@@ -330,6 +330,8 @@ class CWOSMStage : public CStageBase<CWOSMStage>
         nrEvents = 0; return DEVICE_OK;
     }
 
+    int UsesOnStagePositionChanged(bool& result) const { result = true; return DEVICE_OK; }
+
 private:
     double stepSizeUm_;
     double pos_um_;
@@ -394,6 +396,8 @@ class CWOSMXYStage : public CXYStageBase<CWOSMXYStage>
 
     int IsXYStageSequenceable(bool& isSequenceable) const { isSequenceable = false; return DEVICE_OK; }
 
+    int UsesOnXYStagePositionChanged(bool& result) const { result = true; return DEVICE_OK; }
+
     int OnXStageMinPos(MM::PropertyBase* pProp, MM::ActionType eAct);
     int OnXStageMaxPos(MM::PropertyBase* pProp, MM::ActionType eAct);
     int OnYStageMinPos(MM::PropertyBase* pProp, MM::ActionType eAct);

DeviceAdapters/WieneckeSinske/ZPiezoCanDevice.h

@@ -77,7 +77,8 @@ class ZPiezoCANDevice : public CStageBase<ZPiezoCANDevice>
 	int SetOrigin();
 	int IsStageSequenceable(bool& isSequenceable) const {isSequenceable = false; return DEVICE_OK;}
 
-
+	int UsesOnStagePositionChanged(bool& result) const { result = true; return DEVICE_OK; }
+
 	// action interface                                                       
 	// ----------------                                                       
 	int OnPort(MM::PropertyBase* pProp, MM::ActionType eAct); 

DeviceAdapters/WieneckeSinske/ZPiezoWSDevice.h

@@ -77,7 +77,8 @@ class ZPiezoWSDevice : public CStageBase<ZPiezoWSDevice>
 	int SetOrigin();
 	int IsStageSequenceable(bool& isSequenceable) const {isSequenceable = false; return DEVICE_OK;}
 
-
+	int UsesOnStagePositionChanged(bool& result) const { result = true; return DEVICE_OK; }
+
 	// action interface                                                       
 	// ----------------                                                       
 	int OnPort(MM::PropertyBase* pProp, MM::ActionType eAct); 

DeviceAdapters/ZeissCAN29/ZeissCAN29.h

@@ -836,6 +836,8 @@ class Axis : public CStageBase<Axis>, public ZeissAxis
    int IsStageSequenceable(bool& isSequenceable) const {isSequenceable = false; return DEVICE_OK;}
    bool IsContinuousFocusDrive() const {return false;}
 
+   int UsesOnStagePositionChanged(bool& result) const { result = true; return DEVICE_OK; }
+
    // action interface
    // ----------------
    int OnPosition(MM::PropertyBase* pProp, MM::ActionType eAct);
@@ -890,6 +892,8 @@ class XYStage : public CXYStageBase<XYStage>, public ZeissAxis
   double GetStepSizeYUm() {return stepSize_um_;}
   int IsXYStageSequenceable(bool& isSequenceable) const {isSequenceable = false; return DEVICE_OK;}
 
+   int UsesOnXYStagePositionChanged(bool& result) const { result = true; return DEVICE_OK; }
+
    // action interface
    // ----------------
    int OnMoveMode(MM::PropertyBase* pProp, MM::ActionType eAct);

MMCore/Devices/StageInstance.cpp

@@ -60,6 +60,7 @@ StageInstance::SetFocusDirection(MM::FocusDirection direction)
    focusDirectionHasBeenSet_ = true;
 }
 
+int StageInstance::UsesOnStagePositionChanged(bool& result) const { RequireInitialized(__func__); return GetImpl()->UsesOnStagePositionChanged(result); }
 int StageInstance::IsStageSequenceable(bool& isSequenceable) const { RequireInitialized(__func__); return GetImpl()->IsStageSequenceable(isSequenceable); }
 int StageInstance::IsStageLinearSequenceable(bool& isSequenceable) const { RequireInitialized(__func__); return GetImpl()->IsStageLinearSequenceable(isSequenceable); }
 bool StageInstance::IsContinuousFocusDrive() const { RequireInitialized(__func__); return GetImpl()->IsContinuousFocusDrive(); }

MMCore/Devices/StageInstance.h

@@ -57,6 +57,7 @@ class StageInstance : public DeviceInstanceBase<MM::Stage>
    int GetLimits(double& lower, double& upper);
    MM::FocusDirection GetFocusDirection();
    void SetFocusDirection(MM::FocusDirection direction);
+   int UsesOnStagePositionChanged(bool& result) const;
    int IsStageSequenceable(bool& isSequenceable) const;
    int IsStageLinearSequenceable(bool& isSequenceable) const;
    bool IsContinuousFocusDrive() const;

MMCore/Devices/XYStageInstance.cpp

@@ -42,6 +42,7 @@ int XYStageInstance::SetYOrigin() { RequireInitialized(__func__); return GetImpl
 int XYStageInstance::GetStepLimits(long& xMin, long& xMax, long& yMin, long& yMax) { RequireInitialized(__func__); return GetImpl()->GetStepLimits(xMin, xMax, yMin, yMax); }
 double XYStageInstance::GetStepSizeXUm() { RequireInitialized(__func__); return GetImpl()->GetStepSizeXUm(); }
 double XYStageInstance::GetStepSizeYUm() { RequireInitialized(__func__); return GetImpl()->GetStepSizeYUm(); }
+int XYStageInstance::UsesOnXYStagePositionChanged(bool& result) const { RequireInitialized(__func__); return GetImpl()->UsesOnXYStagePositionChanged(result); }
 int XYStageInstance::IsXYStageSequenceable(bool& isSequenceable) const { RequireInitialized(__func__); return GetImpl()->IsXYStageSequenceable(isSequenceable); }
 int XYStageInstance::GetXYStageSequenceMaxLength(long& nrEvents) const { RequireInitialized(__func__); return GetImpl()->GetXYStageSequenceMaxLength(nrEvents); }
 int XYStageInstance::StartXYStageSequence() { RequireInitialized(__func__); return GetImpl()->StartXYStageSequence(); }

MMCore/Devices/XYStageInstance.h

@@ -56,6 +56,7 @@ class XYStageInstance : public DeviceInstanceBase<MM::XYStage>
    int GetStepLimits(long& xMin, long& xMax, long& yMin, long& yMax);
    double GetStepSizeXUm();
    double GetStepSizeYUm();
+   int UsesOnXYStagePositionChanged(bool& result) const;
    int IsXYStageSequenceable(bool& isSequenceable) const;
    int GetXYStageSequenceMaxLength(long& nrEvents) const;
    int StartXYStageSequence();