api/3.32/qgsmaptip_8cpp_source.html

/***************************************************************************

    qgsmaptips.cpp  -  Query a layer and show a maptip on the canvas

    ---------------------

    begin                : October 2007

    copyright            : (C) 2007 by Gary Sherman

    email                : sherman @ mrcc 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.                                   *

 *                                                                         *

 ***************************************************************************/

// QGIS includes

#include "qgsfeatureiterator.h"

#include "qgsmapcanvas.h"

#include "qgsmaptool.h"

#include "qgsvectorlayer.h"

#include "qgsrasterlayer.h"

#include "qgsexpression.h"

#include "qgslogger.h"

#include "qgssettings.h"

#include "qgswebview.h"

#include "qgswebframe.h"

#include "qgsapplication.h"

#include "qgsrenderer.h"

#include "qgsexpressioncontextutils.h"

#include "qgsmaplayertemporalproperties.h"

#include "qgsrendercontext.h"

#include "qgsmapcanvasutils.h"


// Qt includes

#include <QPoint>

#include <QToolTip>

#include <QSettings>

#include <QLabel>

#include <QDesktopServices>

#if WITH_QTWEBKIT

#include <QWebElement>

#endif

#include <QHBoxLayout>


#include "qgsmaptip.h"


const QString QgsMapTip::sMapTipTemplate = "<html>\n"

    "  <head>\n"

    "    <style>\n"

    "    body {\n"

    "        margin: 0;\n"

    "        font: %1pt \"%2\";\n"

    "        color: %3;\n"

    "        width: %4px;\n"

    "    }\n"

    "    #QgsWebViewContainer {\n"

    "        background-color: %5;\n"

    "        border: 1px solid %6;\n"

    "        display: inline-block;\n"

    "        margin: 0\n"

    "    }\n"

    "    #QgsWebViewContainerInner {\n"

    "        margin: 5px\n"

    "    }\n"

    "    </style>\n"

    "  </head>\n"

    "  <body>\n"

    "    <div id='QgsWebViewContainer'>\n"

    "      <div id='QgsWebViewContainerInner'>\n"

    "      %7\n"

    "      </div>\n"

    "    </div>\n"

    "  </body>\n"

    "</html>\n";


QgsMapTip::QgsMapTip()

{

  // Init the visible flag

  mMapTipVisible = false;


  mDelayedClearTimer.setSingleShot( true );

  connect( &mDelayedClearTimer, &QTimer::timeout, this, [ = ]() {this->clear();} );

}


void QgsMapTip::showMapTip( QgsMapLayer *pLayer,

                            QgsPointXY &mapPosition,

                            const QPoint &pixelPosition,

                            QgsMapCanvas *pMapCanvas )

{

  // Do the search using the active layer and the preferred label field for the

  // layer. The label field must be defined in the layer configuration

  // file/database. The code required to do this is similar to identify, except

  // we only want the first qualifying feature and we will only display the

  // field defined as the label field in the layer configuration file/database


  // Do not render map tips if the layer is not visible

  if ( !pMapCanvas->layers( true ).contains( pLayer ) )

  {

    return;

  }


  // Do not render a new map tip when the mouse hovers an existing one

  if ( mWebView && mWebView->underMouse() )

  {

    return;

  }


  // Show the maptip on the canvas

  QString tipText, lastTipText, tipHtml;


  if ( ! mWebView )

  {

    mWebView = new QgsWebView( pMapCanvas );

    // Make the webwiew transparent

    mWebView->setStyleSheet( QStringLiteral( "background:transparent;" ) );


#if WITH_QTWEBKIT

    mWebView->page()->setLinkDelegationPolicy( QWebPage::DelegateAllLinks );//Handle link clicks by yourself

    mWebView->setContextMenuPolicy( Qt::NoContextMenu ); //No context menu is allowed if you don't need it

    connect( mWebView, &QWebView::linkClicked, this, &QgsMapTip::onLinkClicked );

    connect( mWebView, &QWebView::loadFinished, this, [ = ]( bool ) { resizeAndMoveToolTip(); } );

#endif


    mWebView->page()->settings()->setAttribute( QWebSettings::DeveloperExtrasEnabled, true );

    mWebView->page()->settings()->setAttribute( QWebSettings::JavascriptEnabled, true );

    mWebView->page()->settings()->setAttribute( QWebSettings::LocalStorageEnabled, true );


    // Disable scrollbars, avoid random resizing issues

    mWebView->page()->mainFrame()->setScrollBarPolicy( Qt::Horizontal, Qt::ScrollBarAlwaysOff );

    mWebView->page()->mainFrame()->setScrollBarPolicy( Qt::Vertical, Qt::ScrollBarAlwaysOff );


  }


  // Only supported layer types here:

  switch ( pLayer->type() )

  {

    case Qgis::LayerType::Vector:

      tipText = fetchFeature( pLayer, mapPosition, pMapCanvas );

      break;

    case Qgis::LayerType::Raster:

      tipText = fetchRaster( pLayer, mapPosition, pMapCanvas );

      break;

    default:

      break;

  }


  mMapTipVisible = !tipText.isEmpty();

  if ( !mMapTipVisible )

  {

    clear();

    return;

  }


  if ( tipText == lastTipText )

  {

    return;

  }


  // Compute offset from the cursor position

  int cursorOffset = 0;

  if ( QgsApplication::instance() )

  {

    // The following calculations are taken

    // from QgsApplication::getThemeCursor, and are used to calculate the correct cursor size

    // for both hi-dpi and non-hi-dpi screens.

    double scale = Qgis::UI_SCALE_FACTOR * QgsApplication::instance()->fontMetrics().height() / 32.0;

    cursorOffset = static_cast< int >( std::ceil( scale * 32 ) );

  }


  // Ensures the map tip is never larger than half the map canvas minus the cursor size + margin (cursorOffset)

  const int MAX_WIDTH = pMapCanvas->width() / 2 - cursorOffset;

  const int MAX_HEIGHT = pMapCanvas->height() / 2;


  mWebView->setMaximumSize( MAX_WIDTH, MAX_HEIGHT );


  tipHtml = QgsMapTip::htmlText( tipText, MAX_WIDTH );


  QgsDebugMsgLevel( tipHtml, 2 );


  mPosition = pixelPosition;

  mMapCanvas = pMapCanvas;

  mWebView->setHtml( tipHtml );

  lastTipText = tipText;


#if !WITH_QTWEBKIT

  resizeAndMoveToolTip();

#endif


}


void QgsMapTip::resizeAndMoveToolTip()

{

#if WITH_QTWEBKIT

  // Get the content size

  const QWebElement container = mWebView->page()->mainFrame()->findFirstElement(

                                  QStringLiteral( "#QgsWebViewContainer" ) );

  const int width = container.geometry().width();

  const int height = container.geometry().height();

  mWebView->resize( width, height );

#else

  mWebView->adjustSize();

#endif


  int cursorOffset = 0;

  // attempt to shift the tip away from the cursor.

  if ( QgsApplication::instance() )

  {

    // The following calculations are taken

    // from QgsApplication::getThemeCursor, and are used to calculate the correct cursor size

    // for both hi-dpi and non-hi-dpi screens.

    double scale = Qgis::UI_SCALE_FACTOR * QgsApplication::instance()->fontMetrics().height() / 32.0;

    cursorOffset = static_cast< int >( std::ceil( scale * 32 ) );

  }


  if ( mMapCanvas == nullptr )

  {

    mWebView->move( mPosition );

    mWebView->show();

    return;

  }


  // Check if there is enough space to the right of the cursor

  int availableWidthRight = mMapCanvas->width() - mPosition.x() - cursorOffset;

  int availableWidthLeft = mPosition.x() - cursorOffset;

  int availableHeightBottom = mMapCanvas->height() - mPosition.y();

  int availableHeightTop = mPosition.y();

  int x, y;

  // If there is enough space on the right, or more space on the right than on the left, move the map tip to the right of the cursor

  if ( mWebView->width() < availableWidthRight || availableWidthRight > availableWidthLeft )

  {

    x = mPosition.x() + cursorOffset;

  }

  // Otherwise, move the map tip to the left of the cursor

  else

  {

    x = mPosition.x() - mWebView->width() - cursorOffset;

  }


  // If there is enough space on the bottom, or more space on the bottom than on the top, move the map tip to the bottom of the cursor

  if ( mWebView->height() < availableHeightBottom || availableHeightBottom > availableHeightTop )

  {

    y = mPosition.y();

  }

  // Otherwise, move the map tip to the top of the cursor

  else

  {

    y = mPosition.y() - mWebView->height();

  }

  mWebView->move( x, y );

  mWebView->show();

}


void QgsMapTip::clear( QgsMapCanvas *, int msDelay )

{

  if ( !mMapTipVisible )

  {

    return;

  }


  // Skip clearing the map tip if the user interacts with it or the timer still runs

  if ( mDelayedClearTimer.isActive() || mWebView->underMouse() )

  {

    return;

  }


  if ( msDelay > 0 )

  {

    mDelayedClearTimer.start( msDelay );

    return;

  }

  mWebView->setHtml( QString() );

  mWebView->hide();


  // Reset the visible flag

  mMapTipVisible = false;

}


QString QgsMapTip::fetchFeature( QgsMapLayer *layer, QgsPointXY &mapPosition, QgsMapCanvas *mapCanvas )

{

  QgsVectorLayer *vlayer = qobject_cast<QgsVectorLayer *>( layer );

  if ( !vlayer || !vlayer->isSpatial() || !vlayer->mapTipsEnabled() )

  {

    return QString();

  }


  if ( !layer->isInScaleRange( mapCanvas->mapSettings().scale() ) ||

       ( mapCanvas->mapSettings().isTemporal() && !layer->temporalProperties()->isVisibleInTemporalRange( mapCanvas->temporalRange() ) ) )

  {

    return QString();

  }


  const double searchRadius = QgsMapTool::searchRadiusMU( mapCanvas );


  QgsRectangle r;

  r.setXMinimum( mapPosition.x() - searchRadius );

  r.setYMinimum( mapPosition.y() - searchRadius );

  r.setXMaximum( mapPosition.x() + searchRadius );

  r.setYMaximum( mapPosition.y() + searchRadius );


  r = mapCanvas->mapSettings().mapToLayerCoordinates( layer, r );


  QgsExpressionContext context( QgsExpressionContextUtils::globalProjectLayerScopes( vlayer ) );

  context.appendScope( QgsExpressionContextUtils::mapSettingsScope( mapCanvas->mapSettings() ) );

  context.appendScope( QgsExpressionContextUtils::mapLayerPositionScope( r.center() ) );


  const QString canvasFilter = QgsMapCanvasUtils::filterForLayer( mapCanvas, vlayer );

  if ( canvasFilter ==  QLatin1String( "FALSE" ) )

  {

    return QString();

  }


  const QString mapTip = vlayer->mapTipTemplate();

  QString tipString;

  QgsExpression exp( vlayer->displayExpression() );

  QgsFeature feature;


  QgsFeatureRequest request;

  request.setFilterRect( r );

  request.setFlags( QgsFeatureRequest::ExactIntersect );

  if ( !canvasFilter.isEmpty() )

  {

    request.setFilterExpression( canvasFilter );

  }


  if ( mapTip.isEmpty() )

  {

    exp.prepare( &context );

    request.setSubsetOfAttributes( exp.referencedColumns(), vlayer->fields() );

  }


  QgsRenderContext renderCtx = QgsRenderContext::fromMapSettings( mapCanvas->mapSettings() );

  renderCtx.setExpressionContext( mapCanvas->createExpressionContext() );

  renderCtx.expressionContext() << QgsExpressionContextUtils::layerScope( vlayer );


  bool filter = false;

  std::unique_ptr< QgsFeatureRenderer > renderer;

  if ( vlayer->renderer() )

  {

    renderer.reset( vlayer->renderer()->clone() );

    renderer->startRender( renderCtx, vlayer->fields() );

    filter = renderer->capabilities() & QgsFeatureRenderer::Filter;


    const QString filterExpression = renderer->filter( vlayer->fields() );

    if ( ! filterExpression.isEmpty() )

    {

      request.combineFilterExpression( filterExpression );

    }

  }

  request.setExpressionContext( renderCtx.expressionContext() );


  QgsFeatureIterator it = vlayer->getFeatures( request );

  QElapsedTimer timer;

  timer.start();

  while ( it.nextFeature( feature ) )

  {

    context.setFeature( feature );


    renderCtx.expressionContext().setFeature( feature );

    if ( filter && renderer && !renderer->willRenderFeature( feature, renderCtx ) )

    {

      continue;

    }


    if ( !mapTip.isEmpty() )

    {

      tipString = QgsExpression::replaceExpressionText( mapTip, &context );

    }

    else

    {

      tipString = exp.evaluate( &context ).toString();

    }


    if ( !tipString.isEmpty() || timer.elapsed() >= 1000 )

    {

      break;

    }

  }


  if ( renderer )

  {

    renderer->stopRender( renderCtx );

  }


  return tipString;

}


QString QgsMapTip::fetchRaster( QgsMapLayer *layer, QgsPointXY &mapPosition, QgsMapCanvas *mapCanvas )

{

  QgsRasterLayer *rlayer = qobject_cast<QgsRasterLayer *>( layer );

  if ( !rlayer || !rlayer->mapTipsEnabled() )

  {

    return QString();

  }


  if ( !layer->isInScaleRange( mapCanvas->mapSettings().scale() ) ||

       ( mapCanvas->mapSettings().isTemporal() && !layer->temporalProperties()->isVisibleInTemporalRange( mapCanvas->temporalRange() ) ) )

  {

    return QString();

  }


  if ( rlayer->mapTipTemplate().isEmpty() )

  {

    return QString();

  }


  const QgsPointXY mappedPosition { mapCanvas->mapSettings().mapToLayerCoordinates( layer, mapPosition ) };


  if ( ! layer->extent().contains( mappedPosition ) )

  {

    return QString();

  }


  QgsExpressionContext context( QgsExpressionContextUtils::globalProjectLayerScopes( layer ) );

  context.appendScope( QgsExpressionContextUtils::mapSettingsScope( mapCanvas->mapSettings() ) );

  context.appendScope( QgsExpressionContextUtils::mapLayerPositionScope( mappedPosition ) );

  return  QgsExpression::replaceExpressionText( rlayer->mapTipTemplate(), &context );

}


QString QgsMapTip::htmlText( const QString &text, int maxWidth )

{


  const QgsSettings settings;

  const QFont defaultFont = qApp->font();

  const int fontSize = defaultFont.pointSize();

  const QString fontFamily = defaultFont.family();

  const QString backgroundColor = QgsApplication::palette().base().color().name();

  const QString strokeColor = QgsApplication::palette().shadow().color().name();

  const QString textColor = QgsApplication::palette().toolTipText().color().name();

  return sMapTipTemplate.arg( fontSize ).arg( fontFamily ).arg( textColor ).arg( maxWidth == -1 ? "" : QString::number( maxWidth ) ).arg( backgroundColor ).arg( strokeColor ).arg( text );

}


// This slot handles all clicks

void QgsMapTip::onLinkClicked( const QUrl &url )

{

  QDesktopServices::openUrl( url );

}


QString QgsMapTip::vectorMapTipPreviewText( QgsMapLayer *layer, QgsMapCanvas *mapCanvas, const QString &mapTemplate, const QString &displayExpression )

{

  // Only spatial layers can have map tips

  QgsVectorLayer *vlayer = qobject_cast<QgsVectorLayer *>( layer );

  if ( !mapCanvas || !vlayer || !vlayer->isSpatial() )

    return QString();


  // If no map tip template or display expression is set, return an empty string

  if ( mapTemplate.isEmpty() && displayExpression.isEmpty() )

    return QString();


  // Create an expression context

  QgsExpressionContext context( QgsExpressionContextUtils::globalProjectLayerScopes( vlayer ) );

  context.appendScope( QgsExpressionContextUtils::mapSettingsScope( mapCanvas->mapSettings() ) );


  // Get the first feature if any, and add it to the expression context

  QgsFeature previewFeature;

  if ( vlayer->featureCount() > 0 )

  {

    QgsFeatureIterator it = vlayer->getFeatures( QgsFeatureRequest().setLimit( 1 ) );

    it.nextFeature( previewFeature );

  }

  else

  {

    previewFeature = QgsFeature( vlayer->fields() );

  }

  context.setFeature( previewFeature );


  // Generate the map tip text from the context and the mapTipTemplate/displayExpression

  QString tipText;

  if ( mapTemplate.isEmpty() )

  {

    QgsExpression exp( displayExpression );

    exp.prepare( &context );

    tipText = exp.evaluate( &context ).toString();

  }

  else

  {

    tipText = QgsExpression::replaceExpressionText( mapTemplate, &context );

  }


  // Insert the map tip text into the html template

  return QgsMapTip::htmlText( tipText, mapCanvas->width() / 2 );


}


QString QgsMapTip::rasterMapTipPreviewText( QgsMapLayer *layer, QgsMapCanvas *mapCanvas, const QString &mapTemplate )

{

  QgsRasterLayer *rlayer = qobject_cast<QgsRasterLayer *>( layer );

  if ( !mapCanvas || !rlayer || mapTemplate.isEmpty() )

  {

    return QString();

  }


  // Create an expression context

  QgsExpressionContext context( QgsExpressionContextUtils::globalProjectLayerScopes( layer ) );

  context.appendScope( QgsExpressionContextUtils::mapSettingsScope( mapCanvas->mapSettings() ) );


  // Get the position of the center of the layer, and add it to the expression context

  const QgsPointXY mappedPosition { layer->extent().center() };

  context.appendScope( QgsExpressionContextUtils::mapLayerPositionScope( mappedPosition ) );


  // Generate the map tip text from the context and the mapTipTemplate

  const QString tipText = QgsExpression::replaceExpressionText( mapTemplate, &context );


  // Insert the map tip text into the html template

  return QgsMapTip::htmlText( tipText, mapCanvas->width() / 2 );

}

Qgis::UI_SCALE_FACTOR
static const double UI_SCALE_FACTOR
UI scaling factor.
Definition: qgis.h:3749

QgsApplication::instance
static QgsApplication * instance()
Returns the singleton instance of the QgsApplication.
Definition: qgsapplication.cpp:533

QgsExpressionContextUtils::mapLayerPositionScope
static QgsExpressionContextScope * mapLayerPositionScope(const QgsPointXY &position)
Sets the expression context variables which are available for expressions triggered by moving the mou...
Definition: qgsexpressioncontextutils.cpp:562

QgsExpressionContextUtils::mapSettingsScope
static QgsExpressionContextScope * mapSettingsScope(const QgsMapSettings &mapSettings)
Creates a new scope which contains variables and functions relating to a QgsMapSettings object.
Definition: qgsexpressioncontextutils.cpp:451

QgsExpressionContextUtils::globalProjectLayerScopes
static QList< QgsExpressionContextScope * > globalProjectLayerScopes(const QgsMapLayer *layer)
Creates a list of three scopes: global, layer's project and layer.
Definition: qgsexpressioncontextutils.cpp:401

QgsExpressionContextUtils::layerScope
static QgsExpressionContextScope * layerScope(const QgsMapLayer *layer)
Creates a new scope which contains variables and functions relating to a QgsMapLayer.
Definition: qgsexpressioncontextutils.cpp:358

QgsExpressionContext
Expression contexts are used to encapsulate the parameters around which a QgsExpression should be eva...
Definition: qgsexpressioncontext.h:481

QgsExpressionContext::appendScope
void appendScope(QgsExpressionContextScope *scope)
Appends a scope to the end of the context.
Definition: qgsexpressioncontext.cpp:598

QgsExpressionContext::setFeature
void setFeature(const QgsFeature &feature)
Convenience function for setting a feature for the context.
Definition: qgsexpressioncontext.cpp:629

QgsExpression
Class for parsing and evaluation of expressions (formerly called "search strings").
Definition: qgsexpression.h:188

QgsExpression::prepare
bool prepare(const QgsExpressionContext *context)
Gets the expression ready for evaluation - find out column indexes.
Definition: qgsexpression.cpp:332

QgsExpression::replaceExpressionText
static QString replaceExpressionText(const QString &action, const QgsExpressionContext *context, const QgsDistanceArea *distanceArea=nullptr)
This function replaces each expression between [% and %] in the string with the result of its evaluat...
Definition: qgsexpression.cpp:439

QgsExpression::evaluate
QVariant evaluate()
Evaluate the feature and return the result.
Definition: qgsexpression.cpp:355

QgsFeatureIterator
Wrapper for iterator of features from vector data provider or vector layer.
Definition: qgsfeatureiterator.h:290

QgsFeatureIterator::nextFeature
bool nextFeature(QgsFeature &f)
Definition: qgsfeatureiterator.h:399

QgsFeatureRenderer::Filter
@ Filter
Features may be filtered, i.e. some features may not be rendered (categorized, rule based ....
Definition: qgsrenderer.h:275

QgsFeatureRenderer::clone
virtual QgsFeatureRenderer * clone() const =0
Create a deep copy of this renderer.

QgsFeatureRequest
This class wraps a request for features to a vector layer (or directly its vector data provider).
Definition: qgsfeaturerequest.h:84

QgsFeatureRequest::combineFilterExpression
QgsFeatureRequest & combineFilterExpression(const QString &expression)
Modifies the existing filter expression to add an additional expression filter.
Definition: qgsfeaturerequest.cpp:174

QgsFeatureRequest::setFlags
QgsFeatureRequest & setFlags(QgsFeatureRequest::Flags flags)
Sets flags that affect how features will be fetched.
Definition: qgsfeaturerequest.cpp:222

QgsFeatureRequest::setSubsetOfAttributes
QgsFeatureRequest & setSubsetOfAttributes(const QgsAttributeList &attrs)
Set a subset of attributes that will be fetched.
Definition: qgsfeaturerequest.cpp:228

QgsFeatureRequest::setFilterExpression
QgsFeatureRequest & setFilterExpression(const QString &expression)
Set the filter expression.
Definition: qgsfeaturerequest.cpp:167

QgsFeatureRequest::ExactIntersect
@ ExactIntersect
Use exact geometry intersection (slower) instead of bounding boxes.
Definition: qgsfeaturerequest.h:91

QgsFeatureRequest::setExpressionContext
QgsFeatureRequest & setExpressionContext(const QgsExpressionContext &context)
Sets the expression context used to evaluate filter expressions.
Definition: qgsfeaturerequest.cpp:187

QgsFeatureRequest::setFilterRect
QgsFeatureRequest & setFilterRect(const QgsRectangle &rectangle)
Sets the rectangle from which features will be taken.
Definition: qgsfeaturerequest.cpp:101

QgsFeature
The feature class encapsulates a single feature including its unique ID, geometry and a list of field...
Definition: qgsfeature.h:56

QgsMapCanvasUtils::filterForLayer
static QString filterForLayer(QgsMapCanvas *canvas, QgsVectorLayer *layer)
Constructs a filter to use for selecting features from the given layer, in order to apply filters whi...
Definition: qgsmapcanvasutils.cpp:79

QgsMapCanvas
Map canvas is a class for displaying all GIS data types on a canvas.
Definition: qgsmapcanvas.h:90

QgsMapCanvas::createExpressionContext
QgsExpressionContext createExpressionContext() const override
This method needs to be reimplemented in all classes which implement this interface and return an exp...
Definition: qgsmapcanvas.cpp:693

QgsMapCanvas::temporalRange
const QgsDateTimeRange & temporalRange() const
Returns map canvas datetime range.
Definition: qgsmapcanvas.cpp:1295

QgsMapCanvas::layers
QList< QgsMapLayer * > layers(bool expandGroupLayers=false) const
Returns the list of layers shown within the map canvas.
Definition: qgsmapcanvas.cpp:2855

QgsMapCanvas::mapSettings
const QgsMapSettings & mapSettings() const
Gets access to properties used for map rendering.
Definition: qgsmapcanvas.cpp:488

QgsMapLayerTemporalProperties::isVisibleInTemporalRange
virtual bool isVisibleInTemporalRange(const QgsDateTimeRange &range) const
Returns true if the layer should be visible and rendered for the specified time range.
Definition: qgsmaplayertemporalproperties.cpp:25

QgsMapLayer
Base class for all map layer types.
Definition: qgsmaplayer.h:73

QgsMapLayer::isInScaleRange
bool isInScaleRange(double scale) const
Tests whether the layer should be visible at the specified scale.
Definition: qgsmaplayer.cpp:975

QgsMapLayer::extent
virtual QgsRectangle extent() const
Returns the extent of the layer.
Definition: qgsmaplayer.cpp:347

QgsMapLayer::type
Qgis::LayerType type
Definition: qgsmaplayer.h:80

QgsMapLayer::temporalProperties
virtual QgsMapLayerTemporalProperties * temporalProperties()
Returns the layer's temporal properties.
Definition: qgsmaplayer.h:1526

QgsMapLayer::mapTipsEnabled
bool mapTipsEnabled
Definition: qgsmaplayer.h:84

QgsMapLayer::mapTipTemplate
QString mapTipTemplate
Definition: qgsmaplayer.h:83

QgsMapSettings::scale
double scale() const
Returns the calculated map scale.
Definition: qgsmapsettings.cpp:459

QgsMapSettings::mapToLayerCoordinates
QgsPointXY mapToLayerCoordinates(const QgsMapLayer *layer, QgsPointXY point) const
transform point coordinates from output CRS to layer's CRS
Definition: qgsmapsettings.cpp:634

QgsMapTip::showMapTip
void showMapTip(QgsMapLayer *thepLayer, QgsPointXY &mapPosition, const QPoint &pixelPosition, QgsMapCanvas *mpMapCanvas)
Show a maptip at a given point on the map canvas.
Definition: qgsmaptip.cpp:86

QgsMapTip::rasterMapTipPreviewText
static QString rasterMapTipPreviewText(QgsMapLayer *layer, QgsMapCanvas *mapCanvas, const QString &mapTemplate)
Returns the html that would be displayed in a maptip for a given layer.
Definition: qgsmaptip.cpp:487

QgsMapTip::vectorMapTipPreviewText
static QString vectorMapTipPreviewText(QgsMapLayer *layer, QgsMapCanvas *mapCanvas, const QString &mapTemplate, const QString &displayExpression)
Returns the html that would be displayed in a maptip for a given layer.
Definition: qgsmaptip.cpp:441

QgsMapTip::QgsMapTip
QgsMapTip()
Default constructor.
Definition: qgsmaptip.cpp:77

QgsMapTip::clear
void clear(QgsMapCanvas *mpMapCanvas=nullptr, int msDelay=0)
Clear the current maptip if it exists.
Definition: qgsmaptip.cpp:255

QgsMapTool::searchRadiusMU
static double searchRadiusMU(const QgsRenderContext &context)
Gets search radius in map units for given context.
Definition: qgsmaptool.cpp:238

QgsPointXY
A class to represent a 2D point.
Definition: qgspointxy.h:59

QgsPointXY::y
double y
Definition: qgspointxy.h:63

QgsPointXY::x
Q_GADGET double x
Definition: qgspointxy.h:62

QgsRasterLayer
Represents a raster layer.
Definition: qgsrasterlayer.h:78

QgsRectangle
A rectangle specified with double values.
Definition: qgsrectangle.h:42

QgsRectangle::setYMinimum
void setYMinimum(double y) SIP_HOLDGIL
Set the minimum y value.
Definition: qgsrectangle.h:161

QgsRectangle::setXMaximum
void setXMaximum(double x) SIP_HOLDGIL
Set the maximum x value.
Definition: qgsrectangle.h:156

QgsRectangle::setXMinimum
void setXMinimum(double x) SIP_HOLDGIL
Set the minimum x value.
Definition: qgsrectangle.h:151

QgsRectangle::setYMaximum
void setYMaximum(double y) SIP_HOLDGIL
Set the maximum y value.
Definition: qgsrectangle.h:166

QgsRectangle::contains
bool contains(const QgsRectangle &rect) const SIP_HOLDGIL
Returns true when rectangle contains other rectangle.
Definition: qgsrectangle.h:363

QgsRectangle::center
QgsPointXY center() const SIP_HOLDGIL
Returns the center point of the rectangle.
Definition: qgsrectangle.h:251

QgsRenderContext
Contains information about the context of a rendering operation.
Definition: qgsrendercontext.h:61

QgsRenderContext::expressionContext
QgsExpressionContext & expressionContext()
Gets the expression context.
Definition: qgsrendercontext.h:652

QgsRenderContext::fromMapSettings
static QgsRenderContext fromMapSettings(const QgsMapSettings &mapSettings)
create initialized QgsRenderContext instance from given QgsMapSettings
Definition: qgsrendercontext.cpp:231

QgsRenderContext::setExpressionContext
void setExpressionContext(const QgsExpressionContext &context)
Sets the expression context.
Definition: qgsrendercontext.h:644

QgsSettings
This class is a composition of two QSettings instances:
Definition: qgssettings.h:63

QgsTemporalRangeObject::isTemporal
bool isTemporal() const
Returns true if the object's temporal range is enabled, and the object will be filtered when renderin...
Definition: qgstemporalrangeobject.cpp:30

QgsVectorLayer
Represents a vector layer which manages a vector based data sets.
Definition: qgsvectorlayer.h:399

QgsVectorLayer::featureCount
long long featureCount(const QString &legendKey) const
Number of features rendered with specified legend key.
Definition: qgsvectorlayer.cpp:901

QgsVectorLayer::isSpatial
bool isSpatial() const FINAL
Returns true if this is a geometry layer and false in case of NoGeometry (table only) or UnknownGeome...
Definition: qgsvectorlayer.cpp:3969

QgsVectorLayer::getFeatures
QgsFeatureIterator getFeatures(const QgsFeatureRequest &request=QgsFeatureRequest()) const FINAL
Queries the layer for features specified in request.
Definition: qgsvectorlayer.cpp:1166

QgsVectorLayer::fields
QgsFields fields() const FINAL
Returns the list of fields of this layer.
Definition: qgsvectorlayer.cpp:3628

QgsVectorLayer::renderer
QgsFeatureRenderer * renderer()
Returns the feature renderer used for rendering the features in the layer in 2D map views.
Definition: qgsvectorlayer.h:944

QgsVectorLayer::displayExpression
QString displayExpression
Definition: qgsvectorlayer.h:403

QgsWebView
The QgsWebView class is a collection of stubs to mimic the API of QWebView on systems where the real ...
Definition: qgswebview.h:66

qgsapplication.h

qgsexpression.h

qgsexpressioncontextutils.h

qgsfeatureiterator.h

qgslogger.h

QgsDebugMsgLevel
#define QgsDebugMsgLevel(str, level)
Definition: qgslogger.h:39

qgsmapcanvas.h

qgsmapcanvasutils.h

qgsmaplayertemporalproperties.h

qgsmaptip.h

qgsmaptool.h

qgsrasterlayer.h

qgsrendercontext.h

qgsrenderer.h

qgssettings.h

qgsvectorlayer.h

qgswebframe.h

qgswebview.h