diff --git a/libs/image/kis_spacing_information.h b/libs/image/kis_spacing_information.h
index 20c07dd1ee..48dd3baa5a 100644
--- a/libs/image/kis_spacing_information.h
+++ b/libs/image/kis_spacing_information.h
@@ -1,92 +1,94 @@
 #ifndef KIS_SPACING_INFORMATION_H
 #define KIS_SPACING_INFORMATION_H
 
+#include "kritaimage_export.h"
+
 /**
  * Contains information about distance-based spacing settings in a stroke. The spacing settings may
  * be different at different parts of a stroke, e.g. if spacing is linked to pressure; a
  * KisSpacingInformation represents the effective spacing at a single specific part of the stroke.
  */
-class KisSpacingInformation {
+class KRITAIMAGE_EXPORT KisSpacingInformation {
 public:
     explicit KisSpacingInformation()
         : m_distanceSpacingEnabled(true)
         , m_distanceSpacing(0.0, 0.0)
         , m_rotation(0.0)
         , m_coordinateSystemFlipped(false)
     {
     }
 
     explicit KisSpacingInformation(qreal isotropicSpacing)
         : m_distanceSpacingEnabled(true)
         , m_distanceSpacing(isotropicSpacing, isotropicSpacing)
         , m_rotation(0.0)
         , m_coordinateSystemFlipped(false)
     {
     }
 
     explicit KisSpacingInformation(const QPointF &anisotropicSpacing, qreal rotation,
                                    bool coordinateSystemFlipped)
         : m_distanceSpacingEnabled(true)
         , m_distanceSpacing(anisotropicSpacing)
         , m_rotation(rotation)
         , m_coordinateSystemFlipped(coordinateSystemFlipped)
     {
     }
 
     explicit KisSpacingInformation(bool distanceSpacingEnabled, qreal isotropicSpacing)
         : m_distanceSpacingEnabled(distanceSpacingEnabled)
         , m_distanceSpacing(isotropicSpacing, isotropicSpacing)
         , m_rotation(0.0)
         , m_coordinateSystemFlipped(false)
     {
     }
 
     explicit KisSpacingInformation(bool distanceSpacingEnabled,
                                    const QPointF &anisotropicSpacing,
                                    qreal rotation,
                                    bool coordinateSystemFlipped)
         : m_distanceSpacingEnabled(distanceSpacingEnabled)
         , m_distanceSpacing(anisotropicSpacing)
         , m_rotation(rotation)
         , m_coordinateSystemFlipped(coordinateSystemFlipped)
     {
     }
 
     /**
      * @return True if and only if distance-based spacing is enabled.
      */
     inline bool isDistanceSpacingEnabled() const {
         return m_distanceSpacingEnabled;
     }
 
     inline QPointF distanceSpacing() const {
         return m_distanceSpacing;
     }
 
     inline bool isIsotropic() const {
         return m_distanceSpacing.x() == m_distanceSpacing.y();
     }
 
     inline qreal scalarApprox() const {
         return isIsotropic() ? m_distanceSpacing.x() : QVector2D(m_distanceSpacing).length();
     }
 
     inline qreal rotation() const {
         return m_rotation;
     }
 
     bool coordinateSystemFlipped() const {
         return m_coordinateSystemFlipped;
     }
 
 private:
 
     // Distance-based spacing
     bool m_distanceSpacingEnabled;
     QPointF m_distanceSpacing;
 
     qreal m_rotation;
     bool m_coordinateSystemFlipped;
 };
 
 #endif // KIS_SPACING_INFORMATION_H
diff --git a/libs/image/kis_timing_information.h b/libs/image/kis_timing_information.h
index 511c47da7c..d43698f606 100644
--- a/libs/image/kis_timing_information.h
+++ b/libs/image/kis_timing_information.h
@@ -1,61 +1,63 @@
 #ifndef KIS_TIMING_INFORMATION_H
 #define KIS_TIMING_INFORMATION_H
 
+#include "kritaimage_export.h"
+
 /**
  * A time in milliseconds that is assumed to be longer than any stroke (or other paint operation)
  * will ever last. This is used instead of infinity to avoid potential errors. The value is
  * approximately ten years.
  */
 const qreal LONG_TIME = 320000000000.0;
 
 /**
  * Contains information about timing settings in a stroke (mainly for airbrushing effects). The
  * timing settings may be different at different parts of a stroke, e.g. if the airbrush rate is
  * linked to pressure; a KisTimingInformation represents the effective timing at a single specific
  * part of a stroke.
  */
-class KisTimingInformation
+class KRITAIMAGE_EXPORT KisTimingInformation
 {
 public:
 
     /** Makes a KisTimingInformation with timed spacing disabled. */
     explicit KisTimingInformation()
         : m_timedSpacingEnabled(false)
         , m_timedSpacingInterval(LONG_TIME)
     {
     }
 
     /**
      * Makes a KisTimingInformation with timed spacing enabled, using the specified interval in
      * milliseconds.
      */
     explicit KisTimingInformation(qreal interval)
         : m_timedSpacingEnabled(true)
         , m_timedSpacingInterval(interval)
     {
     }
 
     /**
      * @return True if and only if time-based spacing is enabled.
      */
     inline bool isTimedSpacingEnabled() const {
         return m_timedSpacingEnabled;
     }
 
     /**
      * @return The desired maximum amount of time between dabs, in milliseconds. Returns LONG_TIME
      * if time-based spacing is disabled.
      */
     inline qreal timedSpacingInterval() const {
         return isTimedSpacingEnabled() ?
                     m_timedSpacingInterval :
                     LONG_TIME;
     }
 
 private:
     // Time-interval-based spacing
     bool m_timedSpacingEnabled;
     qreal m_timedSpacingInterval;
 };
 
 #endif // KIS_TIMING_INFORMATION_H