qgsguiutils.cpp

Go to the documentation of this file.

/***************************************************************************
    qgsguiutils.cpp - Constants used throughout the QGIS GUI.
     --------------------------------------
    Date                 : 11-Jan-2006
    Copyright            : (C) 2006 by Tom Elwertowski
    Email                : telwertowski at users dot sourceforge dot net
 ***************************************************************************
 *                                                                         *
 *   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 "qgsguiutils.h"
 
#include "qgis.h"
#include "qgis_gui.h"
#include "qgsapplication.h"
#include "qgsencodingfiledialog.h"
#include "qgsfileutils.h"
#include "qgslogger.h"
#include "qgssettings.h"
 
#include <QApplication>
#include <QDockWidget>
#include <QFontDialog>
#include <QImageWriter>
#include <QMainWindow>
#include <QMenu>
#include <QMessageBox>
#include <QRegularExpression>
#include <QString>
#include <QTabBar>
 
using namespace Qt::StringLiterals;
 
namespace QgsGuiUtils
{
 
  bool GUI_EXPORT openFilesRememberingFilter( QString const &filterName, QString const &filters, QStringList &selectedFiles, QString &enc, QString &title, bool cancelAll )
  {
    Q_UNUSED( enc )
 
    QgsSettings settings;
    QString lastUsedFilter = settings.value( "/UI/" + filterName, "" ).toString();
    const QString lastUsedDir = settings.value( "/UI/" + filterName + "Dir", QDir::homePath() ).toString();
 
    QgsDebugMsgLevel( "Opening file dialog with filters: " + filters, 3 );
    if ( !cancelAll )
    {
      selectedFiles = QFileDialog::getOpenFileNames( nullptr, title, lastUsedDir, filters, &lastUsedFilter );
    }
    else //we have to use non-native dialog to add cancel all button
    {
      QgsEncodingFileDialog *openFileDialog = new QgsEncodingFileDialog( nullptr, title, lastUsedDir, filters, QString() );
 
      // allow for selection of more than one file
      openFileDialog->setFileMode( QFileDialog::ExistingFiles );
 
      if ( !lastUsedFilter.isEmpty() )
      {
        openFileDialog->selectNameFilter( lastUsedFilter );
      }
      openFileDialog->addCancelAll();
      if ( openFileDialog->exec() == QDialog::Accepted )
      {
        selectedFiles = openFileDialog->selectedFiles();
      }
      else
      {
        //cancel or cancel all?
        if ( openFileDialog->cancelAll() )
        {
          return true;
        }
      }
    }
 
    if ( !selectedFiles.isEmpty() )
    {
      // Fix by Tim - getting the dirPath from the dialog
      // directly truncates the last node in the dir path.
      // This is a workaround for that
      const QString firstFileName = selectedFiles.first();
      const QFileInfo fi( firstFileName );
      const QString path = fi.path();
 
      QgsDebugMsgLevel( "Writing last used dir: " + path, 2 );
 
      settings.setValue( "/UI/" + filterName, lastUsedFilter );
      settings.setValue( "/UI/" + filterName + "Dir", path );
    }
    return false;
  }
 
  QPair<QString, QString> GUI_EXPORT getSaveAsImageName( QWidget *parent, const QString &message, const QString &defaultFilename )
  {
    // get a list of supported output image types
    QMap<QString, QString> filterMap;
    const auto supportedImageFormats { QImageWriter::supportedImageFormats() };
    QStringList imageFormats;
    // add PNG format first for certain file dialog to auto-fill from first listed extension
    imageFormats << u"*.png *.PNG"_s;
    for ( const QByteArray &format : supportedImageFormats )
    {
      // svg doesn't work so skip it
      if ( format == "svg" )
      {
        continue;
      }
 
      filterMap.insert( createFileFilter_( format ), format );
 
      if ( format != "png" )
      {
        imageFormats << u"*.%1 *.%2"_s.arg( format, QString( format ).toUpper() );
      }
    }
    const QString formatByExtension = u"%1 (%2)"_s.arg( QObject::tr( "Format by Extension" ), imageFormats.join( ' '_L1 ) );
 
#ifdef QGISDEBUG
    QgsDebugMsgLevel( u"Available Filters Map: "_s, 2 );
    for ( QMap<QString, QString>::iterator it = filterMap.begin(); it != filterMap.end(); ++it )
    {
      QgsDebugMsgLevel( it.key() + "  :  " + it.value(), 2 );
    }
#endif
 
    QgsSettings settings; // where we keep last used filter in persistent state
    const QString lastUsedDir = settings.value( u"UI/lastSaveAsImageDir"_s, QDir::homePath() ).toString();
 
    QString selectedFilter = settings.value( u"UI/lastSaveAsImageFilter"_s, QString() ).toString();
    if ( selectedFilter.isEmpty() )
    {
      selectedFilter = formatByExtension;
    }
 
    QString initialPath;
    if ( defaultFilename.isNull() )
    {
      //no default filename provided, just use last directory
      initialPath = lastUsedDir;
    }
    else
    {
      //a default filename was provided, so use it to build the initial path
      initialPath = QDir( lastUsedDir ).filePath( defaultFilename );
    }
 
    QString outputFileName;
    QString ext;
#if defined( Q_OS_WIN ) || defined( Q_OS_MAC ) || defined( Q_OS_LINUX )
    outputFileName = QFileDialog::getSaveFileName( parent, message, initialPath, formatByExtension + u";;"_s + qgsMapJoinKeys( filterMap, u";;"_s ), &selectedFilter );
#else
    //create a file dialog using the filter list generated above
    auto fileDialog = std::make_unique<QFileDialog>( parent, message, initialPath, formatByExtension + u";;"_s + qgsMapJoinKeys( filterMap, u";;"_s ) );
 
    // allow for selection of more than one file
    fileDialog->setFileMode( QFileDialog::AnyFile );
    fileDialog->setAcceptMode( QFileDialog::AcceptSave );
    fileDialog->setOption( QFileDialog::DontConfirmOverwrite, false );
 
    if ( !selectedFilter.isEmpty() ) // set the filter to the last one used
    {
      fileDialog->selectNameFilter( selectedFilter );
    }
 
    //prompt the user for a fileName
    if ( fileDialog->exec() == QDialog::Accepted )
    {
      outputFileName = fileDialog->selectedFiles().first();
    }
#endif
 
    if ( !outputFileName.isNull() )
    {
      if ( selectedFilter == formatByExtension )
      {
        settings.setValue( u"UI/lastSaveAsImageFilter"_s, QString() );
        ext = QFileInfo( outputFileName ).suffix();
 
        auto match = std::find_if( filterMap.begin(), filterMap.end(), [&ext]( const QString &filter ) { return filter == ext; } );
        if ( match == filterMap.end() )
        {
          // Use "png" format when extension missing or not matching
          ext = u"png"_s;
          selectedFilter = createFileFilter_( ext );
          outputFileName = QgsFileUtils::addExtensionFromFilter( outputFileName, selectedFilter );
        }
      }
      else
      {
        ext = filterMap.value( selectedFilter, QString() );
        if ( !ext.isEmpty() )
        {
          outputFileName = QgsFileUtils::addExtensionFromFilter( outputFileName, selectedFilter );
          settings.setValue( u"UI/lastSaveAsImageFilter"_s, selectedFilter );
        }
      }
      settings.setValue( u"UI/lastSaveAsImageDir"_s, QFileInfo( outputFileName ).absolutePath() );
    }
 
    return qMakePair( outputFileName, ext );
  }
 
  QString createFileFilter_( QString const &longName, QString const &glob )
  {
    return u"%1 (%2 %3)"_s.arg( longName, glob.toLower(), glob.toUpper() );
  }
 
  QString createFileFilter_( QString const &format )
  {
    const QString longName = format.toUpper() + " format";
    const QString glob = "*." + format;
    return createFileFilter_( longName, glob );
  }
 
  QFont getFont( bool &ok, const QFont &initial, const QString &title )
  {
    // parent is intentionally not set to 'this' as
    // that would make it follow the style sheet font
    // see also #12233 and #4937
#if defined( Q_OS_MAC )
    // Native dialog broken on macOS with Qt5
    // probably only broken in Qt5.11.1 and .2
    //    (see https://successfulsoftware.net/2018/11/02/qt-is-broken-on-macos-right-now/ )
    // possible upstream bug: https://bugreports.qt.io/browse/QTBUG-69878 (fixed in Qt 5.12 ?)
    return QFontDialog::getFont( &ok, initial, nullptr, title, QFontDialog::DontUseNativeDialog );
#else
    return QFontDialog::getFont( &ok, initial, nullptr, title );
#endif
  }
 
  void saveGeometry( QWidget *widget, const QString &keyName )
  {
    QgsSettings settings;
    const QString key = createWidgetKey( widget, keyName );
    settings.setValue( key, widget->saveGeometry() );
  }
 
  bool restoreGeometry( QWidget *widget, const QString &keyName )
  {
    const QgsSettings settings;
    const QString key = createWidgetKey( widget, keyName );
    return widget->restoreGeometry( settings.value( key ).toByteArray() );
  }
 
  QString createWidgetKey( QWidget *widget, const QString &keyName )
  {
    QString subKey;
    if ( !keyName.isEmpty() )
    {
      subKey = keyName;
    }
    else if ( widget->objectName().isEmpty() )
    {
      subKey = QString( widget->metaObject()->className() );
    }
    else
    {
      subKey = widget->objectName();
    }
    QString key = u"Windows/%1/geometry"_s.arg( subKey );
    return key;
  }
 
  int scaleIconSize( int standardSize )
  {
    return QgsApplication::scaleIconSize( standardSize );
  }
 
  QSize iconSize( bool dockableToolbar )
  {
    const QgsSettings s;
    const int w = s.value( u"/qgis/toolbarIconSize"_s, 32 ).toInt();
    QSize size( w, w );
 
    if ( dockableToolbar )
    {
      size = panelIconSize( size );
    }
 
    return size;
  }
 
  QSize panelIconSize( QSize size )
  {
    int adjustedSize = 16;
    if ( size.width() > 32 )
    {
      adjustedSize = size.width() - 16;
    }
    else if ( size.width() == 32 )
    {
      adjustedSize = 24;
    }
    return QSize( adjustedSize, adjustedSize );
  }
 
  QString displayValueWithMaximumDecimals( const Qgis::DataType dataType, const double value, bool displayTrailingZeroes )
  {
    const int precision { significantDigits( dataType ) };
    QString result { QLocale().toString( value, 'f', precision ) };
    if ( !displayTrailingZeroes )
    {
      const QRegularExpression zeroesRe { QStringLiteral( R"raw(\%1\d*?(0+$))raw" ).arg( QLocale().decimalPoint() ) };
      if ( zeroesRe.match( result ).hasMatch() )
      {
        result.truncate( zeroesRe.match( result ).capturedStart( 1 ) );
        if ( result.endsWith( QLocale().decimalPoint() ) )
        {
          result.chop( 1 );
        }
      }
    }
    return result;
  }
 
  int significantDigits( const Qgis::DataType rasterDataType )
  {
    switch ( rasterDataType )
    {
      case Qgis::DataType::Int16:
      case Qgis::DataType::UInt16:
      case Qgis::DataType::Int32:
      case Qgis::DataType::UInt32:
      case Qgis::DataType::Byte:
      case Qgis::DataType::Int8:
      case Qgis::DataType::CInt16:
      case Qgis::DataType::CInt32:
      case Qgis::DataType::ARGB32:
      case Qgis::DataType::ARGB32_Premultiplied:
      {
        return 0;
      }
      case Qgis::DataType::Float32:
      case Qgis::DataType::CFloat32:
      {
        return std::numeric_limits<float>::digits10 + 1;
      }
      case Qgis::DataType::Float64:
      case Qgis::DataType::CFloat64:
      {
        return std::numeric_limits<double>::digits10 + 1;
      }
      case Qgis::DataType::UnknownDataType:
      {
        return std::numeric_limits<double>::digits10 + 1;
      }
    }
    return 0;
  }
 
  bool isNonStandardGeoPackageGeometryType( Qgis::WkbType wkbType )
  {
    const Qgis::WkbType flatType = QgsWkbTypes::flatType( wkbType );
    return ( flatType == Qgis::WkbType::PolyhedralSurface || flatType == Qgis::WkbType::TIN || flatType == Qgis::WkbType::Triangle );
  }
 
  bool warnAboutNonStandardGeoPackageGeometryType( Qgis::WkbType wkbType, QWidget *parent, const QString &dialogTitle, bool showDialog, bool *isNonStandard )
  {
    const bool nonStandard = isNonStandardGeoPackageGeometryType( wkbType );
 
    if ( isNonStandard )
    {
      *isNonStandard = nonStandard;
    }
 
    if ( !nonStandard )
    {
      return true;
    }
 
    if ( !showDialog )
    {
      return true;
    }
 
    return QMessageBox::question(
             parent,
             dialogTitle,
             QObject::tr(
               "PolyhedralSurface, TIN and Triangle are non-standard GeoPackage geometry types "
               "and may not be recognized by other software.\n\n"
               "Do you want to continue?"
             ),
             QMessageBox::Yes | QMessageBox::No,
             QMessageBox::No
           )
           == QMessageBox::Yes;
  }
 
  void addDockWidget( QMainWindow *window, Qt::DockWidgetArea area, QDockWidget *dockwidget )
  {
    window->addDockWidget( area, dockwidget );
    // Make the right and left docks consume all vertical space and top
    // and bottom docks nest between them
    window->setCorner( Qt::TopLeftCorner, Qt::LeftDockWidgetArea );
    window->setCorner( Qt::BottomLeftCorner, Qt::LeftDockWidgetArea );
    window->setCorner( Qt::TopRightCorner, Qt::RightDockWidgetArea );
    window->setCorner( Qt::BottomRightCorner, Qt::RightDockWidgetArea );
    // add to the Panel submenu, if it exists
    if ( auto menu = window->findChild< QMenu * >( u"mPanelMenu"_s ) )
    {
      menu->addAction( dockwidget->toggleViewAction() );
    }
 
    dockwidget->show();
  }
 
  void addTabifiedDockWidget( QMainWindow *window, Qt::DockWidgetArea area, QDockWidget *dockWidget, const QStringList &tabifyWith, bool raiseTab )
  {
    QList<QDockWidget *> dockWidgetsInArea;
    const QList<QDockWidget *> allDockWidgets = window->findChildren<QDockWidget *>();
    for ( QDockWidget *w : allDockWidgets )
    {
      if ( w->isVisible() && window->dockWidgetArea( w ) == area )
      {
        dockWidgetsInArea << w;
      }
    }
 
    addDockWidget( window, area, dockWidget ); // First add the dock widget, then attempt to tabify
    if ( dockWidgetsInArea.empty() )
      return;
 
    // Get the base dock widget that we'll use to tabify our new dockWidget
    QDockWidget *tabifyWithDockWidget = nullptr;
    for ( const QString &targetName : tabifyWith )
    {
      auto it = std::find_if( dockWidgetsInArea.begin(), dockWidgetsInArea.end(), [&targetName]( QDockWidget *cw ) {
        return cw->objectName() == targetName || cw->property( "dock_uuid" ).toString() == targetName;
      } );
 
      if ( it != dockWidgetsInArea.end() )
      {
        tabifyWithDockWidget = *it;
        break;
      }
    }
 
    if ( !tabifyWithDockWidget )
    {
      // fallback to the first available dock widget if no matches were found, or if no tabifyWith names were specified
      tabifyWithDockWidget = dockWidgetsInArea.at( 0 );
    }
    if ( tabifyWithDockWidget == dockWidget )
      return;
 
    // find the currently active dock widget so that we can restore that if we're not raising the new tab
    QTabBar *existingTabBar = nullptr;
    int currentTabIndex = -1;
    if ( !raiseTab && dockWidgetsInArea.length() > 1 )
    {
      // Chances are we've already got a tabBar, if so, get
      // currentTabIndex to restore status after inserting our new tab
      const QList<QTabBar *> tabBars = window->findChildren<QTabBar *>( QString(), Qt::FindDirectChildrenOnly );
      bool tabBarFound = false;
      for ( QTabBar *tabBar : tabBars )
      {
        for ( int i = 0; i < tabBar->count(); i++ )
        {
          if ( tabBar->tabText( i ) == tabifyWithDockWidget->windowTitle() )
          {
            existingTabBar = tabBar;
            currentTabIndex = tabBar->currentIndex();
            tabBarFound = true;
            break;
          }
        }
        if ( tabBarFound )
        {
          break;
        }
      }
    }
 
    // Now we can put the new dockWidget on top of tabifyWith
    window->tabifyDockWidget( tabifyWithDockWidget, dockWidget );
 
    // Should we restore dock widgets status?
    if ( !raiseTab )
    {
      if ( existingTabBar )
      {
        existingTabBar->setCurrentIndex( currentTabIndex );
      }
      else
      {
        tabifyWithDockWidget->raise(); // Single base dock widget, we can just raise it
      }
    }
  }
 
} // namespace QgsGuiUtils
 
//
// QgsTemporaryCursorOverride
//
 
QgsTemporaryCursorOverride::QgsTemporaryCursorOverride( const QCursor &cursor )
{
  QApplication::setOverrideCursor( cursor );
}
 
QgsTemporaryCursorOverride::~QgsTemporaryCursorOverride()
{
  if ( mHasOverride )
    QApplication::restoreOverrideCursor();
}
 
void QgsTemporaryCursorOverride::release()
{
  if ( !mHasOverride )
    return;
 
  mHasOverride = false;
  QApplication::restoreOverrideCursor();
}
 
 
//
// QgsTemporaryCursorRestoreOverride
//
 
QgsTemporaryCursorRestoreOverride::QgsTemporaryCursorRestoreOverride()
{
  while ( QApplication::overrideCursor() )
  {
    mCursors.emplace_back( QCursor( *QApplication::overrideCursor() ) );
    QApplication::restoreOverrideCursor();
  }
}
 
QgsTemporaryCursorRestoreOverride::~QgsTemporaryCursorRestoreOverride()
{
  restore();
}
 
void QgsTemporaryCursorRestoreOverride::restore()
{
  for ( auto it = mCursors.rbegin(); it != mCursors.rend(); ++it )
  {
    QApplication::setOverrideCursor( *it );
  }
  mCursors.clear();
}
 
//
// QWidgetUpdateBlocker
//
 
QWidgetUpdateBlocker::QWidgetUpdateBlocker( QWidget *widget )
  : mWidget( widget )
{
  mWidget->setUpdatesEnabled( false );
}
 
void QWidgetUpdateBlocker::release()
{
  if ( !mWidget )
    return;
 
  mWidget->setUpdatesEnabled( true );
  mWidget = nullptr;
}
 
QWidgetUpdateBlocker::~QWidgetUpdateBlocker()
{
  release();
}