diff --git a/.github/workflows/linux.yml b/.github/workflows/linux.yml
index 54a45f949c..fd4681f5e6 100644
--- a/.github/workflows/linux.yml
+++ b/.github/workflows/linux.yml
@@ -98,6 +98,7 @@ jobs:
         with:
           build_dir: "build"
           lgtm_comment_body: ''
+          exclude: 'cppcoreguidelines-avoid-magic-numbers,bugprone-easily-swappable-parameters,misc-non-private-member-variables-in-classes,cppcoreguidelines-macro-usage'
 
       - name: Package
         run: |
diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt
index 3fb9d908c5..0da1545fb9 100644
--- a/src/core/CMakeLists.txt
+++ b/src/core/CMakeLists.txt
@@ -45,6 +45,8 @@ set(QFIELD_CORE_SRCS
     deltalistmodel.cpp
     digitizinglogger.cpp
     distancearea.cpp
+    drawingcanvas.cpp
+    drawingtemplatemodel.cpp
     expressionevaluator.cpp
     expressionvariablemodel.cpp
     featurechecklistmodel.cpp
@@ -152,6 +154,8 @@ set(QFIELD_CORE_HDRS
     deltalistmodel.h
     digitizinglogger.h
     distancearea.h
+    drawingcanvas.h
+    drawingtemplatemodel.h
     expressionevaluator.h
     expressionvariablemodel.h
     featurechecklistmodel.h
diff --git a/src/core/drawingcanvas.cpp b/src/core/drawingcanvas.cpp
new file mode 100644
index 0000000000..7a8074cdf9
--- /dev/null
+++ b/src/core/drawingcanvas.cpp
@@ -0,0 +1,327 @@
+/***************************************************************************
+ drawingcanvas.cpp - DrawingCanvas
+
+ ---------------------
+ begin                : 24.03.2024
+ copyright            : (C) 2024 by Mathieu Pellerin
+ email                : mathieu (at) opengis.ch
+ ***************************************************************************
+ *                                                                         *
+ *   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 "drawingcanvas.h"
+
+#include <QPainter>
+#include <QPainterPath>
+#include <QStandardPaths>
+
+#include <cmath>
+
+DrawingCanvas::DrawingCanvas( QQuickItem *parent )
+  : QQuickPaintedItem( parent )
+{
+  setOpaquePainting( true );
+}
+
+void DrawingCanvas::createBlankCanvas( int width, int height, QColor backgroundColor )
+{
+  mBackgroundImage = QImage( QSize( width, height ), QImage::Format_ARGB32 );
+  mBackgroundImage.fill( backgroundColor );
+
+  mDrawingImage = QImage( QSize( width, height ), QImage::Format_ARGB32 );
+  mDrawingImage.fill( Qt::transparent );
+
+  setIsEmpty( false );
+  setIsDirty( false );
+  fitCanvas();
+}
+
+void DrawingCanvas::createCanvasFromImage( const QString &path )
+{
+  mBackgroundImage = QImage( path.startsWith( QStringLiteral( "file://" ) ) ? path.mid( 7 ) : path );
+
+  if ( !mBackgroundImage.isNull() )
+  {
+    if ( mBackgroundImage.format() != QImage::Format_ARGB32 )
+    {
+      mBackgroundImage.convertTo( QImage::Format_ARGB32 );
+    }
+
+    mDrawingImage = QImage( mBackgroundImage.size(), QImage::Format_ARGB32 );
+    mDrawingImage.fill( Qt::transparent );
+    setIsEmpty( false );
+  }
+  else
+  {
+    mDrawingImage = QImage();
+    setIsEmpty( false );
+  }
+
+  setIsDirty( false );
+  fitCanvas();
+}
+
+void DrawingCanvas::clear()
+{
+  mBackgroundImage = QImage();
+  mDrawingImage = QImage();
+
+  setZoomFactor( 1.0 );
+  setOffset( QPointF( 0, 0 ) );
+  setIsDirty( false );
+  setIsEmpty( true );
+
+  update();
+}
+
+QString DrawingCanvas::save() const
+{
+  QImage image( mBackgroundImage.size(), QImage::Format_ARGB32 );
+  image.fill( Qt::transparent );
+
+  QPainter painter( &image );
+  painter.drawImage( 0, 0, mBackgroundImage );
+  painter.drawImage( 0, 0, mDrawingImage );
+
+  QString path = QStandardPaths::writableLocation( QStandardPaths::TempLocation ) + "/sketch.png";
+  image.save( path );
+
+  return path;
+}
+
+void DrawingCanvas::fitCanvas()
+{
+  double scale = 1.0;
+  if ( !mBackgroundImage.isNull() )
+  {
+    const QSizeF itemSize( size().width() - 30, size().height() - 100 );
+    const QSizeF backgroundImageSize = mBackgroundImage.size();
+    if ( backgroundImageSize.width() > itemSize.width() )
+    {
+      scale = itemSize.width() / backgroundImageSize.width();
+    }
+    if ( backgroundImageSize.height() * scale > itemSize.height() )
+    {
+      scale = itemSize.height() / backgroundImageSize.height();
+    }
+  }
+
+  mZoomFactor = scale;
+  emit zoomFactorChanged();
+
+  mOffset = QPoint( 0, 0 );
+  emit offsetChanged();
+
+  update();
+}
+
+void DrawingCanvas::pan( const QPointF &oldPosition, const QPointF &newPosition )
+{
+  setOffset( QPointF( mOffset.x() + ( newPosition.x() - oldPosition.x() ),
+                      mOffset.y() + ( newPosition.y() - oldPosition.y() ) ) );
+}
+
+void DrawingCanvas::zoom( double scale )
+{
+  setZoomFactor( mZoomFactor * scale );
+}
+
+bool DrawingCanvas::isEmpty() const
+{
+  return mIsEmpty;
+}
+
+void DrawingCanvas::setIsEmpty( bool empty )
+{
+  if ( mIsEmpty == empty )
+  {
+    return;
+  }
+
+  mIsEmpty = empty;
+  emit isEmptyChanged();
+}
+
+bool DrawingCanvas::isDirty() const
+{
+  return mIsDirty;
+}
+
+void DrawingCanvas::setIsDirty( bool dirty )
+{
+  if ( mIsDirty == dirty )
+  {
+    return;
+  }
+
+  mIsDirty = dirty;
+  emit isDirtyChanged();
+}
+
+QColor DrawingCanvas::frameColor() const
+{
+  return mFrameColor;
+}
+
+void DrawingCanvas::setFrameColor( const QColor &color )
+{
+  if ( mFrameColor == color )
+  {
+    return;
+  }
+
+  mFrameColor = color;
+  emit frameColorChanged();
+
+  update();
+}
+
+double DrawingCanvas::zoomFactor() const
+{
+  return mZoomFactor;
+}
+
+void DrawingCanvas::setZoomFactor( double factor )
+{
+  if ( mZoomFactor == factor )
+  {
+    return;
+  }
+
+  mZoomFactor = factor;
+  emit zoomFactorChanged();
+
+  update();
+}
+
+QPointF DrawingCanvas::offset() const
+{
+  return mOffset;
+}
+
+void DrawingCanvas::setOffset( const QPointF &offset )
+{
+  if ( mOffset == offset )
+  {
+    return;
+  }
+
+  mOffset = offset;
+  emit offsetChanged();
+
+  update();
+}
+
+void DrawingCanvas::strokeBegin( const QPointF &point, const QColor color )
+{
+  mCurrentStroke.points.clear();
+  mCurrentStroke.color = color;
+  mCurrentStroke.width = DEFAULT_STROKE_WIDTH / mZoomFactor;
+  mCurrentStroke.points << itemToCanvas( point );
+}
+
+void DrawingCanvas::strokeMove( const QPointF &point )
+{
+  if ( mCurrentStroke.points.isEmpty() )
+  {
+    return;
+  }
+
+  const QPointF lastPoint = canvasToItem( mCurrentStroke.points.last() );
+  if ( std::pow( point.x() - lastPoint.x(), 2 ) + std::pow( point.y() - lastPoint.y(), 2 ) >= 0.1 )
+  {
+    mCurrentStroke.points << itemToCanvas( point );
+
+    update();
+  }
+}
+
+void DrawingCanvas::strokeEnd( const QPointF &point )
+{
+  if ( mCurrentStroke.points.isEmpty() )
+  {
+    return;
+  }
+
+  mCurrentStroke.points << itemToCanvas( point );
+
+  QPainter painter( &mDrawingImage );
+  painter.setRenderHint( QPainter::Antialiasing, true );
+  drawStroke( &painter, mCurrentStroke );
+
+  mCurrentStroke.points.clear();
+
+  setIsDirty( true );
+  update();
+}
+
+void DrawingCanvas::drawStroke( QPainter *painter, Stroke &stroke, bool onCanvas )
+{
+  QPainterPath path( onCanvas ? stroke.points.at( 0 ) : canvasToItem( stroke.points.at( 0 ) ) );
+  for ( int i = 1; i < stroke.points.size(); i++ )
+  {
+    path.lineTo( onCanvas ? stroke.points.at( i ) : canvasToItem( stroke.points.at( i ) ) );
+  }
+
+  QPen pen( stroke.color );
+  pen.setWidthF( onCanvas ? stroke.width : stroke.width * mZoomFactor );
+  painter->setPen( pen );
+  QBrush brush( stroke.fillColor );
+  painter->setBrush( brush );
+  painter->drawPath( path );
+}
+
+QPointF DrawingCanvas::itemToCanvas( const QPointF &point )
+{
+  const QPointF canvasTopLeft( size().width() / 2 - ( mBackgroundImage.size().width() * mZoomFactor / 2 ) + mOffset.x(),
+                               size().height() / 2 - ( mBackgroundImage.size().height() * mZoomFactor / 2 ) + mOffset.y() );
+  return QPointF( ( point.x() - canvasTopLeft.x() ) / mZoomFactor,
+                  ( point.y() - canvasTopLeft.y() ) / mZoomFactor );
+}
+
+QPointF DrawingCanvas::canvasToItem( const QPointF &point )
+{
+  const QPointF canvasTopLeft( size().width() / 2 - ( mBackgroundImage.size().width() * mZoomFactor / 2 ) + mOffset.x(),
+                               size().height() / 2 - ( mBackgroundImage.size().height() * mZoomFactor / 2 ) + mOffset.y() );
+  return QPointF( canvasTopLeft.x() + ( point.x() * mZoomFactor ),
+                  canvasTopLeft.y() + ( point.y() * mZoomFactor ) );
+}
+
+void DrawingCanvas::paint( QPainter *painter )
+{
+  if ( !mBackgroundImage.isNull() )
+  {
+    painter->setRenderHint( QPainter::Antialiasing, true );
+    painter->setRenderHint( QPainter::SmoothPixmapTransform, true );
+
+    const QSizeF scaledImageSize = mBackgroundImage.size() * mZoomFactor;
+    const QRectF imageRect( ( size().width() / 2 - scaledImageSize.width() / 2 ) + mOffset.x(),
+                            ( size().height() / 2 - scaledImageSize.height() / 2 ) + mOffset.y(),
+                            scaledImageSize.width(),
+                            scaledImageSize.height() );
+
+    QColor shadowColor = mFrameColor;
+    shadowColor.setAlphaF( shadowColor.alphaF() / 2 );
+
+    painter->setPen( Qt::NoPen );
+    painter->setBrush( QBrush( shadowColor ) );
+    painter->drawRect( imageRect.translated( 3, 3 ) );
+
+    painter->drawImage( imageRect, mBackgroundImage );
+    painter->drawImage( imageRect, mDrawingImage );
+
+    if ( mCurrentStroke.points.size() > 1 )
+    {
+      drawStroke( painter, mCurrentStroke, false );
+    }
+
+    painter->setPen( QPen( mFrameColor ) );
+    painter->setBrush( Qt::NoBrush );
+    painter->drawRect( imageRect );
+  }
+}
diff --git a/src/core/drawingcanvas.h b/src/core/drawingcanvas.h
new file mode 100644
index 0000000000..ff24ec591d
--- /dev/null
+++ b/src/core/drawingcanvas.h
@@ -0,0 +1,189 @@
+/***************************************************************************
+ drawingcanvas.h - DrawingCanvas
+
+ ---------------------
+ begin                : 24.03.2024
+ copyright            : (C) 2024 by Mathieu Pellerin
+ email                : mathieu (at) opengis.ch
+ ***************************************************************************
+ *                                                                         *
+ *   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 DRAWINGCANVAS_H
+#define DRAWINGCANVAS_H
+
+#include <QImage>
+#include <QObject>
+#include <QQuickPaintedItem>
+
+#define DEFAULT_STROKE_WIDTH 5
+
+class DrawingCanvas : public QQuickPaintedItem
+{
+    Q_OBJECT
+
+    /**
+     * This property is set to TRUE when no canvas has been created or a previously
+     * created canvas has been cleared.
+     */
+    Q_PROPERTY( bool isEmpty READ isEmpty NOTIFY isEmptyChanged )
+
+    /**
+     * This property is set to TRUE when a created canvas has been modified.
+     */
+    Q_PROPERTY( bool isDirty READ isDirty NOTIFY isDirtyChanged )
+
+    /**
+     * This property holds the color of the canvas frame.
+     */
+    Q_PROPERTY( QColor frameColor READ frameColor WRITE setFrameColor NOTIFY frameColorChanged )
+
+    /**
+     * This property holds the current zoom factor of the canvas. A value of 1.0 means the canvas
+     * is at native resolutio (i.e. one screen pixel represents one canvas pixel).
+     */
+    Q_PROPERTY( double zoomFactor READ zoomFactor WRITE setZoomFactor NOTIFY zoomFactorChanged )
+
+    /**
+     * This property holds the offset from the center of the canvas as a result of
+     * panning operations.
+     */
+    Q_PROPERTY( QPointF offset READ offset WRITE setOffset NOTIFY offsetChanged )
+
+  public:
+    DrawingCanvas( QQuickItem *parent = nullptr );
+    ~DrawingCanvas() = default;
+
+    void paint( QPainter *painter ) override;
+
+    //! \copydoc DrawingCanvas::isEmpty
+    bool isEmpty() const;
+
+    //! \copydoc DrawingCanvas::isEmpty
+    void setIsEmpty( bool empty );
+
+    //! \copydoc DrawingCanvas::isDirty
+    bool isDirty() const;
+
+    //! \copydoc DrawingCanvas::isDirty
+    void setIsDirty( bool dirty );
+
+    //! \copydoc DrawingCanvas::frameColor
+    QColor frameColor() const;
+
+    //! \copydoc DrawingCanvas::frameColor
+    void setFrameColor( const QColor &color );
+
+    //! \copydoc DrawingCanvas::zoomFactor
+    double zoomFactor() const;
+
+    //! \copydoc DrawingCanvas::zoomFactor
+    void setZoomFactor( double factor );
+
+    //! \copydoc DrawingCanvas::offset
+    QPointF offset() const;
+
+    //! \copydoc DrawingCanvas::offset
+    void setOffset( const QPointF &offset );
+
+    /**
+     * Creates a blank drawing canvas.
+     * \param width the width of the canvas.
+     * \param height the height of the canvas.
+     * \param backgroundColor the background color of the canvas.
+     */
+    Q_INVOKABLE void createBlankCanvas( int width, int height, QColor backgroundColor = QColor( 255, 255, 255 ) );
+
+    /**
+     * Creates a drawing canvas from a given image which will be the background on which
+     * the drawing will be overlayed.
+     * \param path the image path.
+     */
+    Q_INVOKABLE void createCanvasFromImage( const QString &path );
+
+    /**
+     * Clears the drawing canvas.
+     * \see isEmpty()
+     */
+    Q_INVOKABLE void clear();
+
+    /**
+     * Saves the drawing canvas to a temporary location.
+     * \returns the temporary file path of the saved image.
+     */
+    Q_INVOKABLE QString save() const;
+
+    /**
+     * Fits the drawing canvas to match available width and height.
+     */
+    Q_INVOKABLE void fitCanvas();
+
+    /**
+     * Pans the drawing canvas by the distance between two points.
+     */
+    Q_INVOKABLE void pan( const QPointF &oldPosition, const QPointF &newPosition );
+
+    /**
+     * Zooms the drawing canvas by the provided \a scale value.
+     */
+    Q_INVOKABLE void zoom( double scale );
+
+    /**
+     * Begins a stroke operation.
+     * \param point the first point of the stroke
+     * \param color the color of the stroke
+     */
+    Q_INVOKABLE void strokeBegin( const QPointF &point, const QColor color = QColor( 0, 0, 0 ) );
+
+    /**
+     * Adds a new \a point to the current stroke path.
+     * \note The function strokeBegin must have been called prior to this function.
+     */
+    Q_INVOKABLE void strokeMove( const QPointF &point );
+
+    /**
+     * Ends the current stroke with a final \a point added to the stroke path.
+     * \note The function strokeBegin must have been called prior to this function.
+     */
+    Q_INVOKABLE void strokeEnd( const QPointF &point );
+
+  signals:
+    void isEmptyChanged();
+    void isDirtyChanged();
+    void frameColorChanged();
+    void zoomFactorChanged();
+    void offsetChanged();
+
+  private:
+    struct Stroke
+    {
+        double width = 5.0;
+        QColor color = QColor( 0, 0, 0 );
+        QColor fillColor = QColor( Qt::transparent );
+        QList<QPointF> points;
+    };
+
+    void drawStroke( QPainter *painter, Stroke &stroke, bool onCanvas = true );
+
+    QPointF itemToCanvas( const QPointF &point );
+    QPointF canvasToItem( const QPointF &point );
+
+    bool mIsEmpty = true;
+    bool mIsDirty = false;
+
+    QColor mFrameColor;
+    double mZoomFactor = 1.0;
+    QPointF mOffset = QPointF( 0, 0 );
+
+    QImage mBackgroundImage;
+    QImage mDrawingImage;
+
+    Stroke mCurrentStroke;
+};
+
+#endif // DRAWINGCANVAS_H
diff --git a/src/core/drawingtemplatemodel.cpp b/src/core/drawingtemplatemodel.cpp
new file mode 100644
index 0000000000..6b09232dc4
--- /dev/null
+++ b/src/core/drawingtemplatemodel.cpp
@@ -0,0 +1,154 @@
+/***************************************************************************
+  drawingtemplatemodel.cpp
+
+ ---------------------
+ begin                : 28.03.2024
+ copyright            : (C) 2024 by Mathieu Pellerin
+ email                : mathieu at opengis dot ch
+ ***************************************************************************
+ *                                                                         *
+ *   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 "drawingtemplatemodel.h"
+#include "fileutils.h"
+#include "platformutilities.h"
+
+#include <QDir>
+#include <QFile>
+
+DrawingTemplateModel::DrawingTemplateModel( QObject *parent )
+  : QAbstractListModel( parent )
+{
+  reloadModel();
+}
+
+QHash<int, QByteArray> DrawingTemplateModel::roleNames() const
+{
+  QHash<int, QByteArray> roles = QAbstractListModel::roleNames();
+  roles[TemplateTypeRole] = "templateType";
+  roles[TemplateTitleRole] = "templateTitle";
+  roles[TemplatePathRole] = "templatePath";
+
+  return roles;
+}
+
+void DrawingTemplateModel::reloadModel()
+{
+  beginResetModel();
+  mTemplates.clear();
+
+  QStringList dirs;
+  bool hasProjectTemplate = false;
+  QString projectPath;
+
+  // Project templates
+  if ( !mProjectFilePath.isEmpty() )
+  {
+    QFileInfo projectInfo( mProjectFilePath );
+    projectPath = projectInfo.absolutePath() + QStringLiteral( "/" );
+    dirs << projectPath;
+  }
+
+  // App-wide templates
+  dirs << PlatformUtilities::instance()->appDataDirs();
+  for ( const QString &dir : dirs )
+  {
+    QDir templateDir( dir + QStringLiteral( "drawing_templates/" ) );
+    if ( templateDir.exists() )
+    {
+      const QStringList templates = templateDir.entryList( QStringList() << "*.*", QDir::Files );
+      for ( const QString &templateFile : templates )
+      {
+        const QFileInfo templateInfo( dir + QStringLiteral( "drawing_templates/" ) + templateFile );
+        if ( FileUtils::isImageMimeTypeSupported( FileUtils::mimeTypeName( templateInfo.absoluteFilePath() ) ) )
+        {
+          const TemplateType type = !projectPath.isEmpty() && templateDir == projectPath ? ProjectTemplate : AppTemplate;
+          mTemplates << Template( type, templateInfo.baseName(), templateInfo.absoluteFilePath() );
+
+          if ( type == ProjectTemplate )
+          {
+            hasProjectTemplate = true;
+          }
+        }
+      }
+    }
+  }
+
+  std::sort( mTemplates.begin(), mTemplates.end(), [=]( const Template &t1, const Template &t2 ) {
+    if ( t1.type != t2.type )
+    {
+      return t2.type == ProjectTemplate;
+    }
+
+    return t1.title <= t2.title;
+  } );
+
+  // Add blank template
+  mTemplates.prepend( Template( AppTemplate, tr( "Blank" ), QString() ) );
+
+  endResetModel();
+
+  if ( mHasProjectTemplate != hasProjectTemplate )
+  {
+    mHasProjectTemplate = hasProjectTemplate;
+    emit hasProjectTemplateChanged();
+  }
+}
+
+int DrawingTemplateModel::rowCount( const QModelIndex &parent ) const
+{
+  if ( !parent.isValid() )
+  {
+    return mTemplates.size();
+  }
+
+  return 0;
+}
+
+QVariant DrawingTemplateModel::data( const QModelIndex &index, int role ) const
+{
+  if ( index.row() >= mTemplates.size() || index.row() < 0 )
+  {
+    return QVariant();
+  }
+
+  switch ( static_cast<Role>( role ) )
+  {
+    case TemplateTypeRole:
+      return mTemplates.at( index.row() ).type;
+    case TemplateTitleRole:
+      return mTemplates.at( index.row() ).title;
+    case TemplatePathRole:
+      return mTemplates.at( index.row() ).path;
+  }
+
+  return QVariant();
+}
+
+QString DrawingTemplateModel::projectFilePath() const
+{
+  return mProjectFilePath;
+}
+
+void DrawingTemplateModel::setProjectFilePath( const QString &path )
+{
+  if ( mProjectFilePath == path )
+  {
+    return;
+  }
+
+  mProjectFilePath = path;
+  emit projectFilePathChanged();
+
+  reloadModel();
+}
+
+bool DrawingTemplateModel::hasProjectTemplate() const
+{
+  return mHasProjectTemplate;
+}
diff --git a/src/core/drawingtemplatemodel.h b/src/core/drawingtemplatemodel.h
new file mode 100644
index 0000000000..3a0c071cf5
--- /dev/null
+++ b/src/core/drawingtemplatemodel.h
@@ -0,0 +1,95 @@
+/***************************************************************************
+  drawingtemplatemodel.h
+
+ ---------------------
+ begin                : 28.03.2024
+ copyright            : (C) 2024 by Mathieu Pellerin
+ email                : mathieu at opengis dot ch
+ ***************************************************************************
+ *                                                                         *
+ *   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 DRAWINGTEMPLATEMODEL_H
+#define DRAWINGTEMPLATEMODEL_H
+
+#include <QAbstractListModel>
+
+class DrawingTemplateModel : public QAbstractListModel
+{
+    Q_OBJECT
+
+    /**
+     * This property holds the project file path where project templates will be looked for.
+     */
+    Q_PROPERTY( QString projectFilePath READ projectFilePath WRITE setProjectFilePath NOTIFY projectFilePathChanged )
+
+    /**
+     * This property holds whether the model contains project templates.
+     */
+    Q_PROPERTY( bool hasProjectTemplate READ hasProjectTemplate NOTIFY hasProjectTemplateChanged )
+
+  public:
+    enum TemplateType
+    {
+      AppTemplate,
+      ProjectTemplate,
+    };
+
+    enum Role
+    {
+      TemplateTypeRole = Qt::UserRole,
+      TemplateTitleRole,
+      TemplatePathRole,
+    };
+    Q_ENUM( Role )
+
+    explicit DrawingTemplateModel( QObject *parent = nullptr );
+
+    //! \copydoc DrawingTemplateModel::projectFilePath
+    QString projectFilePath() const;
+
+    //! \copydoc DrawingTemplateModel::projectFilePath
+    void setProjectFilePath( const QString &path );
+
+    //! \copydoc DrawingTemplateModel::hasProjectTemplate
+    bool hasProjectTemplate() const;
+
+    QHash<int, QByteArray> roleNames() const override;
+
+    int rowCount( const QModelIndex &parent ) const override;
+    QVariant data( const QModelIndex &index, int role ) const override;
+
+    /**
+     * Reloads the drawing template model.
+     */
+    Q_INVOKABLE void reloadModel();
+
+  signals:
+    void projectFilePathChanged();
+    void hasProjectTemplateChanged();
+
+  private:
+    struct Template
+    {
+        Template( TemplateType type, const QString &title, const QString &path )
+          : type( type )
+          , title( title )
+          , path( path )
+        {}
+
+        TemplateType type = TemplateType::AppTemplate;
+        QString title;
+        QString path;
+    };
+
+    QList<Template> mTemplates;
+
+    QString mProjectFilePath;
+    bool mHasProjectTemplate = false;
+};
+
+#endif // DRAWINGTEMPLATEMODEL_H
diff --git a/src/core/qgismobileapp.cpp b/src/core/qgismobileapp.cpp
index b10ab0de9b..06f52f2123 100644
--- a/src/core/qgismobileapp.cpp
+++ b/src/core/qgismobileapp.cpp
@@ -50,6 +50,7 @@
 #include "deltalistmodel.h"
 #include "digitizinglogger.h"
 #include "distancearea.h"
+#include "drawingcanvas.h"
 #include "expressionevaluator.h"
 #include "expressionvariablemodel.h"
 #include "featurechecklistmodel.h"
@@ -267,6 +268,7 @@ QgisMobileapp::QgisMobileapp( QgsApplication *app, QObject *parent )
   mProjectsImageProvider = new ProjectsImageProvider();
 
   mBookmarkModel = std::make_unique<BookmarkModel>( QgsApplication::bookmarkManager(), mProject->bookmarkManager(), nullptr );
+  mDrawingTemplateModel = std::make_unique<DrawingTemplateModel>( this );
 
   // Transition from 1.8 to 1.8.1+
   const QString deviceAddress = settings.value( QStringLiteral( "positioningDevice" ), QString() ).toString();
@@ -443,6 +445,7 @@ void QgisMobileapp::initDeclarative()
   qmlRegisterType<AttributeFormModel>( "org.qfield", 1, 0, "AttributeFormModel" );
   qmlRegisterType<FeatureModel>( "org.qfield", 1, 0, "FeatureModel" );
   qmlRegisterType<IdentifyTool>( "org.qfield", 1, 0, "IdentifyTool" );
+  qmlRegisterType<DrawingCanvas>( "org.qfield", 1, 0, "DrawingCanvas" );
   qmlRegisterType<SubModel>( "org.qfield", 1, 0, "SubModel" );
   qmlRegisterType<ExpressionVariableModel>( "org.qfield", 1, 0, "ExpressionVariableModel" );
   qmlRegisterType<BadLayerHandler>( "org.qfield", 1, 0, "BadLayerHandler" );
@@ -558,6 +561,7 @@ void QgisMobileapp::initDeclarative()
   rootContext()->setContextProperty( "layerObserver", mLayerObserver.get() );
   rootContext()->setContextProperty( "featureHistory", mFeatureHistory.get() );
   rootContext()->setContextProperty( "messageLogModel", mMessageLogModel.get() );
+  rootContext()->setContextProperty( "drawingTemplateModel", mDrawingTemplateModel.get() );
 
   rootContext()->setContextProperty( "qfieldAuthRequestHandler", mAuthRequestHandler );
 
diff --git a/src/core/qgismobileapp.h b/src/core/qgismobileapp.h
index 8afee0e45d..d120d37a47 100644
--- a/src/core/qgismobileapp.h
+++ b/src/core/qgismobileapp.h
@@ -31,6 +31,7 @@
 // QField includes
 #include "appcoordinateoperationhandlers.h"
 #include "bookmarkmodel.h"
+#include "drawingtemplatemodel.h"
 #include "qfield_core_export.h"
 #include "qfieldappauthrequesthandler.h"
 #include "qgsgpkgflusher.h"
@@ -229,6 +230,7 @@ class QFIELD_CORE_EXPORT QgisMobileapp : public QQmlApplicationEngine
     QFieldAppAuthRequestHandler *mAuthRequestHandler = nullptr;
 
     std::unique_ptr<BookmarkModel> mBookmarkModel;
+    std::unique_ptr<DrawingTemplateModel> mDrawingTemplateModel;
     std::unique_ptr<MessageLogModel> mMessageLogModel;
 
     // Dummy objects. We are not able to call static functions from QML, so we need something here.
diff --git a/src/qml/MapCanvas.qml b/src/qml/MapCanvas.qml
index a4a615a759..ef5f52deb9 100644
--- a/src/qml/MapCanvas.qml
+++ b/src/qml/MapCanvas.qml
@@ -163,10 +163,7 @@ Item {
                       }
 
       onPressed: (mouse) => {
-                   if (mouse.button === Qt.RightButton) {
-                     secondaryDragHandler.grabPermissions = PointerHandler.CanTakeOverFromItems | PointerHandler.CanTakeOverFromHandlersOfDifferentType | PointerHandler.ApprovesTakeOverByAnything;
-                   } else {
-                     mainDragHandler.grabPermissions = PointerHandler.CanTakeOverFromItems | PointerHandler.ApprovesTakeOverByHandlersOfSameType | PointerHandler.ApprovesTakeOverByHandlersOfDifferentType | PointerHandler.ApprovesTakeOverByItems
+                   if (mouse.button !== Qt.RightButton) {
                      if (timer.running) {
                        timer.stop()
                        doublePressed = true
@@ -177,10 +174,7 @@ Item {
                  }
 
       onReleased: (mouse) => {
-                    if (mouse.button === Qt.RightButton) {
-                      secondaryDragHandler.grabPermissions = PointerHandler.TakeOverForbidden
-                    } else {
-                      mainDragHandler.grabPermissions = PointerHandler.ApprovesTakeOverByHandlersOfSameType | PointerHandler.ApprovesTakeOverByHandlersOfDifferentType | PointerHandler.ApprovesTakeOverByItems
+                    if (mouse.button !== Qt.RightButton) {
                       if (doublePressed) {
                         mapCanvasWrapper.zoom(Qt.point(mouse.x, mouse.y), 0.8)
                       }
@@ -227,17 +221,19 @@ Item {
   }
 
   DragHandler {
-    id: mainDragHandler
+    id: stylusDragHandler
     enabled: interactive && !freehandDigitizing && !pinchArea.isDragging
     target: null
-    grabPermissions: PointerHandler.ApprovesTakeOverByHandlersOfSameType | PointerHandler.ApprovesTakeOverByHandlersOfDifferentType | PointerHandler.ApprovesTakeOverByItems
+    grabPermissions: PointerHandler.CanTakeOverFromHandlersOfDifferentType | PointerHandler.ApprovesTakeOverByHandlersOfDifferentType
+    acceptedDevices: PointerDevice.Stylus | PointerDevice.Mouse
     acceptedButtons: Qt.NoButton | Qt.LeftButton
-    dragThreshold: 10
+    dragThreshold: 5
 
     property var oldPos
     property real oldTranslationY
 
     property bool isZooming: false
+    property bool isPanning: false
     property point zoomCenter
 
     onActiveChanged: {
@@ -248,24 +244,76 @@ Item {
           isZooming = true
           freeze('zoom')
         } else {
+          oldPos = centroid.position
+          isPanning = true
           freeze('pan')
         }
       } else {
-        grabPermissions = PointerHandler.ApprovesTakeOverByHandlersOfSameType | PointerHandler.ApprovesTakeOverByHandlersOfDifferentType | PointerHandler.ApprovesTakeOverByItems
-        unfreeze(isZooming ? 'zoom' : 'pan')
+        if (isZooming || isPanning) {
+          unfreeze(isZooming ? 'zoom' : 'pan')
+        }
         isZooming = false
+        isPanning = false
       }
     }
 
     onCentroidChanged: {
-      var oldPos1 = oldPos
-      oldPos = centroid.position
       if (active) {
         if (isZooming) {
           mapCanvasWrapper.zoom(zoomCenter, Math.pow(0.8, (translation.y - oldTranslationY) / 60))
           oldTranslationY = translation.y
+        } else if (isPanning) {
+          mapCanvasWrapper.pan(centroid.position, oldPos)
+          oldPos = centroid.position
+        }
+      }
+    }
+  }
+
+  DragHandler {
+    id: mainDragHandler
+    enabled: interactive && !freehandDigitizing && !pinchArea.isDragging
+    target: null
+    acceptedButtons: Qt.NoButton | Qt.LeftButton
+    acceptedDevices: PointerDevice.TouchScreen
+    dragThreshold: 5
+
+    property var oldPos
+    property real oldTranslationY
+
+    property bool isZooming: false
+    property bool isPanning: false
+    property point zoomCenter
+
+    onActiveChanged: {
+      if (active) {
+        if (mouseArea.doublePressed) {
+          oldTranslationY = 0
+          zoomCenter = centroid.position
+          isZooming = true
+          freeze('zoom')
         } else {
-          mapCanvasWrapper.pan(centroid.position, oldPos1)
+          oldPos = centroid.position
+          isPanning = true
+          freeze('pan')
+        }
+      } else {
+        if (isZooming || isPanning) {
+          unfreeze(isZooming ? 'zoom' : 'pan')
+        }
+        isZooming = false
+        isPanning = false
+      }
+    }
+
+    onCentroidChanged: {
+      if (active) {
+        if (isZooming) {
+          mapCanvasWrapper.zoom(zoomCenter, Math.pow(0.8, (translation.y - oldTranslationY) / 60))
+          oldTranslationY = translation.y
+        } else if (isPanning) {
+          mapCanvasWrapper.pan(centroid.position, oldPos)
+          oldPos = centroid.position
         }
       }
     }
@@ -275,9 +323,10 @@ Item {
     id: secondaryDragHandler
     target: null
     enabled: interactive && !pinchArea.isDragging
+    grabPermissions: PointerHandler.CanTakeOverFromItems | PointerHandler.CanTakeOverFromHandlersOfDifferentType | PointerHandler.ApprovesTakeOverByAnything;
     acceptedDevices: PointerDevice.Stylus | PointerDevice.Mouse
-    grabPermissions: PointerHandler.TakeOverForbidden
     acceptedButtons: Qt.RightButton
+    dragThreshold: 10
 
     property real oldTranslationY
     property point zoomCenter
diff --git a/src/qml/QFieldSketcher.qml b/src/qml/QFieldSketcher.qml
new file mode 100644
index 0000000000..e3d8906b2f
--- /dev/null
+++ b/src/qml/QFieldSketcher.qml
@@ -0,0 +1,316 @@
+import QtQuick 2.15
+import QtQuick.Controls 2.14
+import QtQuick.Layouts 1.14
+import Qt.labs.settings 1.0
+
+import Theme 1.0
+import org.qfield 1.0
+
+Popup {
+  id: sketcher
+
+  signal finished(var path)
+  signal cancelled()
+
+  width: mainWindow.width
+  height: mainWindow.height
+  x: 0
+  y: 0
+  z: 10000 // 1000s are embedded feature forms, use a higher value to insure feature form popups always show above embedded feature formes
+  padding: 0
+
+  closePolicy: Popup.CloseOnEscape
+  dim: true
+
+  Settings {
+    id: settings
+    property color strokeColor: "#000000"
+  }
+
+  Page {
+    width: parent.width
+    height: parent.height
+    padding: 0
+
+    DrawingCanvas {
+      id: drawingCanvas
+      anchors.fill: parent
+
+      fillColor: Theme.mainBackgroundColor
+      frameColor: Theme.mainColor
+
+      Behavior on zoomFactor {
+        enabled: !pinchHandler.active
+        NumberAnimation { duration: 100; easing.type: Easing.OutQuad; }
+      }
+    }
+
+    PinchHandler {
+      id: pinchHandler
+      enabled: sketcher.visible
+      target: null
+
+      property point oldPosition
+
+      onScaleChanged: (delta) => {
+                        if (active) {
+                          drawingCanvas.zoomFactor = drawingCanvas.zoomFactor * delta
+                        }
+                      }
+      onTranslationChanged: (delta) => {
+                              if (active) {
+                                drawingCanvas.pan(Qt.point(0, 0), Qt.point(delta.x, delta.y))
+                              }
+                            }
+    }
+
+    DragHandler {
+      id: stylusDragHandler
+      enabled: sketcher.visible
+      target: null
+      acceptedButtons: Qt.NoButton | Qt.LeftButton | Qt.RightButton
+      acceptedDevices: PointerDevice.Stylus | PointerDevice.Mouse
+      grabPermissions: PointerHandler.CanTakeOverFromHandlersOfDifferentType | PointerHandler.ApprovesTakeOverByAnything
+      dragThreshold: 0
+
+      property point oldPosition
+
+      onActiveChanged: {
+        if (active) {
+          if (centroid.pressedButtons !== Qt.RightButton) {
+            drawingCanvas.strokeBegin(centroid.position, settings.strokeColor)
+          } else {
+            oldPosition = centroid.position
+          }
+        } else {
+          drawingCanvas.strokeEnd(centroid.position)
+        }
+      }
+
+      onCentroidChanged: {
+        if (active) {
+          if (centroid.pressedButtons === Qt.RightButton) {
+            drawingCanvas.pan(oldPosition, centroid.position)
+            oldPosition = centroid.position
+          } else {
+            drawingCanvas.strokeMove(centroid.position)
+          }
+        }
+      }
+    }
+
+    DragHandler {
+      id: dragHandler
+      enabled: sketcher.visible
+      target: null
+      acceptedButtons: Qt.NoButton | Qt.LeftButton | Qt.RightButton
+      acceptedDevices: PointerDevice.TouchScreen
+      dragThreshold: 0
+
+      property point oldPosition
+
+      onActiveChanged: {
+        if (active) {
+          if (centroid.pressedButtons !== Qt.RightButton) {
+            drawingCanvas.strokeBegin(centroid.position, settings.strokeColor)
+          } else {
+            oldPosition = centroid.position
+          }
+        } else {
+          drawingCanvas.strokeEnd(centroid.position)
+        }
+      }
+
+      onCentroidChanged: {
+        if (active) {
+          if (centroid.pressedButtons === Qt.RightButton) {
+            drawingCanvas.pan(oldPosition, centroid.position)
+            oldPosition = centroid.position
+          } else {
+            drawingCanvas.strokeMove(centroid.position)
+          }
+        }
+      }
+    }
+
+    WheelHandler {
+      enabled: sketcher.visible
+      target: null
+
+      onWheel: (event) => { drawingCanvas.zoomFactor = drawingCanvas.zoomFactor * (event.angleDelta.y > 0 ? 1.25 : 0.75) }
+    }
+
+    RowLayout {
+      visible: !drawingCanvas.isEmpty
+      anchors.horizontalCenter: parent.horizontalCenter
+      anchors.bottom: parent.bottom
+      anchors.bottomMargin: mainWindow.sceneBottomMargin + 5
+      spacing: 3
+
+      Repeater {
+        model: [["#000000","#ffffff"], ["#ffffff","#000000"], ["#e41a1c","#e41a1c"], ["#377eb8","#377eb8"], ["#4daf4a","#4daf4a"]]
+
+        QfToolButton {
+          property color colorValue: modelData[0]
+
+          width: 48
+          height: 48
+          round: true
+          borderColor: modelData[1]
+          scale: settings.strokeColor == colorValue ? 1 : 0.66
+          opacity: settings.strokeColor == colorValue ? 1 : 0.66
+
+          Behavior on scale {
+            enabled: true
+            NumberAnimation { duration: 200; easing.type: Easing.OutQuad; }
+          }
+          Behavior on opacity {
+            enabled: true
+            NumberAnimation { duration: 200; easing.type: Easing.OutQuad; }
+          }
+
+          bgcolor: colorValue
+
+          onClicked: {
+            settings.strokeColor = colorValue
+          }
+        }
+      }
+    }
+
+    Rectangle {
+      id: templateContainer
+
+      visible: drawingCanvas.isEmpty
+      width: parent.width
+      height: parent.height / 3
+      x: 0
+      y: parent.height / 7 * 4
+      color: Theme.controlBackgroundAlternateColor
+
+      ColumnLayout {
+        anchors.fill: parent
+        anchors.margins: 10
+
+        Text {
+          Layout.fillWidth: true
+          Layout.alignment: Qt.AlignHCenter
+          text: qsTr('Select drawing template')
+          font: Theme.defaultFont
+          color: Theme.mainColor
+          wrapMode: Text.WordWrap
+          horizontalAlignment: Text.AlignHCenter
+        }
+
+        ListView {
+          id: templateList
+          Layout.preferredWidth: Math.min(parent.width, templateList.contentWidth)
+          Layout.fillHeight: true
+          Layout.alignment: Qt.AlignHCenter
+          model: drawingTemplateModel
+          orientation: ListView.Horizontal
+
+          delegate: Rectangle {
+            id: templateItem
+            width: templateList.height
+            height: templateList.height
+            color: "transparent"
+
+            Image {
+              anchors.fill: parent
+              anchors.margins: 5
+              visible: templatePath !== ''
+              fillMode: Image.PreserveAspectFit
+              source: templatePath !== '' ? 'file://' + templatePath : ''
+            }
+
+            Rectangle {
+              anchors.centerIn: parent
+              anchors.margins: 5
+              visible: templatePath === ''
+              width: mainWindow.width > mainWindow.height ? parent.width : mainWindow.width * parent.height / mainWindow.height
+              height: mainWindow.height > mainWindow.width ? parent.height : mainWindow.height * parent.width / mainWindow.width
+              color: "#ffffff"
+            }
+
+            Rectangle {
+              anchors.centerIn: parent
+              width: titleText.contentWidth + 10
+              height: titleText.contentHeight + 5
+              radius: 4
+              color: "#55000000"
+
+              Text {
+                anchors.centerIn: parent
+                width: templateItem.width
+                id: titleText
+                text: templateTitle
+                font: Theme.tipFont
+                color: "#ffffff"
+                horizontalAlignment: Text.AlignHCenter
+              }
+            }
+
+            MouseArea {
+              anchors.fill: parent
+              onClicked: {
+                if (templatePath !== '') {
+                  drawingCanvas.createCanvasFromImage(templatePath)
+                } else {
+                  drawingCanvas.createBlankCanvas(mainWindow.width, mainWindow.height, "#ffffff")
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+
+    QfToolButton {
+      id: backButton
+
+      anchors.left: parent.left
+      anchors.leftMargin: 5
+      anchors.top: parent.top
+      anchors.topMargin: mainWindow.sceneTopMargin + 5
+
+      iconSource: Theme.getThemeIcon("ic_chevron_left_white_24dp")
+      iconColor: "white"
+      bgcolor: Theme.darkGraySemiOpaque
+      round: true
+
+      onClicked: {
+        sketcher.cancelled()
+        sketcher.close()
+      }
+    }
+
+    QfToolButton {
+      id: saveButton
+      visible: !drawingCanvas.isEmpty
+
+      anchors.right: parent.right
+      anchors.rightMargin: 5
+      anchors.top: parent.top
+      anchors.topMargin: mainWindow.sceneTopMargin + 5
+
+      iconSource: Theme.getThemeIcon( 'ic_check_white_48dp' )
+      iconColor: "white"
+      bgcolor: drawingCanvas.isDirty ? Theme.mainColor : Theme.darkGraySemiOpaque
+      round: true
+
+      onClicked: {
+        sketcher.finished(drawingCanvas.save())
+        sketcher.close()
+      }
+    }
+  }
+
+  function loadImage(path) {
+    drawingCanvas.createCanvasFromImage(path)
+  }
+
+  function clear() {
+    drawingCanvas.clear();
+  }
+}
diff --git a/src/qml/editorwidgets/ExternalResource.qml b/src/qml/editorwidgets/ExternalResource.qml
index 0bc612bcef..fef35211d2 100644
--- a/src/qml/editorwidgets/ExternalResource.qml
+++ b/src/qml/editorwidgets/ExternalResource.qml
@@ -206,7 +206,7 @@ EditorWidgetBase {
 
   Rectangle {
     id: mediaFrame
-    width: parent.width - fileButton.width - galleryButton.width - cameraButton.width - cameraVideoButton.width - microphoneButton.width - (isEnabled ? 5 : 0)
+    width: parent.width - fileButton.width - cameraButton.width - cameraVideoButton.width - microphoneButton.width - (isEnabled ? 5 : 0)
     height: 48
     visible: !linkField.visible
     color: isEnabled ? Theme.controlBackgroundAlternateColor : "transparent"
@@ -236,10 +236,10 @@ EditorWidgetBase {
         property bool hasGeoTag: false
         id: geoTagBadge
         visible: false
-        anchors.top: image.top
+        anchors.bottom: image.bottom
         anchors.right: image.right
         anchors.rightMargin: 10
-        anchors.topMargin: 12
+        anchors.bottomMargin: 12
         fillMode: Image.PreserveAspectFit
         width: 24
         height: 24
@@ -321,6 +321,45 @@ EditorWidgetBase {
       }
     }
 
+    QfToolButton {
+      id: sketchButton
+      anchors.top: image.top
+      anchors.right: image.right
+      visible: image.status === Image.Ready && isEnabled
+
+      round: true
+      iconSource: Theme.getThemeVectorIcon( "ic_freehand_white_24dp" )
+      iconColor: "white"
+      bgcolor: Theme.darkGraySemiOpaque
+
+      onClicked: {
+        sketcherConnection.enabled = true
+        sketcher.loadImage(image.source)
+        sketcher.open()
+      }
+    }
+
+    Connections {
+      id: sketcherConnection
+      target: sketcher
+      enabled: false
+
+      function onFinished(path) {
+        var filepath = getResourceFilePath()
+        filepath = filepath.replace('{filename}', FileUtils.fileName(path))
+        filepath = filepath.replace('{extension}', FileUtils.fileSuffix(path))
+        platformUtilities.renameFile(path, prefixToRelativePath + filepath)
+
+        valueChangeRequested(filepath, false)
+
+        enabled = false
+      }
+
+      function onCancelled() {
+        enabled = false
+      }
+    }
+
     RowLayout {
       id: playerControls
 
@@ -412,7 +451,7 @@ EditorWidgetBase {
     height: 48
 
     // QField has historically handled no viewer type as image, let's carry that on
-    visible: (documentViewer == document_FILE || documentViewer == document_IMAGE) && isEnabled
+    visible: documentViewer == document_IMAGE && isEnabled
 
     anchors.right: cameraVideoButton.left
     anchors.top: parent.top
@@ -421,19 +460,7 @@ EditorWidgetBase {
     iconColor: Theme.mainTextColor
     bgcolor: "transparent"
 
-    onClicked: {
-      Qt.inputMethod.hide()
-      if ( platformUtilities.capabilities & PlatformUtilities.NativeCamera && settings.valueBool("nativeCamera", true) ) {
-        var filepath = getResourceFilePath()
-        // Pictures taken by cameras will always be JPG
-        filepath = filepath.replace('{extension}', 'JPG')
-        __resourceSource = platformUtilities.getCameraPicture(qgisProject.homePath+'/', filepath, FileUtils.fileSuffix(filepath), this)
-      } else {
-        platformUtilities.createDir(qgisProject.homePath, 'DCIM')
-        cameraLoader.isVideo = false
-        cameraLoader.active = true
-      }
-    }
+    onClicked: capturePhoto()
   }
 
   QfToolButton {
@@ -450,19 +477,7 @@ EditorWidgetBase {
     iconColor: Theme.mainTextColor
     bgcolor: "transparent"
 
-    onClicked: {
-      Qt.inputMethod.hide()
-      if ( platformUtilities.capabilities & PlatformUtilities.NativeCamera && settings.valueBool("nativeCamera", true) ) {
-        var filepath = getResourceFilePath()
-        // Video taken by cameras will always be MP4
-        filepath = filepath.replace('{extension}', 'MP4')
-        __resourceSource = platformUtilities.getCameraVideo(qgisProject.homePath+'/', filepath, FileUtils.fileSuffix(filepath), this)
-      } else {
-        platformUtilities.createDir(qgisProject.homePath, 'DCIM')
-        cameraLoader.isVideo = true
-        cameraLoader.active = true
-      }
-    }
+    onClicked: captureVideo()
   }
 
   QfToolButton {
@@ -479,10 +494,7 @@ EditorWidgetBase {
     iconColor: Theme.mainTextColor
     bgcolor: "transparent"
 
-    onClicked: {
-      Qt.inputMethod.hide()
-      audioRecorderLoader.active = true
-    }
+    onClicked: captureAudio()
   }
 
   QfToolButton {
@@ -490,50 +502,16 @@ EditorWidgetBase {
     width: visible ? 48 : 0
     height: 48
 
-    visible: platformUtilities.capabilities & PlatformUtilities.FilePicker && (documentViewer == document_FILE || documentViewer == document_AUDIO) && isEnabled
-
-    anchors.right: galleryButton.left
-    anchors.top: parent.top
-
-    iconSource: Theme.getThemeIcon("ic_file_black_24dp")
-    iconColor: Theme.mainTextColor
-    bgcolor: "transparent"
-
-    onClicked: {
-      Qt.inputMethod.hide()
-      var filepath = getResourceFilePath()
-      if (documentViewer == document_AUDIO) {
-        __resourceSource = platformUtilities.getFile(qgisProject.homePath+'/', filepath, PlatformUtilities.AudioFiles, this)
-      } else {
-        __resourceSource = platformUtilities.getFile(qgisProject.homePath+'/', filepath, this)
-      }
-    }
-  }
-
-  QfToolButton {
-    id: galleryButton
-    width: visible ? 48 : 0
-    height: 48
-
-    // QField has historically handled no viewer type as image, let's carry that on
-    visible: (documentViewer == document_FILE || documentViewer == document_IMAGE || documentViewer == document_VIDEO) && isEnabled
+    visible: platformUtilities.capabilities & PlatformUtilities.FilePicker && documentViewer == document_FILE && isEnabled
 
     anchors.right: parent.right
     anchors.top: parent.top
 
-    iconSource: Theme.getThemeVectorIcon("ic_gallery_black_24dp")
+    iconSource: Theme.getThemeIcon("ic_file_black_24dp")
     iconColor: Theme.mainTextColor
     bgcolor: "transparent"
 
-    onClicked: {
-      Qt.inputMethod.hide()
-      var filepath = getResourceFilePath()
-      if (documentViewer == document_VIDEO) {
-        __resourceSource = platformUtilities.getGalleryVideo(qgisProject.homePath+'/', filepath, this)
-      } else {
-        __resourceSource = platformUtilities.getGalleryPicture(qgisProject.homePath+'/', filepath, this)
-      }
-    }
+    onClicked: attachFile()
   }
 
   Loader {
@@ -656,4 +634,152 @@ EditorWidgetBase {
       }
     }
   }
+
+  function attachFile() {
+    Qt.inputMethod.hide()
+    var filepath = getResourceFilePath()
+    if (documentViewer == document_AUDIO) {
+      __resourceSource = platformUtilities.getFile(qgisProject.homePath+'/', filepath, PlatformUtilities.AudioFiles, this)
+    } else {
+      __resourceSource = platformUtilities.getFile(qgisProject.homePath+'/', filepath, this)
+    }
+  }
+
+  function attachGallery() {
+    Qt.inputMethod.hide()
+    var filepath = getResourceFilePath()
+    if (documentViewer == document_VIDEO) {
+      __resourceSource = platformUtilities.getGalleryVideo(qgisProject.homePath+'/', filepath, this)
+    } else {
+      __resourceSource = platformUtilities.getGalleryPicture(qgisProject.homePath+'/', filepath, this)
+    }
+  }
+
+  function capturePhoto() {
+    Qt.inputMethod.hide()
+    if ( platformUtilities.capabilities & PlatformUtilities.NativeCamera && settings.valueBool("nativeCamera", true) ) {
+      var filepath = getResourceFilePath()
+      // Pictures taken by cameras will always be JPG
+      filepath = filepath.replace('{extension}', 'JPG')
+      __resourceSource = platformUtilities.getCameraPicture(qgisProject.homePath+'/', filepath, FileUtils.fileSuffix(filepath), this)
+    } else {
+      platformUtilities.createDir(qgisProject.homePath, 'DCIM')
+      cameraLoader.isVideo = false
+      cameraLoader.active = true
+    }
+  }
+
+  function captureVideo() {
+    Qt.inputMethod.hide()
+    if ( platformUtilities.capabilities & PlatformUtilities.NativeCamera && settings.valueBool("nativeCamera", true) ) {
+      var filepath = getResourceFilePath()
+      // Video taken by cameras will always be MP4
+      filepath = filepath.replace('{extension}', 'MP4')
+      __resourceSource = platformUtilities.getCameraVideo(qgisProject.homePath+'/', filepath, FileUtils.fileSuffix(filepath), this)
+    } else {
+      platformUtilities.createDir(qgisProject.homePath, 'DCIM')
+      cameraLoader.isVideo = true
+      cameraLoader.active = true
+    }
+  }
+
+  function captureAudio() {
+    Qt.inputMethod.hide()
+    audioRecorderLoader.active = true
+  }
+
+  Component.onCompleted: {
+    menu.addItem(capturePhotoMenuItem)
+    menu.addItem(captureVideoMenuItem)
+    menu.addItem(captureAudioMenuItem)
+    menu.addItem(separatorGalleryItem)
+    if (platformUtilities.capabilities & PlatformUtilities.FilePicker) {
+      menu.addItem(attachFileMenuItem)
+    }
+    menu.addItem(attachGalleryMenuItem)
+    menu.addItem(separatorDrawingItem)
+    menu.addItem(attachDrawingMenuItem)
+
+    hasMenu = true;
+  }
+
+  MenuItem {
+    id: capturePhotoMenuItem
+    text: qsTr( 'Take a photo' )
+
+    font: Theme.defaultFont
+    icon.source: Theme.getThemeVectorIcon( "ic_camera_photo_black_24dp" )
+    height: 48
+    leftPadding: Theme.menuItemLeftPadding
+
+    onTriggered: capturePhoto()
+  }
+
+  MenuItem {
+    id: captureVideoMenuItem
+    text: qsTr( 'Take a video' )
+
+    font: Theme.defaultFont
+    icon.source: Theme.getThemeVectorIcon( "ic_camera_video_black_24dp" )
+    height: 48
+    leftPadding: Theme.menuItemLeftPadding
+
+    onTriggered: captureVideo()
+  }
+
+  MenuItem {
+    id: captureAudioMenuItem
+    text: qsTr( 'Record an audio clip' )
+
+    font: Theme.defaultFont
+    icon.source: Theme.getThemeVectorIcon( "ic_microphone_black_24dp" )
+    height: 48
+    leftPadding: Theme.menuItemLeftPadding
+
+    onTriggered: captureAudio()
+  }
+
+  MenuSeparator { id: separatorGalleryItem; width: parent.width }
+
+  MenuItem {
+    id: attachGalleryMenuItem
+    text: qsTr( 'Attach a gallery item' )
+
+    font: Theme.defaultFont
+    icon.source: Theme.getThemeVectorIcon( "ic_gallery_black_24dp" )
+    height: 48
+    leftPadding: Theme.menuItemLeftPadding
+
+    onTriggered: attachGallery()
+  }
+
+  MenuItem {
+    id: attachFileMenuItem
+    text: qsTr( 'Attach a file' )
+
+    font: Theme.defaultFont
+    icon.source: Theme.getThemeVectorIcon( "ic_file_black_24dp" )
+    height: 48
+    leftPadding: Theme.menuItemLeftPadding
+
+    onTriggered: attachFile()
+  }
+
+  MenuSeparator { id: separatorDrawingItem; width: parent.width }
+
+  MenuItem {
+    id: attachDrawingMenuItem
+    text: qsTr( 'Draw a sketch' )
+
+    font: Theme.defaultFont
+    icon.source: Theme.getThemeVectorIcon( "ic_freehand_white_24dp" )
+    height: 48
+    leftPadding: Theme.menuItemLeftPadding
+
+    onTriggered: {
+      sketcherConnection.enabled = true
+      sketcher.clear()
+      sketcher.open()
+    }
+  }
 }
diff --git a/src/qml/editorwidgets/TextEdit.qml b/src/qml/editorwidgets/TextEdit.qml
index b98c3ac293..2cb0b3e27e 100644
--- a/src/qml/editorwidgets/TextEdit.qml
+++ b/src/qml/editorwidgets/TextEdit.qml
@@ -160,6 +160,7 @@ EditorWidgetBase {
       platformUtilities.copyTextToClipboard(value)
     }
   }
+
   MenuItem {
     id: pasteTextItem
     text: qsTr( 'Paste Text' )
diff --git a/src/qml/qgismobileapp.qml b/src/qml/qgismobileapp.qml
index d4042b92e7..5c9455b5e7 100644
--- a/src/qml/qgismobileapp.qml
+++ b/src/qml/qgismobileapp.qml
@@ -429,7 +429,7 @@ ApplicationWindow {
     /* The map canvas */
     MapCanvas {
       id: mapCanvasMap
-      property bool isEnabled: !dashBoard.opened && !welcomeScreen.visible && !qfieldSettings.visible && !qfieldLocalDataPickerScreen.visible && !qfieldCloudScreen.visible && !cloudPopup.visible && !codeReader.visible
+      property bool isEnabled: !dashBoard.opened && !welcomeScreen.visible && !qfieldSettings.visible && !qfieldLocalDataPickerScreen.visible && !qfieldCloudScreen.visible && !cloudPopup.visible && !codeReader.visible && !sketcher.visible
       interactive: isEnabled && !screenLocker.enabled
       incrementalRendering: true
       quality: qfieldSettings.quality
@@ -3399,6 +3399,8 @@ ApplicationWindow {
       platformUtilities.setHandleVolumeKeys(qfieldSettings.digitizingVolumeKeys && stateMachine.state != 'browse')
       dashBoard.activeLayer = projectInfo.activeLayer
 
+      drawingTemplateModel.projectFilePath = path
+
       mapCanvasBackground.color = mapCanvas.mapSettings.backgroundColor
 
       var titleDecorationConfiguration = projectInfo.getTitleDecorationConfiguration();
@@ -3892,6 +3894,11 @@ ApplicationWindow {
     visible: false
   }
 
+  QFieldSketcher {
+    id: sketcher
+    visible: false
+  }
+
   Connections {
     target: locatorItem
 
diff --git a/src/qml/qml.qrc b/src/qml/qml.qrc
index 2a6013aaf4..6149be6995 100644
--- a/src/qml/qml.qrc
+++ b/src/qml/qml.qrc
@@ -100,6 +100,7 @@
         <file>QFieldCloudDeltaHistory.qml</file>
         <file>QFieldCloudPackageLayersFeedback.qml</file>
         <file>QFieldLocalDataPickerScreen.qml</file>
+        <file>QFieldSketcher.qml</file>
         <file>imports/Theme/QfSlider.qml</file>
     </qresource>
 </RCC>