From ddabad247f461849a7b69a8124d60337d8120d26 Mon Sep 17 00:00:00 2001
From: Nyall Dawson <nyall.dawson@gmail.com>
Date: Wed, 3 Feb 2016 23:37:43 +1100
Subject: [PATCH] Move unit handling helpers out of QGis and
 QgsSymbolLayerUtils into a new QgsUnitTypes helper class. Add unit tests.

TODO QGIS 3.0: Move QGis::UnitType and QgsSymbolV2::OutputUnit
to QgsUnitTypes
---
 python/core/core.sip                          |   1 +
 python/core/qgis.sip                          |  20 +-
 python/core/qgsunittypes.sip                  |  80 ++++++
 .../symbology-ng/qgssymbollayerv2utils.sip    |   6 +-
 src/app/qgsdecorationitem.cpp                 |   5 +-
 src/app/qgsdecorationscalebar.cpp             |   9 +-
 src/app/qgsmaptoolidentifyaction.cpp          |   5 +-
 src/app/qgsmeasuredialog.cpp                  |  31 +--
 src/app/qgsoptions.cpp                        |  15 +-
 src/core/CMakeLists.txt                       |   2 +
 src/core/composer/qgscomposerscalebar.cpp     |   7 +-
 src/core/dxf/qgsdxfexport.cpp                 |   7 +-
 src/core/effects/qgsgloweffect.cpp            |   5 +-
 src/core/effects/qgsshadoweffect.cpp          |   5 +-
 src/core/effects/qgstransformeffect.cpp       |   5 +-
 src/core/qgis.cpp                             |  76 +-----
 src/core/qgis.h                               |  20 +-
 src/core/qgsdistancearea.cpp                  |   7 +-
 src/core/qgspallabeling.cpp                   |   7 +-
 src/core/qgsunittypes.cpp                     | 245 ++++++++++++++++++
 src/core/qgsunittypes.h                       | 106 ++++++++
 .../symbology-ng/qgsellipsesymbollayerv2.cpp  |  23 +-
 .../symbology-ng/qgsfillsymbollayerv2.cpp     |  83 +++---
 .../symbology-ng/qgslinesymbollayerv2.cpp     |  29 ++-
 .../symbology-ng/qgsmarkersymbollayerv2.cpp   |  37 +--
 .../qgspointdisplacementrenderer.cpp          |   5 +-
 .../symbology-ng/qgssymbollayerv2utils.cpp    |  39 +--
 src/core/symbology-ng/qgssymbollayerv2utils.h |   6 +-
 src/core/symbology-ng/qgssymbolv2.h           |   1 +
 .../qgsvectorfieldsymbollayer.cpp             |  13 +-
 src/providers/wms/qgswmscapabilities.cpp      |   5 +-
 tests/src/python/CMakeLists.txt               |   1 +
 tests/src/python/test_qgsunittypes.py         | 141 ++++++++++
 33 files changed, 795 insertions(+), 252 deletions(-)
 create mode 100644 python/core/qgsunittypes.sip
 create mode 100644 src/core/qgsunittypes.cpp
 create mode 100644 src/core/qgsunittypes.h
 create mode 100644 tests/src/python/test_qgsunittypes.py

diff --git a/python/core/core.sip b/python/core/core.sip
index b57a20ae64c5..452c8a76deb7 100644
--- a/python/core/core.sip
+++ b/python/core/core.sip
@@ -125,6 +125,7 @@
 %Include qgsstringutils.sip
 %Include qgstolerance.sip
 %Include qgstracer.sip
+%Include qgsunittypes.sip
 %Include qgsvectordataprovider.sip
 %Include qgsvectorfilewriter.sip
 %Include qgsvectorlayer.sip
diff --git a/python/core/qgis.sip b/python/core/qgis.sip
index c21b7de86023..179f01080287 100644
--- a/python/core/qgis.sip
+++ b/python/core/qgis.sip
@@ -129,16 +129,24 @@ class QGis
       NauticalMiles
     };
 
-    //! Provides the canonical name of the type value
-    static QString toLiteral( QGis::UnitType unit );
+    //! @deprecated use QgsUnitTypes::encodeUnit() instead
+    static QString toLiteral( QGis::UnitType unit ) /Deprecated/;
+
     //! Converts from the canonical name to the type value
-    static UnitType fromLiteral( const QString& literal, QGis::UnitType defaultType = UnknownUnit );
+    //! @deprecated use QgsUnitTypes::decodeDistanceUnit() instead
+    static UnitType fromLiteral( const QString& literal, QGis::UnitType defaultType = UnknownUnit ) /Deprecated/;
+
     //! Provides translated version of the type value
-    static QString tr( QGis::UnitType unit );
+    //! @deprecated use QgsUnitTypes::toString() instead
+    static QString tr( QGis::UnitType unit ) /Deprecated/;
+
     //! Provides type value from translated version
-    static UnitType fromTr( const QString& literal, QGis::UnitType defaultType = UnknownUnit );
+    //! @deprecated use QgsUnitTypes::stringToDistanceUnit() instead
+    static UnitType fromTr( const QString& literal, QGis::UnitType defaultType = UnknownUnit ) /Deprecated/;
+
     //! Returns the conversion factor between the specified units
-    static double fromUnitToUnitFactor( QGis::UnitType fromUnit, QGis::UnitType toUnit );
+    //! @deprecated use QgsUnitTyoes::fromUnitToUnitFactor() instead
+    static double fromUnitToUnitFactor( QGis::UnitType fromUnit, QGis::UnitType toUnit ) /Deprecated/;
 
     /** Converts a string to a double in a permissive way, eg allowing for incorrect
      * numbers of digits between thousand separators
diff --git a/python/core/qgsunittypes.sip b/python/core/qgsunittypes.sip
new file mode 100644
index 000000000000..5fddf3789474
--- /dev/null
+++ b/python/core/qgsunittypes.sip
@@ -0,0 +1,80 @@
+/** \ingroup core
+ * \class QgsUnitTypes
+ * \brief Helper functions for various unit types.
+ * \note Added in version 2.14
+ */
+
+class QgsUnitTypes
+{
+%TypeHeaderCode
+#include <qgsunittypes.h>
+%End
+
+  public:
+
+    /** Types of distance units
+     */
+    enum DistanceUnitType
+    {
+      Standard, /*!< unit is a standard measurement unit */
+      Geographic, /*!< unit is a geographic (eg degree based) unit */
+      UnknownType, /*!< unknown unit type */
+    };
+
+    /** Returns the type for a distance unit.
+    */
+    static DistanceUnitType unitType( QGis::UnitType unit );
+
+    /** Encodes a distance unit to a string.
+     * @param unit unit to encode
+     * @returns encoded string
+     * @see decodeDistanceUnit()
+    */
+    static QString encodeUnit( QGis::UnitType unit );
+
+    /** Decodes a distance unit from a string.
+     * @param string string to decode
+     * @param ok optional boolean, will be set to true if string was converted successfully
+     * @returns decoded units
+     * @see encodeUnit()
+    */
+    static QGis::UnitType decodeDistanceUnit( const QString& string, bool *ok = 0 );
+
+    /** Returns a translated string representing a distance unit.
+     * @param unit unit to convert to string
+     * @see fromString()
+     */
+    static QString toString( QGis::UnitType unit );
+
+    /** Converts a translated string to a distance unit.
+     * @param string string representing a distance unit
+     * @param ok optional boolean, will be set to true if string was converted successfully
+     * @see toString()
+     */
+    static QGis::UnitType stringToDistanceUnit( const QString& string, bool *ok = 0 );
+
+    /** Returns the conversion factor between the specified distance units.
+     * @param fromUnit distance unit to convert from
+     * @param toUnit distance unit to convert to
+     * @returns multiplication factor to convert between units
+     */
+    static double fromUnitToUnitFactor( QGis::UnitType fromUnit, QGis::UnitType toUnit );
+
+
+    /** Encodes a symbol unit to a string.
+     * @param unit unit to encode
+     * @returns encoded string
+     * @see decodeSymbolUnit()
+    */
+    static QString encodeUnit( QgsSymbolV2::OutputUnit unit );
+
+    /** Decodes a symbol unit from a string.
+     * @param string string to decode
+     * @param ok optional boolean, will be set to true if string was converted successfully
+     * @returns decoded units
+     * @see encodeUnit()
+    */
+    static QgsSymbolV2::OutputUnit decodeSymbolUnit( const QString& string, bool *ok = 0 );
+
+};
+
diff --git a/python/core/symbology-ng/qgssymbollayerv2utils.sip b/python/core/symbology-ng/qgssymbollayerv2utils.sip
index 5fabdba1c8f3..7514d65a1649 100644
--- a/python/core/symbology-ng/qgssymbollayerv2utils.sip
+++ b/python/core/symbology-ng/qgssymbollayerv2utils.sip
@@ -51,8 +51,10 @@ class QgsSymbolLayerV2Utils
     static QString encodeSldRealVector( const QVector<qreal>& v );
     static QVector<qreal> decodeSldRealVector( const QString& s );
 
-    static QString encodeOutputUnit( QgsSymbolV2::OutputUnit unit );
-    static QgsSymbolV2::OutputUnit decodeOutputUnit( const QString& str );
+    //! @deprecated use QgsUnitTypes::encodeUnit() instead
+    static QString encodeOutputUnit( QgsSymbolV2::OutputUnit unit ) /Deprecated/;
+    //! @deprecated use QgsUnitTypes::decodeSymbolUnit() instead
+    static QgsSymbolV2::OutputUnit decodeOutputUnit( const QString& str ) /Deprecated/;
 
     static QString encodeSldUom( QgsSymbolV2::OutputUnit unit, double *scaleFactor );
     static QgsSymbolV2::OutputUnit decodeSldUom( const QString& str, double *scaleFactor );
diff --git a/src/app/qgsdecorationitem.cpp b/src/app/qgsdecorationitem.cpp
index daca5a6dd651..d20e52cf3472 100644
--- a/src/app/qgsdecorationitem.cpp
+++ b/src/app/qgsdecorationitem.cpp
@@ -26,6 +26,7 @@
 #include "qgspoint.h"
 #include "qgsproject.h"
 #include "qgssymbollayerv2utils.h" //for pointOnLineWithDistance
+#include "qgsunittypes.h"
 
 #include <QPainter>
 #include <QAction>
@@ -66,7 +67,7 @@ void QgsDecorationItem::projectRead()
   QgsDebugMsg( "Entered" );
   mEnabled = QgsProject::instance()->readBoolEntry( mNameConfig, "/Enabled", false );
   mPlacement = static_cast< Placement >( QgsProject::instance()->readNumEntry( mNameConfig, "/Placement", static_cast< int >( mPlacement ) ) );
-  mMarginUnit = QgsSymbolLayerV2Utils::decodeOutputUnit( QgsProject::instance()->readEntry( mNameConfig, "/MarginUnit", QgsSymbolLayerV2Utils::encodeOutputUnit( mMarginUnit ) ) );
+  mMarginUnit = QgsUnitTypes::decodeSymbolUnit( QgsProject::instance()->readEntry( mNameConfig, "/MarginUnit", QgsUnitTypes::encodeUnit( mMarginUnit ) ) );
 }
 
 void QgsDecorationItem::saveToProject()
@@ -74,7 +75,7 @@ void QgsDecorationItem::saveToProject()
   QgsDebugMsg( "Entered" );
   QgsProject::instance()->writeEntry( mNameConfig, "/Enabled", mEnabled );
   QgsProject::instance()->writeEntry( mNameConfig, "/Placement", static_cast< int >( mPlacement ) );
-  QgsProject::instance()->writeEntry( mNameConfig, "/MarginUnit", QgsSymbolLayerV2Utils::encodeOutputUnit( mMarginUnit ) );
+  QgsProject::instance()->writeEntry( mNameConfig, "/MarginUnit", QgsUnitTypes::encodeUnit( mMarginUnit ) );
 }
 
 void QgsDecorationItem::setName( const char *name )
diff --git a/src/app/qgsdecorationscalebar.cpp b/src/app/qgsdecorationscalebar.cpp
index 4a969922e1d8..a0e2225b1296 100644
--- a/src/app/qgsdecorationscalebar.cpp
+++ b/src/app/qgsdecorationscalebar.cpp
@@ -31,7 +31,7 @@ email                : sbr00pwb@users.sourceforge.net
 #include "qgsmaptopixel.h"
 #include "qgspoint.h"
 #include "qgsproject.h"
-
+#include "qgsunittypes.h"
 
 #include <QPainter>
 #include <QAction>
@@ -132,11 +132,14 @@ void QgsDecorationScaleBar::render( QPainter * theQPainter )
     int myTextOffsetX = 3;
 
     QSettings settings;
-    QGis::UnitType myPreferredUnits = QGis::fromLiteral( settings.value( "/qgis/measure/displayunits", QGis::toLiteral( QGis::Meters ) ).toString() );
+    bool ok = false;
+    QGis::UnitType myPreferredUnits = QgsUnitTypes::decodeDistanceUnit( settings.value( "/qgis/measure/displayunits" ).toString(), &ok );
+    if ( !ok )
+      myPreferredUnits = QGis::Meters;
     QGis::UnitType myMapUnits = canvas->mapUnits();
 
     // Adjust units meter/feet/... or vice versa
-    myMapUnitsPerPixelDouble *= QGis::fromUnitToUnitFactor( myMapUnits, myPreferredUnits );
+    myMapUnitsPerPixelDouble *= QgsUnitTypes::fromUnitToUnitFactor( myMapUnits, myPreferredUnits );
     myMapUnits = myPreferredUnits;
 
     //Calculate size of scale bar for preferred number of map units
diff --git a/src/app/qgsmaptoolidentifyaction.cpp b/src/app/qgsmaptoolidentifyaction.cpp
index 472f33d99570..81497c69688b 100644
--- a/src/app/qgsmaptoolidentifyaction.cpp
+++ b/src/app/qgsmaptoolidentifyaction.cpp
@@ -35,6 +35,7 @@
 #include "qgsproject.h"
 #include "qgsmaplayerregistry.h"
 #include "qgsrendererv2.h"
+#include "qgsunittypes.h"
 
 #include <QSettings>
 #include <QMouseEvent>
@@ -187,7 +188,9 @@ QGis::UnitType QgsMapToolIdentifyAction::displayUnits()
 {
   // Get the units for display
   QSettings settings;
-  return QGis::fromLiteral( settings.value( "/qgis/measure/displayunits", QGis::toLiteral( QGis::Meters ) ).toString() );
+  bool ok = false;
+  QGis::UnitType unit = QgsUnitTypes::decodeDistanceUnit( settings.value( "/qgis/measure/displayunits" ).toString(), &ok );
+  return ok ? unit : QGis::Meters;
 }
 
 void QgsMapToolIdentifyAction::handleCopyToClipboard( QgsFeatureStore & featureStore )
diff --git a/src/app/qgsmeasuredialog.cpp b/src/app/qgsmeasuredialog.cpp
index a56d2897b144..32f1b8165161 100644
--- a/src/app/qgsmeasuredialog.cpp
+++ b/src/app/qgsmeasuredialog.cpp
@@ -25,6 +25,7 @@
 #include "qgsmaprenderer.h"
 #include "qgsproject.h"
 #include "qgscoordinatereferencesystem.h"
+#include "qgsunittypes.h"
 
 #include <QCloseEvent>
 #include <QLocale>
@@ -49,14 +50,14 @@ QgsMeasureDialog::QgsMeasureDialog( QgsMeasureTool* tool, Qt::WindowFlags f )
   mMeasureArea = tool->measureArea();
   mTotal = 0.;
 
-  mUnitsCombo->addItem( QGis::tr( QGis::Meters ) );
-  mUnitsCombo->addItem( QGis::tr( QGis::Feet ) );
-  mUnitsCombo->addItem( QGis::tr( QGis::Degrees ) );
-  mUnitsCombo->addItem( QGis::tr( QGis::NauticalMiles ) );
+  mUnitsCombo->addItem( QgsUnitTypes::toString( QGis::Meters ) );
+  mUnitsCombo->addItem( QgsUnitTypes::toString( QGis::Feet ) );
+  mUnitsCombo->addItem( QgsUnitTypes::toString( QGis::Degrees ) );
+  mUnitsCombo->addItem( QgsUnitTypes::toString( QGis::NauticalMiles ) );
 
   QSettings settings;
-  QString units = settings.value( "/qgis/measure/displayunits", QGis::toLiteral( QGis::Meters ) ).toString();
-  mUnitsCombo->setCurrentIndex( mUnitsCombo->findText( QGis::tr( QGis::fromLiteral( units ) ), Qt::MatchFixedString ) );
+  QString units = settings.value( "/qgis/measure/displayunits", QgsUnitTypes::encodeUnit( QGis::Meters ) ).toString();
+  mUnitsCombo->setCurrentIndex( mUnitsCombo->findText( QgsUnitTypes::toString( QgsUnitTypes::decodeDistanceUnit( units ) ), Qt::MatchFixedString ) );
 
   updateSettings();
 
@@ -78,7 +79,7 @@ void QgsMeasureDialog::updateSettings()
   mDecimalPlaces = settings.value( "/qgis/measure/decimalplaces", "3" ).toInt();
   mCanvasUnits = mTool->canvas()->mapUnits();
   // Configure QgsDistanceArea
-  mDisplayUnits = QGis::fromTr( mUnitsCombo->currentText() );
+  mDisplayUnits = QgsUnitTypes::stringToDistanceUnit( mUnitsCombo->currentText() );
   mDa.setSourceCrs( mTool->canvas()->mapSettings().destinationCrs().srsid() );
   mDa.setEllipsoid( QgsProject::instance()->readEntry( "Measure", "/Ellipsoid", GEO_NONE ) );
   // Only use ellipsoidal calculation when project wide transformation is enabled.
@@ -95,8 +96,8 @@ void QgsMeasureDialog::updateSettings()
   QgsDebugMsg( QString( "Ellipsoid ID : %1" ).arg( mDa.ellipsoid() ) );
   QgsDebugMsg( QString( "Ellipsoidal  : %1" ).arg( mDa.ellipsoidalEnabled() ? "true" : "false" ) );
   QgsDebugMsg( QString( "Decimalplaces: %1" ).arg( mDecimalPlaces ) );
-  QgsDebugMsg( QString( "Display units: %1" ).arg( QGis::toLiteral( mDisplayUnits ) ) );
-  QgsDebugMsg( QString( "Canvas units : %1" ).arg( QGis::toLiteral( mCanvasUnits ) ) );
+  QgsDebugMsg( QString( "Display units: %1" ).arg( QgsUnitTypes::encodeUnit( mDisplayUnits ) ) );
+  QgsDebugMsg( QString( "Canvas units : %1" ).arg( QgsUnitTypes::encodeUnit( mCanvasUnits ) ) );
 
   mTotal = 0;
   updateUi();
@@ -104,7 +105,7 @@ void QgsMeasureDialog::updateSettings()
 
 void QgsMeasureDialog::unitsChanged( const QString &units )
 {
-  mDisplayUnits = QGis::fromTr( units );
+  mDisplayUnits = QgsUnitTypes::stringToDistanceUnit( units );
   mTable->clear();
   mTotal = 0.;
   updateUi();
@@ -273,7 +274,7 @@ void QgsMeasureDialog::updateUi()
   if ( ! mTool->canvas()->hasCrsTransformEnabled() )
   {
     toolTip += "<br> * " + tr( "Project CRS transformation is turned off." ) + ' ';
-    toolTip += tr( "Canvas units setting is taken from project properties setting (%1)." ).arg( QGis::tr( mCanvasUnits ) );
+    toolTip += tr( "Canvas units setting is taken from project properties setting (%1)." ).arg( QgsUnitTypes::toString( mCanvasUnits ) );
     toolTip += "<br> * " + tr( "Ellipsoidal calculation is not possible, as project CRS is undefined." );
     setWindowTitle( tr( "Measure (OTF off)" ) );
   }
@@ -287,14 +288,14 @@ void QgsMeasureDialog::updateUi()
     else
     {
       toolTip += "<br> * " + tr( "Project CRS transformation is turned on but ellipsoidal calculation is not selected." );
-      toolTip += "<br> * " + tr( "The canvas units setting is taken from the project CRS (%1)." ).arg( QGis::tr( mCanvasUnits ) );
+      toolTip += "<br> * " + tr( "The canvas units setting is taken from the project CRS (%1)." ).arg( QgsUnitTypes::toString( mCanvasUnits ) );
     }
     setWindowTitle( tr( "Measure (OTF on)" ) );
   }
 
   if (( mCanvasUnits == QGis::Meters && mDisplayUnits == QGis::Feet ) || ( mCanvasUnits == QGis::Feet && mDisplayUnits == QGis::Meters ) )
   {
-    toolTip += "<br> * " + tr( "Finally, the value is converted from %1 to %2." ).arg( QGis::tr( mCanvasUnits ), QGis::tr( mDisplayUnits ) );
+    toolTip += "<br> * " + tr( "Finally, the value is converted from %1 to %2." ).arg( QgsUnitTypes::toString( mCanvasUnits ), QgsUnitTypes::toString( mDisplayUnits ) );
   }
 
   editTotal->setToolTip( toolTip );
@@ -304,7 +305,7 @@ void QgsMeasureDialog::updateUi()
   QGis::UnitType newDisplayUnits;
   double dummy = 1.0;
   convertMeasurement( dummy, newDisplayUnits, true );
-  mTable->setHeaderLabels( QStringList( tr( "Segments [%1]" ).arg( QGis::tr( newDisplayUnits ) ) ) );
+  mTable->setHeaderLabels( QStringList( tr( "Segments [%1]" ).arg( QgsUnitTypes::toString( newDisplayUnits ) ) ) );
 
   if ( mMeasureArea )
   {
@@ -354,7 +355,7 @@ void QgsMeasureDialog::convertMeasurement( double &measure, QGis::UnitType &u, b
   // Get the canvas units
   QGis::UnitType myUnits = mCanvasUnits;
 
-  QgsDebugMsg( QString( "Preferred display units are %1" ).arg( QGis::toLiteral( mDisplayUnits ) ) );
+  QgsDebugMsg( QString( "Preferred display units are %1" ).arg( QgsUnitTypes::encodeUnit( mDisplayUnits ) ) );
 
   mDa.convertMeasurement( measure, myUnits, mDisplayUnits, isArea );
   u = myUnits;
diff --git a/src/app/qgsoptions.cpp b/src/app/qgsoptions.cpp
index f2d9857a954f..a6e4bb5f332c 100644
--- a/src/app/qgsoptions.cpp
+++ b/src/app/qgsoptions.cpp
@@ -40,6 +40,7 @@
 #include "qgssymbollayerv2utils.h"
 #include "qgscolordialog.h"
 #include "qgsexpressioncontext.h"
+#include "qgsunittypes.h"
 
 #include <QInputDialog>
 #include <QFileDialog>
@@ -459,7 +460,11 @@ QgsOptions::QgsOptions( QWidget *parent, Qt::WindowFlags fl ) :
   }
 
   // Set the units for measuring
-  QGis::UnitType myDisplayUnits = QGis::fromLiteral( mSettings->value( "/qgis/measure/displayunits", QGis::toLiteral( QGis::Meters ) ).toString() );
+  bool ok = false;
+  QGis::UnitType myDisplayUnits = QgsUnitTypes::decodeDistanceUnit( mSettings->value( "/qgis/measure/displayunits" ).toString(), &ok );
+  if ( !ok )
+    myDisplayUnits = QGis::Meters;
+
   if ( myDisplayUnits == QGis::Feet )
   {
     radFeet->setChecked( true );
@@ -1241,19 +1246,19 @@ void QgsOptions::saveOptions()
 
   if ( radFeet->isChecked() )
   {
-    mSettings->setValue( "/qgis/measure/displayunits", QGis::toLiteral( QGis::Feet ) );
+    mSettings->setValue( "/qgis/measure/displayunits", QgsUnitTypes::encodeUnit( QGis::Feet ) );
   }
   else if ( radNautical->isChecked() )
   {
-    mSettings->setValue( "/qgis/measure/displayunits", QGis::toLiteral( QGis::NauticalMiles ) );
+    mSettings->setValue( "/qgis/measure/displayunits", QgsUnitTypes::encodeUnit( QGis::NauticalMiles ) );
   }
   else if ( radDegrees->isChecked() )
   {
-    mSettings->setValue( "/qgis/measure/displayunits", QGis::toLiteral( QGis::Degrees ) );
+    mSettings->setValue( "/qgis/measure/displayunits", QgsUnitTypes::encodeUnit( QGis::Degrees ) );
   }
   else
   {
-    mSettings->setValue( "/qgis/measure/displayunits", QGis::toLiteral( QGis::Meters ) );
+    mSettings->setValue( "/qgis/measure/displayunits", QgsUnitTypes::encodeUnit( QGis::Meters ) );
   }
 
   QString angleUnitString = "degrees";
diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt
index e76d7379f0d1..8b9d779561ea 100644
--- a/src/core/CMakeLists.txt
+++ b/src/core/CMakeLists.txt
@@ -192,6 +192,7 @@ SET(QGIS_CORE_SRCS
   qgstracer.cpp
   qgstransaction.cpp
   qgstransactiongroup.cpp
+  qgsunittypes.cpp
   qgsvectordataprovider.cpp
   qgsvectorfilewriter.cpp
   qgsvectorlayer.cpp
@@ -668,6 +669,7 @@ SET(QGIS_CORE_HDRS
   qgstextlabelfeature.h
   qgstolerance.h
   qgstracer.h
+  qgsunittypes.h
 
   qgsvectordataprovider.h
   qgsvectorlayercache.h
diff --git a/src/core/composer/qgscomposerscalebar.cpp b/src/core/composer/qgscomposerscalebar.cpp
index 7f40014f3279..10e180ec31ab 100644
--- a/src/core/composer/qgscomposerscalebar.cpp
+++ b/src/core/composer/qgscomposerscalebar.cpp
@@ -29,6 +29,7 @@
 #include "qgsproject.h"
 #include "qgssymbollayerv2utils.h"
 #include "qgsfontutils.h"
+#include "qgsunittypes.h"
 #include <QDomDocument>
 #include <QDomElement>
 #include <QFontMetricsF>
@@ -312,13 +313,13 @@ double QgsComposerScaleBar::mapWidth() const
     switch ( mUnits )
     {
       case QgsComposerScaleBar::Feet:
-        measure /= QGis::fromUnitToUnitFactor( QGis::Feet, units );
+        measure /= QgsUnitTypes::fromUnitToUnitFactor( QGis::Feet, units );
         break;
       case QgsComposerScaleBar::NauticalMiles:
-        measure /= QGis::fromUnitToUnitFactor( QGis::NauticalMiles, units );
+        measure /= QgsUnitTypes::fromUnitToUnitFactor( QGis::NauticalMiles, units );
         break;
       case QgsComposerScaleBar::Meters:
-        measure /= QGis::fromUnitToUnitFactor( QGis::Meters, units );
+        measure /= QgsUnitTypes::fromUnitToUnitFactor( QGis::Meters, units );
         break;
       case QgsComposerScaleBar::MapUnits:
         //avoid warning
diff --git a/src/core/dxf/qgsdxfexport.cpp b/src/core/dxf/qgsdxfexport.cpp
index 7b2161b3fb46..b3a714291233 100644
--- a/src/core/dxf/qgsdxfexport.cpp
+++ b/src/core/dxf/qgsdxfexport.cpp
@@ -36,6 +36,7 @@
 #include "qgslinesymbollayerv2.h"
 #include "qgsvectorlayer.h"
 #include "qgsmaplayerregistry.h"
+#include "qgsunittypes.h"
 
 #include <QIODevice>
 
@@ -893,7 +894,7 @@ void QgsDxfExport::writeEntities()
   mapSettings.setExtent( bbox );
 
   int dpi = 96;
-  double factor = 1000 * dpi / mSymbologyScaleDenominator / 25.4 * QGis::fromUnitToUnitFactor( mMapUnits, QGis::Meters );
+  double factor = 1000 * dpi / mSymbologyScaleDenominator / 25.4 * QgsUnitTypes::fromUnitToUnitFactor( mMapUnits, QGis::Meters );
   mapSettings.setOutputSize( QSize( bbox.width() * factor, bbox.height() * factor ) );
   mapSettings.setOutputDpi( dpi );
   mapSettings.setCrsTransformEnabled( false );
@@ -3857,7 +3858,7 @@ double QgsDxfExport::mapUnitScaleFactor( double scaleDenominator, QgsSymbolV2::O
     return 1.0;
   }
   // MM symbol unit
-  return scaleDenominator * QGis::fromUnitToUnitFactor( QGis::Meters, mapUnits ) / 1000.0;
+  return scaleDenominator * QgsUnitTypes::fromUnitToUnitFactor( QGis::Meters, mapUnits ) / 1000.0;
 }
 
 QList< QPair< QgsSymbolLayerV2*, QgsSymbolV2* > > QgsDxfExport::symbolLayers( QgsRenderContext &context )
@@ -4054,7 +4055,7 @@ double QgsDxfExport::dashSeparatorSize() const
 
 double QgsDxfExport::sizeToMapUnits( double s ) const
 {
-  double size = s * QGis::fromUnitToUnitFactor( QGis::Meters, mMapUnits );
+  double size = s * QgsUnitTypes::fromUnitToUnitFactor( QGis::Meters, mMapUnits );
   return size;
 }
 
diff --git a/src/core/effects/qgsgloweffect.cpp b/src/core/effects/qgsgloweffect.cpp
index 8832cee7a97c..46c7da765e56 100644
--- a/src/core/effects/qgsgloweffect.cpp
+++ b/src/core/effects/qgsgloweffect.cpp
@@ -19,6 +19,7 @@
 #include "qgssymbollayerv2utils.h"
 #include "qgsimageoperation.h"
 #include "qgsvectorcolorrampv2.h"
+#include "qgsunittypes.h"
 
 QgsGlowEffect::QgsGlowEffect()
     : QgsPaintEffect()
@@ -123,7 +124,7 @@ QgsStringMap QgsGlowEffect::properties() const
   props.insert( "transparency", QString::number( mTransparency ) );
   props.insert( "blur_level", QString::number( mBlurLevel ) );
   props.insert( "spread", QString::number( mSpread ) );
-  props.insert( "spread_unit", QgsSymbolLayerV2Utils::encodeOutputUnit( mSpreadUnit ) );
+  props.insert( "spread_unit", QgsUnitTypes::encodeUnit( mSpreadUnit ) );
   props.insert( "spread_unit_scale", QgsSymbolLayerV2Utils::encodeMapUnitScale( mSpreadMapUnitScale ) );
   props.insert( "color_type", QString::number( static_cast< int >( mColorType ) ) );
   props.insert( "single_color", QgsSymbolLayerV2Utils::encodeColor( mColor ) );
@@ -161,7 +162,7 @@ void QgsGlowEffect::readProperties( const QgsStringMap &props )
   {
     mSpread = spread;
   }
-  mSpreadUnit = QgsSymbolLayerV2Utils::decodeOutputUnit( props.value( "spread_unit" ) );
+  mSpreadUnit = QgsUnitTypes::decodeSymbolUnit( props.value( "spread_unit" ) );
   mSpreadMapUnitScale = QgsSymbolLayerV2Utils::decodeMapUnitScale( props.value( "spread_unit_scale" ) );
   QgsGlowEffect::GlowColorType type = static_cast< QgsGlowEffect::GlowColorType >( props.value( "color_type" ).toInt( &ok ) );
   if ( ok )
diff --git a/src/core/effects/qgsshadoweffect.cpp b/src/core/effects/qgsshadoweffect.cpp
index db46522d4a66..c0f63e358187 100644
--- a/src/core/effects/qgsshadoweffect.cpp
+++ b/src/core/effects/qgsshadoweffect.cpp
@@ -18,6 +18,7 @@
 #include "qgsshadoweffect.h"
 #include "qgsimageoperation.h"
 #include "qgssymbollayerv2utils.h"
+#include "qgsunittypes.h"
 
 QgsShadowEffect::QgsShadowEffect()
     : QgsPaintEffect()
@@ -102,7 +103,7 @@ QgsStringMap QgsShadowEffect::properties() const
   props.insert( "blur_level", QString::number( mBlurLevel ) );
   props.insert( "offset_angle", QString::number( mOffsetAngle ) );
   props.insert( "offset_distance", QString::number( mOffsetDist ) );
-  props.insert( "offset_unit", QgsSymbolLayerV2Utils::encodeOutputUnit( mOffsetUnit ) );
+  props.insert( "offset_unit", QgsUnitTypes::encodeUnit( mOffsetUnit ) );
   props.insert( "offset_unit_scale", QgsSymbolLayerV2Utils::encodeMapUnitScale( mOffsetMapUnitScale ) );
   props.insert( "color", QgsSymbolLayerV2Utils::encodeColor( mColor ) );
   return props;
@@ -138,7 +139,7 @@ void QgsShadowEffect::readProperties( const QgsStringMap &props )
   {
     mOffsetDist = distance;
   }
-  mOffsetUnit = QgsSymbolLayerV2Utils::decodeOutputUnit( props.value( "offset_unit" ) );
+  mOffsetUnit = QgsUnitTypes::decodeSymbolUnit( props.value( "offset_unit" ) );
   mOffsetMapUnitScale = QgsSymbolLayerV2Utils::decodeMapUnitScale( props.value( "offset_unit_scale" ) );
   if ( props.contains( "color" ) )
   {
diff --git a/src/core/effects/qgstransformeffect.cpp b/src/core/effects/qgstransformeffect.cpp
index a1222645044c..d9b0d6aab21b 100644
--- a/src/core/effects/qgstransformeffect.cpp
+++ b/src/core/effects/qgstransformeffect.cpp
@@ -17,6 +17,7 @@
 
 #include "qgstransformeffect.h"
 #include "qgssymbollayerv2utils.h"
+#include "qgsunittypes.h"
 #include <QPicture>
 #include <QTransform>
 
@@ -77,7 +78,7 @@ QgsStringMap QgsTransformEffect::properties() const
   props.insert( "shear_y", QString::number( mShearY ) );
   props.insert( "translate_x", QString::number( mTranslateX ) );
   props.insert( "translate_y", QString::number( mTranslateY ) );
-  props.insert( "translate_unit", QgsSymbolLayerV2Utils::encodeOutputUnit( mTranslateUnit ) );
+  props.insert( "translate_unit", QgsUnitTypes::encodeUnit( mTranslateUnit ) );
   props.insert( "translate_unit_scale", QgsSymbolLayerV2Utils::encodeMapUnitScale( mTranslateMapUnitScale ) );
   props.insert( "enabled", mEnabled ? "1" : "0" );
   props.insert( "draw_mode", QString::number( int( mDrawMode ) ) );
@@ -95,7 +96,7 @@ void QgsTransformEffect::readProperties( const QgsStringMap &props )
   mRotation = props.value( "rotation", "0.0" ).toDouble();
   mTranslateX = props.value( "translate_x", "0.0" ).toDouble();
   mTranslateY = props.value( "translate_y", "0.0" ).toDouble();
-  mTranslateUnit = QgsSymbolLayerV2Utils::decodeOutputUnit( props.value( "translate_unit" ) );
+  mTranslateUnit = QgsUnitTypes::decodeSymbolUnit( props.value( "translate_unit" ) );
   mTranslateMapUnitScale = QgsSymbolLayerV2Utils::decodeMapUnitScale( props.value( "translate_unit_scale" ) );
 }
 
diff --git a/src/core/qgis.cpp b/src/core/qgis.cpp
index 765b63406bb2..05652f8442b9 100644
--- a/src/core/qgis.cpp
+++ b/src/core/qgis.cpp
@@ -28,6 +28,7 @@
 #include "qgsconfig.h"
 #include "qgslogger.h"
 #include "geometry/qgswkbtypes.h"
+#include "qgsunittypes.h"
 
 #include <ogr_api.h>
 
@@ -181,88 +182,31 @@ QGis::WkbType QGis::fromNewWkbType( QgsWKBTypes::Type type )
 
 QGis::UnitType QGis::fromLiteral( const QString& literal, QGis::UnitType defaultType )
 {
-  for ( unsigned int i = 0; i < ( sizeof( qgisUnitTypes ) / sizeof( qgisUnitTypes[0] ) ); i++ )
-  {
-    if ( literal == qgisUnitTypes[ i ] )
-    {
-      return static_cast<UnitType>( i );
-    }
-  }
-  return defaultType;
+  bool ok = false;
+  QGis::UnitType unit = QgsUnitTypes::decodeDistanceUnit( literal, &ok );
+  return ok ? unit : defaultType;
 }
 
 QString QGis::toLiteral( QGis::UnitType unit )
 {
-  return QString( qgisUnitTypes[ static_cast<int>( unit )] );
+  return QgsUnitTypes::encodeUnit( unit );
 }
 
 QString QGis::tr( QGis::UnitType unit )
 {
-  return QCoreApplication::translate( "QGis::UnitType", qPrintable( toLiteral( unit ) ) );
+  return QgsUnitTypes::toString( unit );
 }
 
 QGis::UnitType QGis::fromTr( const QString& literal, QGis::UnitType defaultType )
 {
-  for ( unsigned int i = 0; i < ( sizeof( qgisUnitTypes ) / sizeof( qgisUnitTypes[0] ) ); i++ )
-  {
-    if ( literal == QGis::tr( static_cast<UnitType>( i ) ) )
-    {
-      return static_cast<UnitType>( i );
-    }
-  }
-  return defaultType;
+  bool ok = false;
+  QGis::UnitType unit = QgsUnitTypes::stringToDistanceUnit( literal, &ok );
+  return ok ? unit : defaultType;
 }
 
 double QGis::fromUnitToUnitFactor( QGis::UnitType fromUnit, QGis::UnitType toUnit )
 {
-#define DEGREE_TO_METER 111319.49079327358
-#define FEET_TO_METER 0.3048
-#define NMILE_TO_METER 1852.0
-
-  // Unify degree units
-  if ( fromUnit == QGis::DecimalDegrees || fromUnit == QGis::DegreesMinutesSeconds || fromUnit == QGis::DegreesDecimalMinutes )
-    fromUnit = QGis::Degrees;
-  if ( toUnit == QGis::DecimalDegrees || toUnit == QGis::DegreesMinutesSeconds || toUnit == QGis::DegreesDecimalMinutes )
-    toUnit = QGis::Degrees;
-
-  // Calculate the conversion factor between the specified units
-  if ( fromUnit != toUnit && fromUnit != QGis::UnknownUnit && toUnit != QGis::UnknownUnit )
-  {
-    switch ( fromUnit )
-    {
-      case QGis::Meters:
-      {
-        if ( toUnit == QGis::Feet ) return 1.0 / FEET_TO_METER;
-        if ( toUnit == QGis::Degrees ) return 1.0 / DEGREE_TO_METER;
-        if ( toUnit == QGis::NauticalMiles ) return 1.0 / NMILE_TO_METER;
-        break;
-      }
-      case QGis::Feet:
-      {
-        if ( toUnit == QGis::Meters ) return FEET_TO_METER;
-        if ( toUnit == QGis::Degrees ) return FEET_TO_METER / DEGREE_TO_METER;
-        if ( toUnit == QGis::NauticalMiles ) return FEET_TO_METER / NMILE_TO_METER;
-        break;
-      }
-      case QGis::Degrees:
-      {
-        if ( toUnit == QGis::Meters ) return DEGREE_TO_METER;
-        if ( toUnit == QGis::Feet ) return DEGREE_TO_METER / FEET_TO_METER;
-        if ( toUnit == QGis::NauticalMiles ) return DEGREE_TO_METER / NMILE_TO_METER;
-        break;
-      }
-      case QGis::NauticalMiles:
-      {
-        if ( toUnit == QGis::Meters ) return NMILE_TO_METER;
-        if ( toUnit == QGis::Feet ) return NMILE_TO_METER / FEET_TO_METER;
-        if ( toUnit == QGis::Degrees ) return NMILE_TO_METER / DEGREE_TO_METER;
-        break;
-      }
-      case QGis::UnknownUnit:
-        break;
-    }
-  }
-  return 1.0;
+  return QgsUnitTypes::fromUnitToUnitFactor( fromUnit, toUnit );
 }
 
 double QGis::permissiveToDouble( QString string, bool &ok )
diff --git a/src/core/qgis.h b/src/core/qgis.h
index 4c1490bd7122..03b171e4c883 100644
--- a/src/core/qgis.h
+++ b/src/core/qgis.h
@@ -151,6 +151,7 @@ class CORE_EXPORT QGis
      * @note that QGIS < 1.4 api had only Meters, Feet, Degrees and UnknownUnit
      * @note and QGIS >1.8 returns to that
      */
+    //TODO QGIS 3.0 - clean up and move to QgsUnitTypes and rename to DistanceUnit
     enum UnitType
     {
       Meters = 0,
@@ -166,15 +167,24 @@ class CORE_EXPORT QGis
     };
 
     //! Provides the canonical name of the type value
-    static QString toLiteral( QGis::UnitType unit );
+    //! @deprecated use QgsUnitTypes::encodeUnit() instead
+    Q_DECL_DEPRECATED static QString toLiteral( QGis::UnitType unit );
+
     //! Converts from the canonical name to the type value
-    static UnitType fromLiteral( const QString& literal, QGis::UnitType defaultType = UnknownUnit );
+    //! @deprecated use QgsUnitTypes::decodeDistanceUnit() instead
+    Q_DECL_DEPRECATED static UnitType fromLiteral( const QString& literal, QGis::UnitType defaultType = UnknownUnit );
+
     //! Provides translated version of the type value
-    static QString tr( QGis::UnitType unit );
+    //! @deprecated use QgsUnitTypes::toString() instead
+    Q_DECL_DEPRECATED static QString tr( QGis::UnitType unit );
+
     //! Provides type value from translated version
-    static UnitType fromTr( const QString& literal, QGis::UnitType defaultType = UnknownUnit );
+    //! @deprecated use QgsUnitTypes::stringToDistanceUnit() instead
+    Q_DECL_DEPRECATED static UnitType fromTr( const QString& literal, QGis::UnitType defaultType = UnknownUnit );
+
     //! Returns the conversion factor between the specified units
-    static double fromUnitToUnitFactor( QGis::UnitType fromUnit, QGis::UnitType toUnit );
+    //! @deprecated use QgsUnitTyoes::fromUnitToUnitFactor() instead
+    Q_DECL_DEPRECATED static double fromUnitToUnitFactor( QGis::UnitType fromUnit, QGis::UnitType toUnit );
 
     /** Converts a string to a double in a permissive way, eg allowing for incorrect
      * numbers of digits between thousand separators
diff --git a/src/core/qgsdistancearea.cpp b/src/core/qgsdistancearea.cpp
index 58d2c8fbab55..3450d18a725f 100644
--- a/src/core/qgsdistancearea.cpp
+++ b/src/core/qgsdistancearea.cpp
@@ -35,6 +35,7 @@
 #include "qgslinestringv2.h"
 #include "qgspolygonv2.h"
 #include "qgssurfacev2.h"
+#include "qgsunittypes.h"
 
 // MSVC compiler doesn't have defined M_PI in math.h
 #ifndef M_PI
@@ -1107,13 +1108,13 @@ void QgsDistanceArea::convertMeasurement( double &measure, QGis::UnitType &measu
   }
 
   // Gets the conversion factor between the specified units
-  double factorUnits = QGis::fromUnitToUnitFactor( measureUnits, displayUnits );
+  double factorUnits = QgsUnitTypes::fromUnitToUnitFactor( measureUnits, displayUnits );
   if ( isArea )
     factorUnits *= factorUnits;
 
-  QgsDebugMsg( QString( "Converting %1 %2" ).arg( QString::number( measure ), QGis::toLiteral( measureUnits ) ) );
+  QgsDebugMsg( QString( "Converting %1 %2" ).arg( QString::number( measure ), QgsUnitTypes::toString( measureUnits ) ) );
   measure *= factorUnits;
-  QgsDebugMsg( QString( "to %1 %2" ).arg( QString::number( measure ), QGis::toLiteral( displayUnits ) ) );
+  QgsDebugMsg( QString( "to %1 %2" ).arg( QString::number( measure ), QgsUnitTypes::toString( displayUnits ) ) );
   measureUnits = displayUnits;
 }
 
diff --git a/src/core/qgspallabeling.cpp b/src/core/qgspallabeling.cpp
index 4e4c6be1275a..e9c751f2344f 100644
--- a/src/core/qgspallabeling.cpp
+++ b/src/core/qgspallabeling.cpp
@@ -17,6 +17,7 @@
 
 #include "qgspallabeling.h"
 #include "qgstextlabelfeature.h"
+#include "qgsunittypes.h"
 
 #include <list>
 
@@ -4626,14 +4627,14 @@ void QgsPalLabeling::drawLabelBackground( QgsRenderContext& context,
     QgsStringMap map; // for SVG symbology marker
     map["name"] = QgsSymbolLayerV2Utils::symbolNameToPath( tmpLyr.shapeSVGFile.trimmed() );
     map["size"] = QString::number( sizeOut );
-    map["size_unit"] = QgsSymbolLayerV2Utils::encodeOutputUnit(
+    map["size_unit"] = QgsUnitTypes::encodeUnit(
                          tmpLyr.shapeSizeUnits == QgsPalLayerSettings::MapUnits ? QgsSymbolV2::MapUnit : QgsSymbolV2::MM );
     map["angle"] = QString::number( 0.0 ); // angle is handled by this local painter
 
     // offset is handled by this local painter
     // TODO: see why the marker renderer doesn't seem to translate offset *after* applying rotation
     //map["offset"] = QgsSymbolLayerV2Utils::encodePoint( tmpLyr.shapeOffset );
-    //map["offset_unit"] = QgsSymbolLayerV2Utils::encodeOutputUnit(
+    //map["offset_unit"] = QgsUnitTypes::encodeUnit(
     //                       tmpLyr.shapeOffsetUnits == QgsPalLayerSettings::MapUnits ? QgsSymbolV2::MapUnit : QgsSymbolV2::MM );
 
     map["fill"] = tmpLyr.shapeFillColor.name();
@@ -4642,7 +4643,7 @@ void QgsPalLabeling::drawLabelBackground( QgsRenderContext& context,
 
     // TODO: fix overriding SVG symbol's border width/units in QgsSvgCache
     // currently broken, fall back to symbol's
-    //map["outline_width_unit"] = QgsSymbolLayerV2Utils::encodeOutputUnit(
+    //map["outline_width_unit"] = QgsUnitTypes::encodeUnit(
     //                              tmpLyr.shapeBorderWidthUnits == QgsPalLayerSettings::MapUnits ? QgsSymbolV2::MapUnit : QgsSymbolV2::MM );
 
     if ( tmpLyr.shadowDraw && tmpLyr.shadowUnder == QgsPalLayerSettings::ShadowShape )
diff --git a/src/core/qgsunittypes.cpp b/src/core/qgsunittypes.cpp
new file mode 100644
index 000000000000..a7910f2fdb95
--- /dev/null
+++ b/src/core/qgsunittypes.cpp
@@ -0,0 +1,245 @@
+/***************************************************************************
+                         qgsunittypes.cpp
+                         --------------
+    begin                : February 2016
+    copyright            : (C) 2016 by Nyall Dawson
+    email                : nyall dot dawson at gmail dot com
+ ***************************************************************************/
+/***************************************************************************
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ ***************************************************************************/
+
+#include "qgsunittypes.h"
+#include <QCoreApplication>
+
+/***************************************************************************
+ * This class is considered CRITICAL and any change MUST be accompanied with
+ * full unit tests in test_qgsunittypes.py.
+ * See details in QEP #17
+ ****************************************************************************/
+
+QgsUnitTypes::DistanceUnitType QgsUnitTypes::unitType( QGis::UnitType unit )
+{
+  switch ( unit )
+  {
+    case QGis::Meters:
+    case QGis::Feet:
+    case QGis::NauticalMiles:
+      return Standard;
+
+    case QGis::Degrees:
+      return Geographic;
+
+    case QGis::UnknownUnit:
+      return UnknownType;
+  }
+  return UnknownType;
+}
+
+QString QgsUnitTypes::encodeUnit( QGis::UnitType unit )
+{
+  switch ( unit )
+  {
+    case QGis::Meters:
+      return "meters";
+
+    case QGis::Feet:
+      return "feet";
+
+    case QGis::Degrees:
+      return "degrees";
+
+    case QGis::UnknownUnit:
+      return "<unknown>";
+
+    case QGis::NauticalMiles:
+      return "nautical miles";
+  }
+  return QString();
+}
+
+/***************************************************************************
+ * This class is considered CRITICAL and any change MUST be accompanied with
+ * full unit tests in test_qgsunittypes.py.
+ * See details in QEP #17
+ ****************************************************************************/
+
+QGis::UnitType QgsUnitTypes::decodeDistanceUnit( const QString& string, bool* ok )
+{
+  QString normalized = string.trimmed().toLower();
+
+  if ( ok )
+    *ok = true;
+
+  if ( normalized == encodeUnit( QGis::Meters ) )
+    return QGis::Meters;
+  if ( normalized == encodeUnit( QGis::Feet ) )
+    return QGis::Feet;
+  if ( normalized == encodeUnit( QGis::Degrees ) )
+    return QGis::Degrees;
+  if ( normalized == encodeUnit( QGis::NauticalMiles ) )
+    return QGis::NauticalMiles;
+  if ( normalized == encodeUnit( QGis::UnknownUnit ) )
+    return QGis::UnknownUnit;
+
+  if ( ok )
+    *ok = false;
+
+  return QGis::UnknownUnit;
+}
+
+QString QgsUnitTypes::toString( QGis::UnitType unit )
+{
+  switch ( unit )
+  {
+    case QGis::Meters:
+      return QCoreApplication::translate( "QGis::UnitType", "meters" );
+    case QGis::Feet:
+      return QCoreApplication::translate( "QGis::UnitType", "feet" );
+
+    case QGis::Degrees:
+      return QCoreApplication::translate( "QGis::UnitType", "degrees" );
+
+    case QGis::UnknownUnit:
+      return QCoreApplication::translate( "QGis::UnitType", "<unknown>" );
+
+    case QGis::NauticalMiles:
+      return QCoreApplication::translate( "QGis::UnitType", "nautical miles" );
+  }
+  return QString();
+}
+
+/***************************************************************************
+ * This class is considered CRITICAL and any change MUST be accompanied with
+ * full unit tests in test_qgsunittypes.py.
+ * See details in QEP #17
+ ****************************************************************************/
+
+QGis::UnitType QgsUnitTypes::stringToDistanceUnit( const QString& string, bool* ok )
+{
+  QString normalized = string.trimmed().toLower();
+
+  if ( ok )
+    *ok = true;
+
+  if ( normalized == toString( QGis::Meters ) )
+    return QGis::Meters;
+  if ( normalized == toString( QGis::Feet ) )
+    return QGis::Feet;
+  if ( normalized == toString( QGis::Degrees ) )
+    return QGis::Degrees;
+  if ( normalized == toString( QGis::NauticalMiles ) )
+    return QGis::NauticalMiles;
+  if ( normalized == toString( QGis::UnknownUnit ) )
+    return QGis::UnknownUnit;
+
+  if ( ok )
+    *ok = false;
+
+  return QGis::UnknownUnit;
+}
+
+/***************************************************************************
+ * This class is considered CRITICAL and any change MUST be accompanied with
+ * full unit tests in test_qgsunittypes.py.
+ * See details in QEP #17
+ ****************************************************************************/
+
+double QgsUnitTypes::fromUnitToUnitFactor( QGis::UnitType fromUnit, QGis::UnitType toUnit )
+{
+#define DEGREE_TO_METER 111319.49079327358
+#define FEET_TO_METER 0.3048
+#define NMILE_TO_METER 1852.0
+
+  // Unify degree units
+  if ( fromUnit == QGis::DecimalDegrees || fromUnit == QGis::DegreesMinutesSeconds || fromUnit == QGis::DegreesDecimalMinutes )
+    fromUnit = QGis::Degrees;
+  if ( toUnit == QGis::DecimalDegrees || toUnit == QGis::DegreesMinutesSeconds || toUnit == QGis::DegreesDecimalMinutes )
+    toUnit = QGis::Degrees;
+
+  // Calculate the conversion factor between the specified units
+  if ( fromUnit != toUnit && fromUnit != QGis::UnknownUnit && toUnit != QGis::UnknownUnit )
+  {
+    switch ( fromUnit )
+    {
+      case QGis::Meters:
+      {
+        if ( toUnit == QGis::Feet ) return 1.0 / FEET_TO_METER;
+        if ( toUnit == QGis::Degrees ) return 1.0 / DEGREE_TO_METER;
+        if ( toUnit == QGis::NauticalMiles ) return 1.0 / NMILE_TO_METER;
+        break;
+      }
+      case QGis::Feet:
+      {
+        if ( toUnit == QGis::Meters ) return FEET_TO_METER;
+        if ( toUnit == QGis::Degrees ) return FEET_TO_METER / DEGREE_TO_METER;
+        if ( toUnit == QGis::NauticalMiles ) return FEET_TO_METER / NMILE_TO_METER;
+        break;
+      }
+      case QGis::Degrees:
+      {
+        if ( toUnit == QGis::Meters ) return DEGREE_TO_METER;
+        if ( toUnit == QGis::Feet ) return DEGREE_TO_METER / FEET_TO_METER;
+        if ( toUnit == QGis::NauticalMiles ) return DEGREE_TO_METER / NMILE_TO_METER;
+        break;
+      }
+      case QGis::NauticalMiles:
+      {
+        if ( toUnit == QGis::Meters ) return NMILE_TO_METER;
+        if ( toUnit == QGis::Feet ) return NMILE_TO_METER / FEET_TO_METER;
+        if ( toUnit == QGis::Degrees ) return NMILE_TO_METER / DEGREE_TO_METER;
+        break;
+      }
+      case QGis::UnknownUnit:
+        break;
+    }
+  }
+  return 1.0;
+}
+
+QString QgsUnitTypes::encodeUnit( QgsSymbolV2::OutputUnit unit )
+{
+  switch ( unit )
+  {
+    case QgsSymbolV2::MM:
+      return "MM";
+    case QgsSymbolV2::MapUnit:
+      return "MapUnit";
+    case QgsSymbolV2::Pixel:
+      return "Pixel";
+    case QgsSymbolV2::Percentage:
+      return "Percentage";
+    default:
+      return "MM";
+  }
+  //avoid warning
+  return QString();
+}
+
+QgsSymbolV2::OutputUnit QgsUnitTypes::decodeSymbolUnit( const QString& string, bool* ok )
+{
+  QString normalized = string.trimmed().toLower();
+
+  if ( ok )
+    *ok = true;
+
+  if ( normalized == encodeUnit( QgsSymbolV2::MM ).toLower() )
+    return QgsSymbolV2::MM;
+  if ( normalized == encodeUnit( QgsSymbolV2::MapUnit ).toLower() )
+    return QgsSymbolV2::MapUnit;
+  if ( normalized == encodeUnit( QgsSymbolV2::Pixel ).toLower() )
+    return QgsSymbolV2::Pixel;
+  if ( normalized == encodeUnit( QgsSymbolV2::Percentage ).toLower() )
+    return QgsSymbolV2::Percentage;
+
+  if ( ok )
+    *ok = false;
+
+  // millimeters are default
+  return QgsSymbolV2::MM;
+}
diff --git a/src/core/qgsunittypes.h b/src/core/qgsunittypes.h
new file mode 100644
index 000000000000..30055ba65737
--- /dev/null
+++ b/src/core/qgsunittypes.h
@@ -0,0 +1,106 @@
+/***************************************************************************
+                         qgsunittypes.h
+                         --------------
+    begin                : February 2016
+    copyright            : (C) 2016 by Nyall Dawson
+    email                : nyall dot dawson at gmail dot com
+ ***************************************************************************/
+
+/***************************************************************************
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ ***************************************************************************/
+
+#ifndef QGSUNITTYPES_H
+#define QGSUNITTYPES_H
+
+#include "qgis.h"
+#include "symbology-ng/qgssymbolv2.h"
+
+/***************************************************************************
+ * This class is considered CRITICAL and any change MUST be accompanied with
+ * full unit tests in test_qgsunittypes.py.
+ * See details in QEP #17
+ ****************************************************************************/
+
+/** \ingroup core
+ * \class QgsUnitTypes
+ * \brief Helper functions for various unit types.
+ * \note Added in version 2.14
+ */
+
+class CORE_EXPORT QgsUnitTypes
+{
+  public:
+
+    /** Types of distance units
+     */
+    enum DistanceUnitType
+    {
+      Standard = 0, /*!< unit is a standard measurement unit */
+      Geographic, /*!< unit is a geographic (eg degree based) unit */
+      UnknownType, /*!< unknown unit type */
+    };
+
+    /** Returns the type for a distance unit.
+    */
+    static DistanceUnitType unitType( QGis::UnitType unit );
+
+    /** Encodes a distance unit to a string.
+     * @param unit unit to encode
+     * @returns encoded string
+     * @see decodeDistanceUnit()
+    */
+    static QString encodeUnit( QGis::UnitType unit );
+
+    /** Decodes a distance unit from a string.
+     * @param string string to decode
+     * @param ok optional boolean, will be set to true if string was converted successfully
+     * @returns decoded units
+     * @see encodeUnit()
+    */
+    static QGis::UnitType decodeDistanceUnit( const QString& string, bool *ok = 0 );
+
+    /** Returns a translated string representing a distance unit.
+     * @param unit unit to convert to string
+     * @see fromString()
+     */
+    static QString toString( QGis::UnitType unit );
+
+    /** Converts a translated string to a distance unit.
+     * @param string string representing a distance unit
+     * @param ok optional boolean, will be set to true if string was converted successfully
+     * @see toString()
+     */
+    static QGis::UnitType stringToDistanceUnit( const QString& string, bool *ok = 0 );
+
+    /** Returns the conversion factor between the specified distance units.
+     * @param fromUnit distance unit to convert from
+     * @param toUnit distance unit to convert to
+     * @returns multiplication factor to convert between units
+     */
+    static double fromUnitToUnitFactor( QGis::UnitType fromUnit, QGis::UnitType toUnit );
+
+
+    /** Encodes a symbol unit to a string.
+     * @param unit unit to encode
+     * @returns encoded string
+     * @see decodeSymbolUnit()
+    */
+    static QString encodeUnit( QgsSymbolV2::OutputUnit unit );
+
+    /** Decodes a symbol unit from a string.
+     * @param string string to decode
+     * @param ok optional boolean, will be set to true if string was converted successfully
+     * @returns decoded units
+     * @see encodeUnit()
+    */
+    static QgsSymbolV2::OutputUnit decodeSymbolUnit( const QString& string, bool *ok = 0 );
+
+};
+
+#endif // QGSUNITTYPES_H
diff --git a/src/core/symbology-ng/qgsellipsesymbollayerv2.cpp b/src/core/symbology-ng/qgsellipsesymbollayerv2.cpp
index 0212a2336d3a..4c2536b775ae 100644
--- a/src/core/symbology-ng/qgsellipsesymbollayerv2.cpp
+++ b/src/core/symbology-ng/qgsellipsesymbollayerv2.cpp
@@ -20,6 +20,7 @@
 #include "qgsvectorlayer.h"
 #include "qgsdatadefined.h"
 #include "qgslogger.h"
+#include "qgsunittypes.h"
 
 #include <QPainter>
 #include <QSet>
@@ -67,7 +68,7 @@ QgsSymbolLayerV2* QgsEllipseSymbolLayerV2::create( const QgsStringMap& propertie
   }
   if ( properties.contains( "symbol_width_unit" ) )
   {
-    layer->setSymbolWidthUnit( QgsSymbolLayerV2Utils::decodeOutputUnit( properties["symbol_width_unit"] ) );
+    layer->setSymbolWidthUnit( QgsUnitTypes::decodeSymbolUnit( properties["symbol_width_unit"] ) );
   }
   if ( properties.contains( "symbol_width_map_unit_scale" ) )
   {
@@ -79,7 +80,7 @@ QgsSymbolLayerV2* QgsEllipseSymbolLayerV2::create( const QgsStringMap& propertie
   }
   if ( properties.contains( "symbol_height_unit" ) )
   {
-    layer->setSymbolHeightUnit( QgsSymbolLayerV2Utils::decodeOutputUnit( properties["symbol_height_unit"] ) );
+    layer->setSymbolHeightUnit( QgsUnitTypes::decodeSymbolUnit( properties["symbol_height_unit"] ) );
   }
   if ( properties.contains( "symbol_height_map_unit_scale" ) )
   {
@@ -107,11 +108,11 @@ QgsSymbolLayerV2* QgsEllipseSymbolLayerV2::create( const QgsStringMap& propertie
   }
   if ( properties.contains( "outline_width_unit" ) )
   {
-    layer->setOutlineWidthUnit( QgsSymbolLayerV2Utils::decodeOutputUnit( properties["outline_width_unit"] ) );
+    layer->setOutlineWidthUnit( QgsUnitTypes::decodeSymbolUnit( properties["outline_width_unit"] ) );
   }
   else if ( properties.contains( "line_width_unit" ) )
   {
-    layer->setOutlineWidthUnit( QgsSymbolLayerV2Utils::decodeOutputUnit( properties["line_width_unit"] ) );
+    layer->setOutlineWidthUnit( QgsUnitTypes::decodeSymbolUnit( properties["line_width_unit"] ) );
   }
   if ( properties.contains( "outline_width_map_unit_scale" ) )
   {
@@ -140,7 +141,7 @@ QgsSymbolLayerV2* QgsEllipseSymbolLayerV2::create( const QgsStringMap& propertie
   }
   if ( properties.contains( "size_unit" ) )
   {
-    layer->setSizeUnit( QgsSymbolLayerV2Utils::decodeOutputUnit( properties["size_unit"] ) );
+    layer->setSizeUnit( QgsUnitTypes::decodeSymbolUnit( properties["size_unit"] ) );
   }
   if ( properties.contains( "size_map_unit_scale" ) )
   {
@@ -152,7 +153,7 @@ QgsSymbolLayerV2* QgsEllipseSymbolLayerV2::create( const QgsStringMap& propertie
   }
   if ( properties.contains( "offset_unit" ) )
   {
-    layer->setOffsetUnit( QgsSymbolLayerV2Utils::decodeOutputUnit( properties["offset_unit"] ) );
+    layer->setOffsetUnit( QgsUnitTypes::decodeSymbolUnit( properties["offset_unit"] ) );
   }
   if ( properties.contains( "offset_map_unit_scale" ) )
   {
@@ -470,23 +471,23 @@ QgsStringMap QgsEllipseSymbolLayerV2::properties() const
   QgsStringMap map;
   map["symbol_name"] = mSymbolName;
   map["symbol_width"] = QString::number( mSymbolWidth );
-  map["symbol_width_unit"] = QgsSymbolLayerV2Utils::encodeOutputUnit( mSymbolWidthUnit );
+  map["symbol_width_unit"] = QgsUnitTypes::encodeUnit( mSymbolWidthUnit );
   map["symbol_width_map_unit_scale"] = QgsSymbolLayerV2Utils::encodeMapUnitScale( mSymbolWidthMapUnitScale );
   map["symbol_height"] = QString::number( mSymbolHeight );
-  map["symbol_height_unit"] = QgsSymbolLayerV2Utils::encodeOutputUnit( mSymbolHeightUnit );
+  map["symbol_height_unit"] = QgsUnitTypes::encodeUnit( mSymbolHeightUnit );
   map["symbol_height_map_unit_scale"] = QgsSymbolLayerV2Utils::encodeMapUnitScale( mSymbolHeightMapUnitScale );
   map["angle"] = QString::number( mAngle );
   map["outline_style"] = QgsSymbolLayerV2Utils::encodePenStyle( mOutlineStyle );
   map["outline_width"] = QString::number( mOutlineWidth );
-  map["outline_width_unit"] = QgsSymbolLayerV2Utils::encodeOutputUnit( mOutlineWidthUnit );
+  map["outline_width_unit"] = QgsUnitTypes::encodeUnit( mOutlineWidthUnit );
   map["outline_width_map_unit_scale"] = QgsSymbolLayerV2Utils::encodeMapUnitScale( mOutlineWidthMapUnitScale );
   map["color"] = QgsSymbolLayerV2Utils::encodeColor( mColor );
   map["outline_color"] = QgsSymbolLayerV2Utils::encodeColor( mOutlineColor );
   map["offset"] = QgsSymbolLayerV2Utils::encodePoint( mOffset );
-  map["offset_unit"] = QgsSymbolLayerV2Utils::encodeOutputUnit( mOffsetUnit );
+  map["offset_unit"] = QgsUnitTypes::encodeUnit( mOffsetUnit );
   map["offset_map_unit_scale"] = QgsSymbolLayerV2Utils::encodeMapUnitScale( mOffsetMapUnitScale );
   map["size"] = QString::number( mSize );
-  map["size_unit"] = QgsSymbolLayerV2Utils::encodeOutputUnit( mSizeUnit );
+  map["size_unit"] = QgsUnitTypes::encodeUnit( mSizeUnit );
   map["size_map_unit_scale"] = QgsSymbolLayerV2Utils::encodeMapUnitScale( mSizeMapUnitScale );
   map["horizontal_anchor_point"] = QString::number( mHorizontalAnchorPoint );
   map["vertical_anchor_point"] = QString::number( mVerticalAnchorPoint );
diff --git a/src/core/symbology-ng/qgsfillsymbollayerv2.cpp b/src/core/symbology-ng/qgsfillsymbollayerv2.cpp
index b8c009cbebfd..8060208875a0 100644
--- a/src/core/symbology-ng/qgsfillsymbollayerv2.cpp
+++ b/src/core/symbology-ng/qgsfillsymbollayerv2.cpp
@@ -24,6 +24,7 @@
 #include "qgssvgcache.h"
 #include "qgslogger.h"
 #include "qgsvectorcolorrampv2.h"
+#include "qgsunittypes.h"
 
 #include <QPainter>
 #include <QFile>
@@ -197,18 +198,18 @@ QgsSymbolLayerV2* QgsSimpleFillSymbolLayerV2::create( const QgsStringMap& props
   sl->setOffset( offset );
   if ( props.contains( "border_width_unit" ) )
   {
-    sl->setBorderWidthUnit( QgsSymbolLayerV2Utils::decodeOutputUnit( props["border_width_unit"] ) );
+    sl->setBorderWidthUnit( QgsUnitTypes::decodeSymbolUnit( props["border_width_unit"] ) );
   }
   else if ( props.contains( "outline_width_unit" ) )
   {
-    sl->setBorderWidthUnit( QgsSymbolLayerV2Utils::decodeOutputUnit( props["outline_width_unit"] ) );
+    sl->setBorderWidthUnit( QgsUnitTypes::decodeSymbolUnit( props["outline_width_unit"] ) );
   }
   else if ( props.contains( "line_width_unit" ) )
   {
-    sl->setBorderWidthUnit( QgsSymbolLayerV2Utils::decodeOutputUnit( props["line_width_unit"] ) );
+    sl->setBorderWidthUnit( QgsUnitTypes::decodeSymbolUnit( props["line_width_unit"] ) );
   }
   if ( props.contains( "offset_unit" ) )
-    sl->setOffsetUnit( QgsSymbolLayerV2Utils::decodeOutputUnit( props["offset_unit"] ) );
+    sl->setOffsetUnit( QgsUnitTypes::decodeSymbolUnit( props["offset_unit"] ) );
 
   if ( props.contains( "border_width_map_unit_scale" ) )
     sl->setBorderWidthMapUnitScale( QgsSymbolLayerV2Utils::decodeMapUnitScale( props["border_width_map_unit_scale"] ) );
@@ -300,11 +301,11 @@ QgsStringMap QgsSimpleFillSymbolLayerV2::properties() const
   map["outline_color"] = QgsSymbolLayerV2Utils::encodeColor( mBorderColor );
   map["outline_style"] = QgsSymbolLayerV2Utils::encodePenStyle( mBorderStyle );
   map["outline_width"] = QString::number( mBorderWidth );
-  map["outline_width_unit"] = QgsSymbolLayerV2Utils::encodeOutputUnit( mBorderWidthUnit );
+  map["outline_width_unit"] = QgsUnitTypes::encodeUnit( mBorderWidthUnit );
   map["border_width_map_unit_scale"] = QgsSymbolLayerV2Utils::encodeMapUnitScale( mBorderWidthMapUnitScale );
   map["joinstyle"] = QgsSymbolLayerV2Utils::encodePenJoinStyle( mPenJoinStyle );
   map["offset"] = QgsSymbolLayerV2Utils::encodePoint( mOffset );
-  map["offset_unit"] = QgsSymbolLayerV2Utils::encodeOutputUnit( mOffsetUnit );
+  map["offset_unit"] = QgsUnitTypes::encodeUnit( mOffsetUnit );
   map["offset_map_unit_scale"] = QgsSymbolLayerV2Utils::encodeMapUnitScale( mOffsetMapUnitScale );
   saveDataDefinedProperties( map );
   return map;
@@ -529,7 +530,7 @@ QgsSymbolLayerV2* QgsGradientFillSymbolLayerV2::create( const QgsStringMap& prop
   QgsGradientFillSymbolLayerV2* sl = new QgsGradientFillSymbolLayerV2( color, color2, colorType, type, coordinateMode, gradientSpread );
   sl->setOffset( offset );
   if ( props.contains( "offset_unit" ) )
-    sl->setOffsetUnit( QgsSymbolLayerV2Utils::decodeOutputUnit( props["offset_unit"] ) );
+    sl->setOffsetUnit( QgsUnitTypes::decodeSymbolUnit( props["offset_unit"] ) );
   if ( props.contains( "offset_map_unit_scale" ) )
     sl->setOffsetMapUnitScale( QgsSymbolLayerV2Utils::decodeMapUnitScale( props["offset_map_unit_scale"] ) );
   sl->setReferencePoint1( referencePoint1 );
@@ -876,7 +877,7 @@ QgsStringMap QgsGradientFillSymbolLayerV2::properties() const
   map["reference_point2_iscentroid"] = QString::number( mReferencePoint2IsCentroid );
   map["angle"] = QString::number( mAngle );
   map["offset"] = QgsSymbolLayerV2Utils::encodePoint( mOffset );
-  map["offset_unit"] = QgsSymbolLayerV2Utils::encodeOutputUnit( mOffsetUnit );
+  map["offset_unit"] = QgsUnitTypes::encodeUnit( mOffsetUnit );
   map["offset_map_unit_scale"] = QgsSymbolLayerV2Utils::encodeMapUnitScale( mOffsetMapUnitScale );
   saveDataDefinedProperties( map );
   if ( mGradientRamp )
@@ -1013,11 +1014,11 @@ QgsSymbolLayerV2* QgsShapeburstFillSymbolLayerV2::create( const QgsStringMap& pr
   sl->setOffset( offset );
   if ( props.contains( "offset_unit" ) )
   {
-    sl->setOffsetUnit( QgsSymbolLayerV2Utils::decodeOutputUnit( props["offset_unit"] ) );
+    sl->setOffsetUnit( QgsUnitTypes::decodeSymbolUnit( props["offset_unit"] ) );
   }
   if ( props.contains( "distance_unit" ) )
   {
-    sl->setDistanceUnit( QgsSymbolLayerV2Utils::decodeOutputUnit( props["distance_unit"] ) );
+    sl->setDistanceUnit( QgsUnitTypes::decodeSymbolUnit( props["distance_unit"] ) );
   }
   if ( props.contains( "offset_map_unit_scale" ) )
   {
@@ -1472,11 +1473,11 @@ QgsStringMap QgsShapeburstFillSymbolLayerV2::properties() const
   map["blur_radius"] = QString::number( mBlurRadius );
   map["use_whole_shape"] = QString::number( mUseWholeShape );
   map["max_distance"] = QString::number( mMaxDistance );
-  map["distance_unit"] = QgsSymbolLayerV2Utils::encodeOutputUnit( mDistanceUnit );
+  map["distance_unit"] = QgsUnitTypes::encodeUnit( mDistanceUnit );
   map["distance_map_unit_scale"] = QgsSymbolLayerV2Utils::encodeMapUnitScale( mDistanceMapUnitScale );
   map["ignore_rings"] = QString::number( mIgnoreRings );
   map["offset"] = QgsSymbolLayerV2Utils::encodePoint( mOffset );
-  map["offset_unit"] = QgsSymbolLayerV2Utils::encodeOutputUnit( mOffsetUnit );
+  map["offset_unit"] = QgsUnitTypes::encodeUnit( mOffsetUnit );
   map["offset_map_unit_scale"] = QgsSymbolLayerV2Utils::encodeMapUnitScale( mOffsetMapUnitScale );
 
   saveDataDefinedProperties( map );
@@ -1879,7 +1880,7 @@ QgsSymbolLayerV2* QgsSVGFillSymbolLayer::create( const QgsStringMap& properties
   //units
   if ( properties.contains( "pattern_width_unit" ) )
   {
-    symbolLayer->setPatternWidthUnit( QgsSymbolLayerV2Utils::decodeOutputUnit( properties["pattern_width_unit"] ) );
+    symbolLayer->setPatternWidthUnit( QgsUnitTypes::decodeSymbolUnit( properties["pattern_width_unit"] ) );
   }
   if ( properties.contains( "pattern_width_map_unit_scale" ) )
   {
@@ -1887,7 +1888,7 @@ QgsSymbolLayerV2* QgsSVGFillSymbolLayer::create( const QgsStringMap& properties
   }
   if ( properties.contains( "svg_outline_width_unit" ) )
   {
-    symbolLayer->setSvgOutlineWidthUnit( QgsSymbolLayerV2Utils::decodeOutputUnit( properties["svg_outline_width_unit"] ) );
+    symbolLayer->setSvgOutlineWidthUnit( QgsUnitTypes::decodeSymbolUnit( properties["svg_outline_width_unit"] ) );
   }
   if ( properties.contains( "svg_outline_width_map_unit_scale" ) )
   {
@@ -1895,7 +1896,7 @@ QgsSymbolLayerV2* QgsSVGFillSymbolLayer::create( const QgsStringMap& properties
   }
   if ( properties.contains( "outline_width_unit" ) )
   {
-    symbolLayer->setOutlineWidthUnit( QgsSymbolLayerV2Utils::decodeOutputUnit( properties["outline_width_unit"] ) );
+    symbolLayer->setOutlineWidthUnit( QgsUnitTypes::decodeSymbolUnit( properties["outline_width_unit"] ) );
   }
   if ( properties.contains( "outline_width_map_unit_scale" ) )
   {
@@ -2011,11 +2012,11 @@ QgsStringMap QgsSVGFillSymbolLayer::properties() const
   map.insert( "outline_width", QString::number( mSvgOutlineWidth ) );
 
   //units
-  map.insert( "pattern_width_unit", QgsSymbolLayerV2Utils::encodeOutputUnit( mPatternWidthUnit ) );
+  map.insert( "pattern_width_unit", QgsUnitTypes::encodeUnit( mPatternWidthUnit ) );
   map.insert( "pattern_width_map_unit_scale", QgsSymbolLayerV2Utils::encodeMapUnitScale( mPatternWidthMapUnitScale ) );
-  map.insert( "svg_outline_width_unit", QgsSymbolLayerV2Utils::encodeOutputUnit( mSvgOutlineWidthUnit ) );
+  map.insert( "svg_outline_width_unit", QgsUnitTypes::encodeUnit( mSvgOutlineWidthUnit ) );
   map.insert( "svg_outline_width_map_unit_scale", QgsSymbolLayerV2Utils::encodeMapUnitScale( mSvgOutlineWidthMapUnitScale ) );
-  map.insert( "outline_width_unit", QgsSymbolLayerV2Utils::encodeOutputUnit( mOutlineWidthUnit ) );
+  map.insert( "outline_width_unit", QgsUnitTypes::encodeUnit( mOutlineWidthUnit ) );
   map.insert( "outline_width_map_unit_scale", QgsSymbolLayerV2Utils::encodeMapUnitScale( mOutlineWidthMapUnitScale ) );
 
   saveDataDefinedProperties( map );
@@ -2464,7 +2465,7 @@ QgsSymbolLayerV2* QgsLinePatternFillSymbolLayer::create( const QgsStringMap& pro
 
   if ( properties.contains( "distance_unit" ) )
   {
-    patternLayer->setDistanceUnit( QgsSymbolLayerV2Utils::decodeOutputUnit( properties["distance_unit"] ) );
+    patternLayer->setDistanceUnit( QgsUnitTypes::decodeSymbolUnit( properties["distance_unit"] ) );
   }
   if ( properties.contains( "distance_map_unit_scale" ) )
   {
@@ -2472,11 +2473,11 @@ QgsSymbolLayerV2* QgsLinePatternFillSymbolLayer::create( const QgsStringMap& pro
   }
   if ( properties.contains( "line_width_unit" ) )
   {
-    patternLayer->setLineWidthUnit( QgsSymbolLayerV2Utils::decodeOutputUnit( properties["line_width_unit"] ) );
+    patternLayer->setLineWidthUnit( QgsUnitTypes::decodeSymbolUnit( properties["line_width_unit"] ) );
   }
   else if ( properties.contains( "outline_width_unit" ) )
   {
-    patternLayer->setLineWidthUnit( QgsSymbolLayerV2Utils::decodeOutputUnit( properties["outline_width_unit"] ) );
+    patternLayer->setLineWidthUnit( QgsUnitTypes::decodeSymbolUnit( properties["outline_width_unit"] ) );
   }
   if ( properties.contains( "line_width_map_unit_scale" ) )
   {
@@ -2484,7 +2485,7 @@ QgsSymbolLayerV2* QgsLinePatternFillSymbolLayer::create( const QgsStringMap& pro
   }
   if ( properties.contains( "offset_unit" ) )
   {
-    patternLayer->setOffsetUnit( QgsSymbolLayerV2Utils::decodeOutputUnit( properties["offset_unit"] ) );
+    patternLayer->setOffsetUnit( QgsUnitTypes::decodeSymbolUnit( properties["offset_unit"] ) );
   }
   if ( properties.contains( "offset_map_unit_scale" ) )
   {
@@ -2492,7 +2493,7 @@ QgsSymbolLayerV2* QgsLinePatternFillSymbolLayer::create( const QgsStringMap& pro
   }
   if ( properties.contains( "outline_width_unit" ) )
   {
-    patternLayer->setOutlineWidthUnit( QgsSymbolLayerV2Utils::decodeOutputUnit( properties["outline_width_unit"] ) );
+    patternLayer->setOutlineWidthUnit( QgsUnitTypes::decodeSymbolUnit( properties["outline_width_unit"] ) );
   }
   if ( properties.contains( "outline_width_map_unit_scale" ) )
   {
@@ -2822,13 +2823,13 @@ QgsStringMap QgsLinePatternFillSymbolLayer::properties() const
   map.insert( "line_width", QString::number( mLineWidth ) );
   map.insert( "color", QgsSymbolLayerV2Utils::encodeColor( mColor ) );
   map.insert( "offset", QString::number( mOffset ) );
-  map.insert( "distance_unit", QgsSymbolLayerV2Utils::encodeOutputUnit( mDistanceUnit ) );
-  map.insert( "line_width_unit", QgsSymbolLayerV2Utils::encodeOutputUnit( mLineWidthUnit ) );
-  map.insert( "offset_unit", QgsSymbolLayerV2Utils::encodeOutputUnit( mOffsetUnit ) );
+  map.insert( "distance_unit", QgsUnitTypes::encodeUnit( mDistanceUnit ) );
+  map.insert( "line_width_unit", QgsUnitTypes::encodeUnit( mLineWidthUnit ) );
+  map.insert( "offset_unit", QgsUnitTypes::encodeUnit( mOffsetUnit ) );
   map.insert( "distance_map_unit_scale", QgsSymbolLayerV2Utils::encodeMapUnitScale( mDistanceMapUnitScale ) );
   map.insert( "line_width_map_unit_scale", QgsSymbolLayerV2Utils::encodeMapUnitScale( mLineWidthMapUnitScale ) );
   map.insert( "offset_map_unit_scale", QgsSymbolLayerV2Utils::encodeMapUnitScale( mOffsetMapUnitScale ) );
-  map.insert( "outline_width_unit", QgsSymbolLayerV2Utils::encodeOutputUnit( mOutlineWidthUnit ) );
+  map.insert( "outline_width_unit", QgsUnitTypes::encodeUnit( mOutlineWidthUnit ) );
   map.insert( "outline_width_map_unit_scale", QgsSymbolLayerV2Utils::encodeMapUnitScale( mOutlineWidthMapUnitScale ) );
   saveDataDefinedProperties( map );
   return map;
@@ -3091,7 +3092,7 @@ QgsSymbolLayerV2* QgsPointPatternFillSymbolLayer::create( const QgsStringMap& pr
 
   if ( properties.contains( "distance_x_unit" ) )
   {
-    layer->setDistanceXUnit( QgsSymbolLayerV2Utils::decodeOutputUnit( properties["distance_x_unit"] ) );
+    layer->setDistanceXUnit( QgsUnitTypes::decodeSymbolUnit( properties["distance_x_unit"] ) );
   }
   if ( properties.contains( "distance_x_map_unit_scale" ) )
   {
@@ -3099,7 +3100,7 @@ QgsSymbolLayerV2* QgsPointPatternFillSymbolLayer::create( const QgsStringMap& pr
   }
   if ( properties.contains( "distance_y_unit" ) )
   {
-    layer->setDistanceYUnit( QgsSymbolLayerV2Utils::decodeOutputUnit( properties["distance_y_unit"] ) );
+    layer->setDistanceYUnit( QgsUnitTypes::decodeSymbolUnit( properties["distance_y_unit"] ) );
   }
   if ( properties.contains( "distance_y_map_unit_scale" ) )
   {
@@ -3107,7 +3108,7 @@ QgsSymbolLayerV2* QgsPointPatternFillSymbolLayer::create( const QgsStringMap& pr
   }
   if ( properties.contains( "displacement_x_unit" ) )
   {
-    layer->setDisplacementXUnit( QgsSymbolLayerV2Utils::decodeOutputUnit( properties["displacement_x_unit"] ) );
+    layer->setDisplacementXUnit( QgsUnitTypes::decodeSymbolUnit( properties["displacement_x_unit"] ) );
   }
   if ( properties.contains( "displacement_x_map_unit_scale" ) )
   {
@@ -3115,7 +3116,7 @@ QgsSymbolLayerV2* QgsPointPatternFillSymbolLayer::create( const QgsStringMap& pr
   }
   if ( properties.contains( "displacement_y_unit" ) )
   {
-    layer->setDisplacementYUnit( QgsSymbolLayerV2Utils::decodeOutputUnit( properties["displacement_y_unit"] ) );
+    layer->setDisplacementYUnit( QgsUnitTypes::decodeSymbolUnit( properties["displacement_y_unit"] ) );
   }
   if ( properties.contains( "displacement_y_map_unit_scale" ) )
   {
@@ -3123,7 +3124,7 @@ QgsSymbolLayerV2* QgsPointPatternFillSymbolLayer::create( const QgsStringMap& pr
   }
   if ( properties.contains( "outline_width_unit" ) )
   {
-    layer->setOutlineWidthUnit( QgsSymbolLayerV2Utils::decodeOutputUnit( properties["outline_width_unit"] ) );
+    layer->setOutlineWidthUnit( QgsUnitTypes::decodeSymbolUnit( properties["outline_width_unit"] ) );
   }
   if ( properties.contains( "outline_width_map_unit_scale" ) )
   {
@@ -3234,15 +3235,15 @@ QgsStringMap QgsPointPatternFillSymbolLayer::properties() const
   map.insert( "distance_y", QString::number( mDistanceY ) );
   map.insert( "displacement_x", QString::number( mDisplacementX ) );
   map.insert( "displacement_y", QString::number( mDisplacementY ) );
-  map.insert( "distance_x_unit", QgsSymbolLayerV2Utils::encodeOutputUnit( mDistanceXUnit ) );
-  map.insert( "distance_y_unit", QgsSymbolLayerV2Utils::encodeOutputUnit( mDistanceYUnit ) );
-  map.insert( "displacement_x_unit", QgsSymbolLayerV2Utils::encodeOutputUnit( mDisplacementXUnit ) );
-  map.insert( "displacement_y_unit", QgsSymbolLayerV2Utils::encodeOutputUnit( mDisplacementYUnit ) );
+  map.insert( "distance_x_unit", QgsUnitTypes::encodeUnit( mDistanceXUnit ) );
+  map.insert( "distance_y_unit", QgsUnitTypes::encodeUnit( mDistanceYUnit ) );
+  map.insert( "displacement_x_unit", QgsUnitTypes::encodeUnit( mDisplacementXUnit ) );
+  map.insert( "displacement_y_unit", QgsUnitTypes::encodeUnit( mDisplacementYUnit ) );
   map.insert( "distance_x_map_unit_scale", QgsSymbolLayerV2Utils::encodeMapUnitScale( mDistanceXMapUnitScale ) );
   map.insert( "distance_y_map_unit_scale", QgsSymbolLayerV2Utils::encodeMapUnitScale( mDistanceYMapUnitScale ) );
   map.insert( "displacement_x_map_unit_scale", QgsSymbolLayerV2Utils::encodeMapUnitScale( mDisplacementXMapUnitScale ) );
   map.insert( "displacement_y_map_unit_scale", QgsSymbolLayerV2Utils::encodeMapUnitScale( mDisplacementYMapUnitScale ) );
-  map.insert( "outline_width_unit", QgsSymbolLayerV2Utils::encodeOutputUnit( mOutlineWidthUnit ) );
+  map.insert( "outline_width_unit", QgsUnitTypes::encodeUnit( mOutlineWidthUnit ) );
   map.insert( "outline_width_map_unit_scale", QgsSymbolLayerV2Utils::encodeMapUnitScale( mOutlineWidthMapUnitScale ) );
   saveDataDefinedProperties( map );
   return map;
@@ -3590,7 +3591,7 @@ QgsSymbolLayerV2 *QgsRasterFillSymbolLayer::create( const QgsStringMap &properti
   symbolLayer->setWidth( width );
   if ( properties.contains( "offset_unit" ) )
   {
-    symbolLayer->setOffsetUnit( QgsSymbolLayerV2Utils::decodeOutputUnit( properties["offset_unit"] ) );
+    symbolLayer->setOffsetUnit( QgsUnitTypes::decodeSymbolUnit( properties["offset_unit"] ) );
   }
   if ( properties.contains( "offset_map_unit_scale" ) )
   {
@@ -3598,7 +3599,7 @@ QgsSymbolLayerV2 *QgsRasterFillSymbolLayer::create( const QgsStringMap &properti
   }
   if ( properties.contains( "width_unit" ) )
   {
-    symbolLayer->setWidthUnit( QgsSymbolLayerV2Utils::decodeOutputUnit( properties["width_unit"] ) );
+    symbolLayer->setWidthUnit( QgsUnitTypes::decodeSymbolUnit( properties["width_unit"] ) );
   }
   if ( properties.contains( "width_map_unit_scale" ) )
   {
@@ -3668,11 +3669,11 @@ QgsStringMap QgsRasterFillSymbolLayer::properties() const
   map["coordinate_mode"] = QString::number( mCoordinateMode );
   map["alpha"] = QString::number( mAlpha );
   map["offset"] = QgsSymbolLayerV2Utils::encodePoint( mOffset );
-  map["offset_unit"] = QgsSymbolLayerV2Utils::encodeOutputUnit( mOffsetUnit );
+  map["offset_unit"] = QgsUnitTypes::encodeUnit( mOffsetUnit );
   map["offset_map_unit_scale"] = QgsSymbolLayerV2Utils::encodeMapUnitScale( mOffsetMapUnitScale );
   map["angle"] = QString::number( mAngle );
   map["width"] = QString::number( mWidth );
-  map["width_unit"] = QgsSymbolLayerV2Utils::encodeOutputUnit( mWidthUnit );
+  map["width_unit"] = QgsUnitTypes::encodeUnit( mWidthUnit );
   map["width_map_unit_scale"] = QgsSymbolLayerV2Utils::encodeMapUnitScale( mWidthMapUnitScale );
 
   saveDataDefinedProperties( map );
diff --git a/src/core/symbology-ng/qgslinesymbollayerv2.cpp b/src/core/symbology-ng/qgslinesymbollayerv2.cpp
index 8382e5dbe722..8413c07f0ccb 100644
--- a/src/core/symbology-ng/qgslinesymbollayerv2.cpp
+++ b/src/core/symbology-ng/qgslinesymbollayerv2.cpp
@@ -23,6 +23,7 @@
 #include "qgslogger.h"
 #include "qgsvectorlayer.h"
 #include "qgsgeometrysimplifier.h"
+#include "qgsunittypes.h"
 
 #include <QPainter>
 #include <QDomDocument>
@@ -128,23 +129,23 @@ QgsSymbolLayerV2* QgsSimpleLineSymbolLayerV2::create( const QgsStringMap& props
   QgsSimpleLineSymbolLayerV2* l = new QgsSimpleLineSymbolLayerV2( color, width, penStyle );
   if ( props.contains( "line_width_unit" ) )
   {
-    l->setWidthUnit( QgsSymbolLayerV2Utils::decodeOutputUnit( props["line_width_unit"] ) );
+    l->setWidthUnit( QgsUnitTypes::decodeSymbolUnit( props["line_width_unit"] ) );
   }
   else if ( props.contains( "outline_width_unit" ) )
   {
-    l->setWidthUnit( QgsSymbolLayerV2Utils::decodeOutputUnit( props["outline_width_unit"] ) );
+    l->setWidthUnit( QgsUnitTypes::decodeSymbolUnit( props["outline_width_unit"] ) );
   }
   else if ( props.contains( "width_unit" ) )
   {
     //pre 2.5 projects used "width_unit"
-    l->setWidthUnit( QgsSymbolLayerV2Utils::decodeOutputUnit( props["width_unit"] ) );
+    l->setWidthUnit( QgsUnitTypes::decodeSymbolUnit( props["width_unit"] ) );
   }
   if ( props.contains( "width_map_unit_scale" ) )
     l->setWidthMapUnitScale( QgsSymbolLayerV2Utils::decodeMapUnitScale( props["width_map_unit_scale"] ) );
   if ( props.contains( "offset" ) )
     l->setOffset( props["offset"].toDouble() );
   if ( props.contains( "offset_unit" ) )
-    l->setOffsetUnit( QgsSymbolLayerV2Utils::decodeOutputUnit( props["offset_unit"] ) );
+    l->setOffsetUnit( QgsUnitTypes::decodeSymbolUnit( props["offset_unit"] ) );
   if ( props.contains( "offset_map_unit_scale" ) )
     l->setOffsetMapUnitScale( QgsSymbolLayerV2Utils::decodeMapUnitScale( props["offset_map_unit_scale"] ) );
   if ( props.contains( "joinstyle" ) )
@@ -162,7 +163,7 @@ QgsSymbolLayerV2* QgsSimpleLineSymbolLayerV2::create( const QgsStringMap& props
   }
   if ( props.contains( "customdash_unit" ) )
   {
-    l->setCustomDashPatternUnit( QgsSymbolLayerV2Utils::decodeOutputUnit( props["customdash_unit"] ) );
+    l->setCustomDashPatternUnit( QgsUnitTypes::decodeSymbolUnit( props["customdash_unit"] ) );
   }
   if ( props.contains( "customdash_map_unit_scale" ) )
   {
@@ -354,17 +355,17 @@ QgsStringMap QgsSimpleLineSymbolLayerV2::properties() const
   QgsStringMap map;
   map["line_color"] = QgsSymbolLayerV2Utils::encodeColor( mColor );
   map["line_width"] = QString::number( mWidth );
-  map["line_width_unit"] = QgsSymbolLayerV2Utils::encodeOutputUnit( mWidthUnit );
+  map["line_width_unit"] = QgsUnitTypes::encodeUnit( mWidthUnit );
   map["width_map_unit_scale"] = QgsSymbolLayerV2Utils::encodeMapUnitScale( mWidthMapUnitScale );
   map["line_style"] = QgsSymbolLayerV2Utils::encodePenStyle( mPenStyle );
   map["joinstyle"] = QgsSymbolLayerV2Utils::encodePenJoinStyle( mPenJoinStyle );
   map["capstyle"] = QgsSymbolLayerV2Utils::encodePenCapStyle( mPenCapStyle );
   map["offset"] = QString::number( mOffset );
-  map["offset_unit"] = QgsSymbolLayerV2Utils::encodeOutputUnit( mOffsetUnit );
+  map["offset_unit"] = QgsUnitTypes::encodeUnit( mOffsetUnit );
   map["offset_map_unit_scale"] = QgsSymbolLayerV2Utils::encodeMapUnitScale( mOffsetMapUnitScale );
   map["use_custom_dash"] = ( mUseCustomDashPattern ? "1" : "0" );
   map["customdash"] = QgsSymbolLayerV2Utils::encodeRealVector( mCustomDashVector );
-  map["customdash_unit"] = QgsSymbolLayerV2Utils::encodeOutputUnit( mCustomDashPatternUnit );
+  map["customdash_unit"] = QgsUnitTypes::encodeUnit( mCustomDashPatternUnit );
   map["customdash_map_unit_scale"] = QgsSymbolLayerV2Utils::encodeMapUnitScale( mCustomDashPatternMapUnitScale );
   map["draw_inside_polygon"] = ( mDrawInsidePolygon ? "1" : "0" );
   saveDataDefinedProperties( map );
@@ -748,11 +749,11 @@ QgsSymbolLayerV2* QgsMarkerLineSymbolLayerV2::create( const QgsStringMap& props
   }
   if ( props.contains( "offset_unit" ) )
   {
-    x->setOffsetUnit( QgsSymbolLayerV2Utils::decodeOutputUnit( props["offset_unit"] ) );
+    x->setOffsetUnit( QgsUnitTypes::decodeSymbolUnit( props["offset_unit"] ) );
   }
   if ( props.contains( "interval_unit" ) )
   {
-    x->setIntervalUnit( QgsSymbolLayerV2Utils::decodeOutputUnit( props["interval_unit"] ) );
+    x->setIntervalUnit( QgsUnitTypes::decodeSymbolUnit( props["interval_unit"] ) );
   }
   if ( props.contains( "offset_along_line" ) )
   {
@@ -760,7 +761,7 @@ QgsSymbolLayerV2* QgsMarkerLineSymbolLayerV2::create( const QgsStringMap& props
   }
   if ( props.contains( "offset_along_line_unit" ) )
   {
-    x->setOffsetAlongLineUnit( QgsSymbolLayerV2Utils::decodeOutputUnit( props["offset_along_line_unit"] ) );
+    x->setOffsetAlongLineUnit( QgsUnitTypes::decodeSymbolUnit( props["offset_along_line_unit"] ) );
   }
   if ( props.contains(( "offset_along_line_map_unit_scale" ) ) )
   {
@@ -1314,11 +1315,11 @@ QgsStringMap QgsMarkerLineSymbolLayerV2::properties() const
   map["interval"] = QString::number( mInterval );
   map["offset"] = QString::number( mOffset );
   map["offset_along_line"] = QString::number( mOffsetAlongLine );
-  map["offset_along_line_unit"] = QgsSymbolLayerV2Utils::encodeOutputUnit( mOffsetAlongLineUnit );
+  map["offset_along_line_unit"] = QgsUnitTypes::encodeUnit( mOffsetAlongLineUnit );
   map["offset_along_line_map_unit_scale"] = QgsSymbolLayerV2Utils::encodeMapUnitScale( mOffsetAlongLineMapUnitScale );
-  map["offset_unit"] = QgsSymbolLayerV2Utils::encodeOutputUnit( mOffsetUnit );
+  map["offset_unit"] = QgsUnitTypes::encodeUnit( mOffsetUnit );
   map["offset_map_unit_scale"] = QgsSymbolLayerV2Utils::encodeMapUnitScale( mOffsetMapUnitScale );
-  map["interval_unit"] = QgsSymbolLayerV2Utils::encodeOutputUnit( mIntervalUnit );
+  map["interval_unit"] = QgsUnitTypes::encodeUnit( mIntervalUnit );
   map["interval_map_unit_scale"] = QgsSymbolLayerV2Utils::encodeMapUnitScale( mIntervalMapUnitScale );
   if ( mPlacement == Vertex )
     map["placement"] = "vertex";
diff --git a/src/core/symbology-ng/qgsmarkersymbollayerv2.cpp b/src/core/symbology-ng/qgsmarkersymbollayerv2.cpp
index ff9cdcb416fc..6ba76dd73a3a 100644
--- a/src/core/symbology-ng/qgsmarkersymbollayerv2.cpp
+++ b/src/core/symbology-ng/qgsmarkersymbollayerv2.cpp
@@ -22,6 +22,7 @@
 #include "qgsrendercontext.h"
 #include "qgslogger.h"
 #include "qgssvgcache.h"
+#include "qgsunittypes.h"
 
 #include <QPainter>
 #include <QSvgRenderer>
@@ -99,11 +100,11 @@ QgsSymbolLayerV2* QgsSimpleMarkerSymbolLayerV2::create( const QgsStringMap& prop
   if ( props.contains( "offset" ) )
     m->setOffset( QgsSymbolLayerV2Utils::decodePoint( props["offset"] ) );
   if ( props.contains( "offset_unit" ) )
-    m->setOffsetUnit( QgsSymbolLayerV2Utils::decodeOutputUnit( props["offset_unit"] ) );
+    m->setOffsetUnit( QgsUnitTypes::decodeSymbolUnit( props["offset_unit"] ) );
   if ( props.contains( "offset_map_unit_scale" ) )
     m->setOffsetMapUnitScale( QgsSymbolLayerV2Utils::decodeMapUnitScale( props["offset_map_unit_scale"] ) );
   if ( props.contains( "size_unit" ) )
-    m->setSizeUnit( QgsSymbolLayerV2Utils::decodeOutputUnit( props["size_unit"] ) );
+    m->setSizeUnit( QgsUnitTypes::decodeSymbolUnit( props["size_unit"] ) );
   if ( props.contains( "size_map_unit_scale" ) )
     m->setSizeMapUnitScale( QgsSymbolLayerV2Utils::decodeMapUnitScale( props["size_map_unit_scale"] ) );
 
@@ -125,11 +126,11 @@ QgsSymbolLayerV2* QgsSimpleMarkerSymbolLayerV2::create( const QgsStringMap& prop
   }
   if ( props.contains( "outline_width_unit" ) )
   {
-    m->setOutlineWidthUnit( QgsSymbolLayerV2Utils::decodeOutputUnit( props["outline_width_unit"] ) );
+    m->setOutlineWidthUnit( QgsUnitTypes::decodeSymbolUnit( props["outline_width_unit"] ) );
   }
   if ( props.contains( "line_width_unit" ) )
   {
-    m->setOutlineWidthUnit( QgsSymbolLayerV2Utils::decodeOutputUnit( props["line_width_unit"] ) );
+    m->setOutlineWidthUnit( QgsUnitTypes::decodeSymbolUnit( props["line_width_unit"] ) );
   }
   if ( props.contains( "outline_width_map_unit_scale" ) )
   {
@@ -652,16 +653,16 @@ QgsStringMap QgsSimpleMarkerSymbolLayerV2::properties() const
   map["color"] = QgsSymbolLayerV2Utils::encodeColor( mColor );
   map["outline_color"] = QgsSymbolLayerV2Utils::encodeColor( mBorderColor );
   map["size"] = QString::number( mSize );
-  map["size_unit"] = QgsSymbolLayerV2Utils::encodeOutputUnit( mSizeUnit );
+  map["size_unit"] = QgsUnitTypes::encodeUnit( mSizeUnit );
   map["size_map_unit_scale"] = QgsSymbolLayerV2Utils::encodeMapUnitScale( mSizeMapUnitScale );
   map["angle"] = QString::number( mAngle );
   map["offset"] = QgsSymbolLayerV2Utils::encodePoint( mOffset );
-  map["offset_unit"] = QgsSymbolLayerV2Utils::encodeOutputUnit( mOffsetUnit );
+  map["offset_unit"] = QgsUnitTypes::encodeUnit( mOffsetUnit );
   map["offset_map_unit_scale"] = QgsSymbolLayerV2Utils::encodeMapUnitScale( mOffsetMapUnitScale );
   map["scale_method"] = QgsSymbolLayerV2Utils::encodeScaleMethod( mScaleMethod );
   map["outline_style"] = QgsSymbolLayerV2Utils::encodePenStyle( mOutlineStyle );
   map["outline_width"] = QString::number( mOutlineWidth );
-  map["outline_width_unit"] = QgsSymbolLayerV2Utils::encodeOutputUnit( mOutlineWidthUnit );
+  map["outline_width_unit"] = QgsUnitTypes::encodeUnit( mOutlineWidthUnit );
   map["outline_width_map_unit_scale"] = QgsSymbolLayerV2Utils::encodeMapUnitScale( mOutlineWidthMapUnitScale );
   map["horizontal_anchor_point"] = QString::number( mHorizontalAnchorPoint );
   map["vertical_anchor_point"] = QString::number( mVerticalAnchorPoint );
@@ -1186,13 +1187,13 @@ QgsSymbolLayerV2* QgsSvgMarkerSymbolLayerV2::create( const QgsStringMap& props )
   }
 
   if ( props.contains( "size_unit" ) )
-    m->setSizeUnit( QgsSymbolLayerV2Utils::decodeOutputUnit( props["size_unit"] ) );
+    m->setSizeUnit( QgsUnitTypes::decodeSymbolUnit( props["size_unit"] ) );
   if ( props.contains( "size_map_unit_scale" ) )
     m->setSizeMapUnitScale( QgsSymbolLayerV2Utils::decodeMapUnitScale( props["size_map_unit_scale"] ) );
   if ( props.contains( "offset" ) )
     m->setOffset( QgsSymbolLayerV2Utils::decodePoint( props["offset"] ) );
   if ( props.contains( "offset_unit" ) )
-    m->setOffsetUnit( QgsSymbolLayerV2Utils::decodeOutputUnit( props["offset_unit"] ) );
+    m->setOffsetUnit( QgsUnitTypes::decodeSymbolUnit( props["offset_unit"] ) );
   if ( props.contains( "offset_map_unit_scale" ) )
     m->setOffsetMapUnitScale( QgsSymbolLayerV2Utils::decodeMapUnitScale( props["offset_map_unit_scale"] ) );
   if ( props.contains( "fill" ) )
@@ -1234,11 +1235,11 @@ QgsSymbolLayerV2* QgsSvgMarkerSymbolLayerV2::create( const QgsStringMap& props )
 
   if ( props.contains( "outline_width_unit" ) )
   {
-    m->setOutlineWidthUnit( QgsSymbolLayerV2Utils::decodeOutputUnit( props["outline_width_unit"] ) );
+    m->setOutlineWidthUnit( QgsUnitTypes::decodeSymbolUnit( props["outline_width_unit"] ) );
   }
   else if ( props.contains( "line_width_unit" ) )
   {
-    m->setOutlineWidthUnit( QgsSymbolLayerV2Utils::decodeOutputUnit( props["line_width_unit"] ) );
+    m->setOutlineWidthUnit( QgsUnitTypes::decodeSymbolUnit( props["line_width_unit"] ) );
   }
   if ( props.contains( "outline_width_map_unit_scale" ) )
     m->setOutlineWidthMapUnitScale( QgsSymbolLayerV2Utils::decodeMapUnitScale( props["outline_width_map_unit_scale"] ) );
@@ -1516,17 +1517,17 @@ QgsStringMap QgsSvgMarkerSymbolLayerV2::properties() const
   QgsStringMap map;
   map["name"] = QgsSymbolLayerV2Utils::symbolPathToName( mPath );
   map["size"] = QString::number( mSize );
-  map["size_unit"] = QgsSymbolLayerV2Utils::encodeOutputUnit( mSizeUnit );
+  map["size_unit"] = QgsUnitTypes::encodeUnit( mSizeUnit );
   map["size_map_unit_scale"] = QgsSymbolLayerV2Utils::encodeMapUnitScale( mSizeMapUnitScale );
   map["angle"] = QString::number( mAngle );
   map["offset"] = QgsSymbolLayerV2Utils::encodePoint( mOffset );
-  map["offset_unit"] = QgsSymbolLayerV2Utils::encodeOutputUnit( mOffsetUnit );
+  map["offset_unit"] = QgsUnitTypes::encodeUnit( mOffsetUnit );
   map["offset_map_unit_scale"] = QgsSymbolLayerV2Utils::encodeMapUnitScale( mOffsetMapUnitScale );
   map["scale_method"] = QgsSymbolLayerV2Utils::encodeScaleMethod( mScaleMethod );
   map["color"] = QgsSymbolLayerV2Utils::encodeColor( mColor );
   map["outline_color"] = QgsSymbolLayerV2Utils::encodeColor( mOutlineColor );
   map["outline_width"] = QString::number( mOutlineWidth );
-  map["outline_width_unit"] = QgsSymbolLayerV2Utils::encodeOutputUnit( mOutlineWidthUnit );
+  map["outline_width_unit"] = QgsUnitTypes::encodeUnit( mOutlineWidthUnit );
   map["outline_width_map_unit_scale"] = QgsSymbolLayerV2Utils::encodeMapUnitScale( mOutlineWidthMapUnitScale );
   map["horizontal_anchor_point"] = QString::number( mHorizontalAnchorPoint );
   map["vertical_anchor_point"] = QString::number( mVerticalAnchorPoint );
@@ -1912,11 +1913,11 @@ QgsSymbolLayerV2* QgsFontMarkerSymbolLayerV2::create( const QgsStringMap& props
   if ( props.contains( "offset" ) )
     m->setOffset( QgsSymbolLayerV2Utils::decodePoint( props["offset"] ) );
   if ( props.contains( "offset_unit" ) )
-    m->setOffsetUnit( QgsSymbolLayerV2Utils::decodeOutputUnit( props["offset_unit" ] ) );
+    m->setOffsetUnit( QgsUnitTypes::decodeSymbolUnit( props["offset_unit" ] ) );
   if ( props.contains( "offset_map_unit_scale" ) )
     m->setOffsetMapUnitScale( QgsSymbolLayerV2Utils::decodeMapUnitScale( props["offset_map_unit_scale" ] ) );
   if ( props.contains( "size_unit" ) )
-    m->setSizeUnit( QgsSymbolLayerV2Utils::decodeOutputUnit( props["size_unit"] ) );
+    m->setSizeUnit( QgsUnitTypes::decodeSymbolUnit( props["size_unit"] ) );
   if ( props.contains( "size_map_unit_scale" ) )
     m->setSizeMapUnitScale( QgsSymbolLayerV2Utils::decodeMapUnitScale( props["size_map_unit_scale"] ) );
   if ( props.contains( "horizontal_anchor_point" ) )
@@ -2099,12 +2100,12 @@ QgsStringMap QgsFontMarkerSymbolLayerV2::properties() const
   props["font"] = mFontFamily;
   props["chr"] = mChr;
   props["size"] = QString::number( mSize );
-  props["size_unit"] = QgsSymbolLayerV2Utils::encodeOutputUnit( mSizeUnit );
+  props["size_unit"] = QgsUnitTypes::encodeUnit( mSizeUnit );
   props["size_map_unit_scale"] = QgsSymbolLayerV2Utils::encodeMapUnitScale( mSizeMapUnitScale );
   props["color"] = QgsSymbolLayerV2Utils::encodeColor( mColor );
   props["angle"] = QString::number( mAngle );
   props["offset"] = QgsSymbolLayerV2Utils::encodePoint( mOffset );
-  props["offset_unit"] = QgsSymbolLayerV2Utils::encodeOutputUnit( mOffsetUnit );
+  props["offset_unit"] = QgsUnitTypes::encodeUnit( mOffsetUnit );
   props["offset_map_unit_scale"] = QgsSymbolLayerV2Utils::encodeMapUnitScale( mOffsetMapUnitScale );
   props["horizontal_anchor_point"] = QString::number( mHorizontalAnchorPoint );
   props["vertical_anchor_point"] = QString::number( mVerticalAnchorPoint );
diff --git a/src/core/symbology-ng/qgspointdisplacementrenderer.cpp b/src/core/symbology-ng/qgspointdisplacementrenderer.cpp
index c900034d7202..3493a3f0d2de 100644
--- a/src/core/symbology-ng/qgspointdisplacementrenderer.cpp
+++ b/src/core/symbology-ng/qgspointdisplacementrenderer.cpp
@@ -28,6 +28,7 @@
 #include "qgsfontutils.h"
 #include "qgsmultipointv2.h"
 #include "qgspointv2.h"
+#include "qgsunittypes.h"
 
 #include <QDomElement>
 #include <QPainter>
@@ -368,7 +369,7 @@ QgsFeatureRendererV2* QgsPointDisplacementRenderer::create( QDomElement& symbolo
   r->setCircleRadiusAddition( symbologyElem.attribute( "circleRadiusAddition", "0.0" ).toDouble() );
   r->setMaxLabelScaleDenominator( symbologyElem.attribute( "maxLabelScaleDenominator", "-1" ).toDouble() );
   r->setTolerance( symbologyElem.attribute( "tolerance", "0.00001" ).toDouble() );
-  r->setToleranceUnit( QgsSymbolLayerV2Utils::decodeOutputUnit( symbologyElem.attribute( "toleranceUnit", "MapUnit" ) ) );
+  r->setToleranceUnit( QgsUnitTypes::decodeSymbolUnit( symbologyElem.attribute( "toleranceUnit", "MapUnit" ) ) );
   r->setToleranceMapUnitScale( QgsSymbolLayerV2Utils::decodeMapUnitScale( symbologyElem.attribute( "toleranceUnitScale" ) ) );
 
   //look for an embedded renderer <renderer-v2>
@@ -401,7 +402,7 @@ QDomElement QgsPointDisplacementRenderer::save( QDomDocument& doc )
   rendererElement.setAttribute( "placement", static_cast< int >( mPlacement ) );
   rendererElement.setAttribute( "maxLabelScaleDenominator", QString::number( mMaxLabelScaleDenominator ) );
   rendererElement.setAttribute( "tolerance", QString::number( mTolerance ) );
-  rendererElement.setAttribute( "toleranceUnit", QgsSymbolLayerV2Utils::encodeOutputUnit( mToleranceUnit ) );
+  rendererElement.setAttribute( "toleranceUnit", QgsUnitTypes::encodeUnit( mToleranceUnit ) );
   rendererElement.setAttribute( "toleranceUnitScale", QgsSymbolLayerV2Utils::encodeMapUnitScale( mToleranceMapUnitScale ) );
 
   if ( mRenderer )
diff --git a/src/core/symbology-ng/qgssymbollayerv2utils.cpp b/src/core/symbology-ng/qgssymbollayerv2utils.cpp
index 1c307bcfef95..d9f1c1bbdb0f 100644
--- a/src/core/symbology-ng/qgssymbollayerv2utils.cpp
+++ b/src/core/symbology-ng/qgssymbollayerv2utils.cpp
@@ -27,6 +27,7 @@
 #include "qgsogcutils.h"
 #include "qgslogger.h"
 #include "qgsrendercontext.h"
+#include "qgsunittypes.h"
 
 #include <QColor>
 #include <QFont>
@@ -407,42 +408,14 @@ QgsMapUnitScale QgsSymbolLayerV2Utils::decodeMapUnitScale( const QString& str )
 
 QString QgsSymbolLayerV2Utils::encodeOutputUnit( QgsSymbolV2::OutputUnit unit )
 {
-  switch ( unit )
-  {
-    case QgsSymbolV2::MM:
-      return "MM";
-    case QgsSymbolV2::MapUnit:
-      return "MapUnit";
-    case QgsSymbolV2::Pixel:
-      return "Pixel";
-    case QgsSymbolV2::Percentage:
-      return "Percentage";
-    default:
-      return "MM";
-  }
+  return QgsUnitTypes::encodeUnit( unit );
 }
 
 QgsSymbolV2::OutputUnit QgsSymbolLayerV2Utils::decodeOutputUnit( const QString& str )
 {
-  if ( str == "MM" )
-  {
-    return QgsSymbolV2::MM;
-  }
-  else if ( str == "MapUnit" )
-  {
-    return QgsSymbolV2::MapUnit;
-  }
-  else if ( str == "Pixel" )
-  {
-    return QgsSymbolV2::Pixel;
-  }
-  else if ( str == "Percentage" )
-  {
-    return QgsSymbolV2::Percentage;
-  }
-
-  // millimeters are default
-  return QgsSymbolV2::MM;
+  bool ok = false;
+  QgsSymbolV2::OutputUnit unit = QgsUnitTypes::decodeSymbolUnit( str, &ok );
+  return ok ? unit : QgsSymbolV2::MM;
 }
 
 QString QgsSymbolLayerV2Utils::encodeSldUom( QgsSymbolV2::OutputUnit unit, double *scaleFactor )
@@ -1008,7 +981,7 @@ QgsSymbolV2* QgsSymbolLayerV2Utils::loadSymbol( const QDomElement &element )
 
   if ( element.hasAttribute( "outputUnit" ) )
   {
-    symbol->setOutputUnit( decodeOutputUnit( element.attribute( "outputUnit" ) ) );
+    symbol->setOutputUnit( QgsUnitTypes::decodeSymbolUnit( element.attribute( "outputUnit" ) ) );
   }
   if ( element.hasAttribute(( "mapUnitScale" ) ) )
   {
diff --git a/src/core/symbology-ng/qgssymbollayerv2utils.h b/src/core/symbology-ng/qgssymbollayerv2utils.h
index 66845336ba64..3f1bc4665543 100644
--- a/src/core/symbology-ng/qgssymbollayerv2utils.h
+++ b/src/core/symbology-ng/qgssymbollayerv2utils.h
@@ -91,8 +91,10 @@ class CORE_EXPORT QgsSymbolLayerV2Utils
     static QString encodeSldRealVector( const QVector<qreal>& v );
     static QVector<qreal> decodeSldRealVector( const QString& s );
 
-    static QString encodeOutputUnit( QgsSymbolV2::OutputUnit unit );
-    static QgsSymbolV2::OutputUnit decodeOutputUnit( const QString& str );
+    //! @deprecated use QgsUnitTypes::encodeUnit() instead
+    Q_DECL_DEPRECATED static QString encodeOutputUnit( QgsSymbolV2::OutputUnit unit );
+    //! @deprecated use QgsUnitTypes::decodeSymbolUnit() instead
+    Q_DECL_DEPRECATED static QgsSymbolV2::OutputUnit decodeOutputUnit( const QString& str );
 
     static QString encodeSldUom( QgsSymbolV2::OutputUnit unit, double *scaleFactor );
     static QgsSymbolV2::OutputUnit decodeSldUom( const QString& str, double *scaleFactor );
diff --git a/src/core/symbology-ng/qgssymbolv2.h b/src/core/symbology-ng/qgssymbolv2.h
index ac1966a2f757..761b1ae45ce3 100644
--- a/src/core/symbology-ng/qgssymbolv2.h
+++ b/src/core/symbology-ng/qgssymbolv2.h
@@ -55,6 +55,7 @@ class CORE_EXPORT QgsSymbolV2
     /**
      * The unit of the output
      */
+    //TODO QGIS 3.0 - move to QgsUnitTypes and rename to SymbolUnit
     enum OutputUnit
     {
       MM = 0,     //!< The output shall be in millimeters
diff --git a/src/core/symbology-ng/qgsvectorfieldsymbollayer.cpp b/src/core/symbology-ng/qgsvectorfieldsymbollayer.cpp
index fcb076e8f4c0..221d5e3f36ab 100644
--- a/src/core/symbology-ng/qgsvectorfieldsymbollayer.cpp
+++ b/src/core/symbology-ng/qgsvectorfieldsymbollayer.cpp
@@ -17,6 +17,7 @@
 
 #include "qgsvectorfieldsymbollayer.h"
 #include "qgsvectorlayer.h"
+#include "qgsunittypes.h"
 
 QgsVectorFieldSymbolLayer::QgsVectorFieldSymbolLayer()
     : mXAttribute( "" )
@@ -81,7 +82,7 @@ QgsSymbolLayerV2* QgsVectorFieldSymbolLayer::create( const QgsStringMap& propert
   }
   if ( properties.contains( "distance_unit" ) )
   {
-    symbolLayer->setDistanceUnit( QgsSymbolLayerV2Utils::decodeOutputUnit( properties["distance_unit"] ) );
+    symbolLayer->setDistanceUnit( QgsUnitTypes::decodeSymbolUnit( properties["distance_unit"] ) );
   }
   if ( properties.contains( "distance_map_unit_scale" ) )
   {
@@ -109,7 +110,7 @@ QgsSymbolLayerV2* QgsVectorFieldSymbolLayer::create( const QgsStringMap& propert
   }
   if ( properties.contains( "size_unit" ) )
   {
-    symbolLayer->setSizeUnit( QgsSymbolLayerV2Utils::decodeOutputUnit( properties["size_unit"] ) );
+    symbolLayer->setSizeUnit( QgsUnitTypes::decodeSymbolUnit( properties["size_unit"] ) );
   }
   if ( properties.contains( "size_map_unit_scale" ) )
   {
@@ -121,7 +122,7 @@ QgsSymbolLayerV2* QgsVectorFieldSymbolLayer::create( const QgsStringMap& propert
   }
   if ( properties.contains( "offset_unit" ) )
   {
-    symbolLayer->setOffsetUnit( QgsSymbolLayerV2Utils::decodeOutputUnit( properties["offset_unit"] ) );
+    symbolLayer->setOffsetUnit( QgsUnitTypes::decodeSymbolUnit( properties["offset_unit"] ) );
   }
   if ( properties.contains( "offset_map_unit_scale" ) )
   {
@@ -245,17 +246,17 @@ QgsStringMap QgsVectorFieldSymbolLayer::properties() const
   QgsStringMap properties;
   properties["x_attribute"] = mXAttribute;
   properties["y_attribute"] = mYAttribute;
-  properties["distance_unit"] = QgsSymbolLayerV2Utils::encodeOutputUnit( mDistanceUnit );
+  properties["distance_unit"] = QgsUnitTypes::encodeUnit( mDistanceUnit );
   properties["distance_map_unit_scale"] = QgsSymbolLayerV2Utils::encodeMapUnitScale( mDistanceMapUnitScale );
   properties["scale"] = QString::number( mScale );
   properties["vector_field_type"] = QString::number( mVectorFieldType );
   properties["angle_orientation"] = QString::number( mAngleOrientation );
   properties["angle_units"] = QString::number( mAngleUnits );
   properties["size"] = QString::number( mSize );
-  properties["size_unit"] = QgsSymbolLayerV2Utils::encodeOutputUnit( mSizeUnit );
+  properties["size_unit"] = QgsUnitTypes::encodeUnit( mSizeUnit );
   properties["size_map_unit_scale"] = QgsSymbolLayerV2Utils::encodeMapUnitScale( mSizeMapUnitScale );
   properties["offset"] = QgsSymbolLayerV2Utils::encodePoint( mOffset );
-  properties["offset_unit"] = QgsSymbolLayerV2Utils::encodeOutputUnit( mOffsetUnit );
+  properties["offset_unit"] = QgsUnitTypes::encodeUnit( mOffsetUnit );
   properties["offset_map_unit_scale"] = QgsSymbolLayerV2Utils::encodeMapUnitScale( mOffsetMapUnitScale );
   return properties;
 }
diff --git a/src/providers/wms/qgswmscapabilities.cpp b/src/providers/wms/qgswmscapabilities.cpp
index 01e8eb259425..8c091779c53d 100644
--- a/src/providers/wms/qgswmscapabilities.cpp
+++ b/src/providers/wms/qgswmscapabilities.cpp
@@ -12,6 +12,7 @@
 #include "qgslogger.h"
 #include "qgsmessagelog.h"
 #include "qgsnetworkaccessmanager.h"
+#include "qgsunittypes.h"
 
 
 // %%% copied from qgswmsprovider.cpp
@@ -1292,7 +1293,7 @@ void QgsWmsCapabilities::parseWMTSContents( QDomElement const &e )
 
     s.wkScaleSet = e0.firstChildElement( "WellKnownScaleSet" ).text();
 
-    double metersPerUnit = QGis::fromUnitToUnitFactor( crs.mapUnits(), QGis::Meters );
+    double metersPerUnit = QgsUnitTypes::fromUnitToUnitFactor( crs.mapUnits(), QGis::Meters );
 
     s.crs = crs.authid();
 
@@ -1799,7 +1800,7 @@ bool QgsWmsCapabilities::detectTileLayerBoundingBox( QgsWmtsTileLayer& l )
     return false;
 
   const QgsWmtsTileMatrix& tm = *tmIt;
-  double metersPerUnit = QGis::fromUnitToUnitFactor( crs.mapUnits(), QGis::Meters );
+  double metersPerUnit = QgsUnitTypes::fromUnitToUnitFactor( crs.mapUnits(), QGis::Meters );
   double res = tm.scaleDenom * 0.00028 / metersPerUnit;
   QgsPoint bottomRight( tm.topLeft.x() + res * tm.tileWidth * tm.matrixWidth,
                         tm.topLeft.y() - res * tm.tileHeight * tm.matrixHeight );
diff --git a/tests/src/python/CMakeLists.txt b/tests/src/python/CMakeLists.txt
index c5ca88ba5368..4eb1a5215102 100644
--- a/tests/src/python/CMakeLists.txt
+++ b/tests/src/python/CMakeLists.txt
@@ -62,6 +62,7 @@ ADD_PYTHON_TEST(PyQgsSymbolLayerV2 test_qgssymbollayerv2.py)
 ADD_PYTHON_TEST(PyQgsSymbolExpressionVariables test_qgssymbolexpressionvariables.py)
 ADD_PYTHON_TEST(PyQgsSyntacticSugar test_syntactic_sugar.py)
 ADD_PYTHON_TEST(PyQgsSymbolV2 test_qgssymbolv2.py)
+ADD_PYTHON_TEST(PyQgsUnitTypes test_qgsunittypes.py)
 ADD_PYTHON_TEST(PyQgsVectorColorRamp test_qgsvectorcolorramp.py)
 ADD_PYTHON_TEST(PyQgsVectorFileWriter test_qgsvectorfilewriter.py)
 ADD_PYTHON_TEST(PyQgsVectorLayer test_qgsvectorlayer.py)
diff --git a/tests/src/python/test_qgsunittypes.py b/tests/src/python/test_qgsunittypes.py
new file mode 100644
index 000000000000..726968ec6768
--- /dev/null
+++ b/tests/src/python/test_qgsunittypes.py
@@ -0,0 +1,141 @@
+# -*- coding: utf-8 -*-
+"""QGIS Unit tests for QgsUnitTypes
+
+.. note:: This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+"""
+__author__ = 'Nyall Dawson'
+__date__ = '03.02.2016'
+__copyright__ = 'Copyright 2016, The QGIS Project'
+# This will get replaced with a git SHA1 when you do a git archive
+__revision__ = '$Format:%H$'
+
+import qgis
+
+from utilities import (unittest,
+                       TestCase,
+                       getQgisTestApp
+                       )
+from qgis.core import (QgsUnitTypes,
+                       QGis,
+                       QgsSymbolV2
+                       )
+
+getQgisTestApp()
+
+
+class TestQgsUnitTypes(TestCase):
+
+    def testDistanceUnitType(self):
+        """Test QgsUnitTypes::unitType() """
+        expected = {QGis.Meters: QgsUnitTypes.Standard,
+                    QGis.Feet: QgsUnitTypes.Standard,
+                    QGis.Degrees: QgsUnitTypes.Geographic,
+                    QGis.UnknownUnit: QgsUnitTypes.UnknownType,
+                    QGis.NauticalMiles: QgsUnitTypes.Standard
+                    }
+
+        for t in expected.keys():
+            self.assertEqual(QgsUnitTypes.unitType(t), expected[t])
+
+    def testEncodeDecodeDistanceUnits(self):
+        """Test encoding and decoding distance units"""
+        units = [QGis.Meters,
+                 QGis.Feet,
+                 QGis.Degrees,
+                 QGis.UnknownUnit,
+                 QGis.NauticalMiles]
+
+        for u in units:
+            res, ok = QgsUnitTypes.decodeDistanceUnit(QgsUnitTypes.encodeUnit(u))
+            assert ok
+            self.assertEqual(res, u)
+
+        # Test decoding bad units
+        res, ok = QgsUnitTypes.decodeDistanceUnit('bad')
+        self.assertFalse(ok)
+        self.assertEqual(res, QGis.UnknownUnit)
+
+        # Test that string is cleaned before decoding
+        res, ok = QgsUnitTypes.decodeDistanceUnit(' FeEt  ')
+        assert ok
+        self.assertEqual(res, QGis.Feet)
+
+    def testDistanceUnitsToFromString(self):
+        """Test converting distance units to and from translated strings"""
+        units = [QGis.Meters,
+                 QGis.Feet,
+                 QGis.Degrees,
+                 QGis.UnknownUnit,
+                 QGis.NauticalMiles]
+
+        for u in units:
+            res, ok = QgsUnitTypes.stringToDistanceUnit(QgsUnitTypes.toString(u))
+            assert ok
+            self.assertEqual(res, u)
+
+        # Test converting bad strings
+        res, ok = QgsUnitTypes.stringToDistanceUnit('bad')
+        self.assertFalse(ok)
+        self.assertEqual(res, QGis.UnknownUnit)
+
+        # Test that string is cleaned before conversion
+        res, ok = QgsUnitTypes.decodeDistanceUnit(' {}  '.format(QgsUnitTypes.toString(QGis.Feet).upper()))
+        print ' {}  '.format(QgsUnitTypes.toString(QGis.Feet).upper())
+        assert ok
+        self.assertEqual(res, QGis.Feet)
+
+    def testEncodeDecodeSymbolUnits(self):
+        """Test encoding and decoding symbol units"""
+        units = [QgsSymbolV2.MM,
+                 QgsSymbolV2.MapUnit,
+                 QgsSymbolV2.Pixel,
+                 QgsSymbolV2.Percentage]
+
+        for u in units:
+            res, ok = QgsUnitTypes.decodeSymbolUnit(QgsUnitTypes.encodeUnit(u))
+            assert ok
+            self.assertEqual(res, u)
+
+        # Test decoding bad units
+        res, ok = QgsUnitTypes.decodeSymbolUnit('bad')
+        self.assertFalse(ok)
+        # default units should be MM
+        self.assertEqual(res, QgsSymbolV2.MM)
+
+        # Test that string is cleaned before decoding
+        res, ok = QgsUnitTypes.decodeSymbolUnit(' PiXeL  ')
+        assert ok
+        self.assertEqual(res, QgsSymbolV2.Pixel)
+
+    def testFromUnitToUnitFactor(self):
+        """Test calculation of conversion factor between units"""
+
+        expected = {QGis.Meters: {QGis.Meters: 1.0, QGis.Feet: 3.28083989501, QGis.Degrees: 0.00000898315, QGis.NauticalMiles: 0.000539957},
+                    QGis.Feet: {QGis.Meters: 0.3048, QGis.Feet: 1.0, QGis.Degrees: 2.73806498599629E-06, QGis.NauticalMiles: 0.000164579},
+                    QGis.Degrees: {QGis.Meters: 111319.49079327358, QGis.Feet: 365221.4264871, QGis.Degrees: 1.0, QGis.NauticalMiles: 60.1077164},
+                    QGis.NauticalMiles: {QGis.Meters: 1852.0, QGis.Feet: 6076.1154856, QGis.Degrees: 0.0166367990650, QGis.NauticalMiles: 1.0},
+                    QGis.UnknownUnit: {QGis.Meters: 1.0, QGis.Feet: 1.0, QGis.Degrees: 1.0, QGis.NauticalMiles: 1.0}
+                    }
+
+        for from_unit in expected.keys():
+            for to_unit in expected[from_unit].keys():
+                expected_factor = expected[from_unit][to_unit]
+                res = QgsUnitTypes.fromUnitToUnitFactor(from_unit, to_unit)
+                self.assertAlmostEqual(res,
+                                       expected_factor,
+                                       msg='got {:.7f}, expected {:.7f} when converting from {} to {}'.format(res, expected_factor,
+                                                                                                              QgsUnitTypes.toString(from_unit),
+                                                                                                              QgsUnitTypes.toString(to_unit)))
+                #test conversion to unknown units
+                res = QgsUnitTypes.fromUnitToUnitFactor(from_unit, QGis.UnknownUnit)
+                self.assertAlmostEqual(res,
+                                       1.0,
+                                       msg='got {:.7f}, expected 1.0 when converting from {} to unknown units'.format(res, expected_factor,
+                                                                                                                      QgsUnitTypes.toString(from_unit)))
+
+
+if __name__ == "__main__":
+    unittest.main()