vcl/inc/qt5/QtTools.hxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #pragma once
  21
  22 #include <config_vclplug.h>
  23
  24 #include <QtCore/QPoint>
  25 #include <QtCore/QRect>
  26 #include <QtCore/QSize>
  27 #include <QtCore/QString>
  28 #include <QtGui/QImage>
  29
  30 #include <rtl/string.hxx>
  31 #include <rtl/ustring.hxx>
  32 #include <tools/color.hxx>
  33 #include <tools/gen.hxx>
  34 #include <vcl/bitmap/BitmapTypes.hxx>
  35
  36 #include <com/sun/star/uno/Sequence.hxx>
  37 #include <com/sun/star/datatransfer/dnd/DNDConstants.hpp>
  38
  39 #include <memory>
  40
  41 class Image;
  42 class QImage;
  43
  44 inline OUString toOUString(const QString& s)
  45 {
  46     // QString stores UTF16, just like OUString
  47     return OUString(reinterpret_cast<const sal_Unicode*>(s.data()), s.length());
  48 }
  49
  50 inline QString toQString(const OUString& s)
  51 {
  52     return QString::fromUtf16(s.getStr(), s.getLength());
  53 }
  54
  55 inline QRect toQRect(const tools::Rectangle& rRect)
  56 {
  57     return QRect(rRect.Left(), rRect.Top(), rRect.GetWidth(), rRect.GetHeight());
  58 }
  59
  60 inline QRect toQRect(const AbsoluteScreenPixelRectangle& rRect, const qreal fScale)
  61 {
  62     return QRect(floor(rRect.Left() * fScale), floor(rRect.Top() * fScale),
  63                  ceil(rRect.GetWidth() * fScale), ceil(rRect.GetHeight() * fScale));
  64 }
  65
  66 inline QRect scaledQRect(const QRect& rRect, const qreal fScale)
  67 {
  68     return QRect(floor(rRect.x() * fScale), floor(rRect.y() * fScale), ceil(rRect.width() * fScale),
  69                  ceil(rRect.height() * fScale));
  70 }
  71
  72 inline tools::Rectangle toRectangle(const QRect& rRect)
  73 {
  74     return tools::Rectangle(rRect.left(), rRect.top(), rRect.right(), rRect.bottom());
  75 }
  76
  77 inline QSize toQSize(const Size& rSize) { return QSize(rSize.Width(), rSize.Height()); }
  78
  79 inline Size toSize(const QSize& rSize) { return Size(rSize.width(), rSize.height()); }
  80
  81 inline Point toPoint(const QPoint& rPoint) { return Point(rPoint.x(), rPoint.y()); }
  82
  83 inline QColor toQColor(const Color& rColor)
  84 {
  85     return QColor(rColor.GetRed(), rColor.GetGreen(), rColor.GetBlue(), rColor.GetAlpha());
  86 }
  87
  88 Qt::DropActions toQtDropActions(sal_Int8 dragOperation);
  89 sal_Int8 toVclDropActions(Qt::DropActions dragOperation);
  90 sal_Int8 toVclDropAction(Qt::DropAction dragOperation);
  91 Qt::DropAction getPreferredDropAction(sal_Int8 dragOperation);
  92
  93 inline QList<int> toQList(const css::uno::Sequence<sal_Int32>& aSequence)
  94 {
  95     QList<int> aList;
  96     for (sal_Int32 i : aSequence)
  97     {
  98         aList.append(i);
  99     }
 100     return aList;
 101 }
 102
 103 constexpr QImage::Format Qt_DefaultFormat32 = QImage::Format_ARGB32;
 104
 105 inline QImage::Format getBitFormat(vcl::PixelFormat ePixelFormat)
 106 {
 107     switch (ePixelFormat)
 108     {
 109         case vcl::PixelFormat::N8_BPP:
 110             return QImage::Format_Indexed8;
 111         case vcl::PixelFormat::N24_BPP:
 112             return QImage::Format_RGB888;
 113         case vcl::PixelFormat::N32_BPP:
 114             return Qt_DefaultFormat32;
 115         default:
 116             std::abort();
 117             break;
 118     }
 119     return QImage::Format_Invalid;
 120 }
 121
 122 inline sal_uInt16 getFormatBits(QImage::Format eFormat)
 123 {
 124     switch (eFormat)
 125     {
 126         case QImage::Format_Mono:
 127             return 1;
 128         case QImage::Format_Indexed8:
 129             return 8;
 130         case QImage::Format_RGB888:
 131             return 24;
 132         case Qt_DefaultFormat32:
 133         case QImage::Format_ARGB32_Premultiplied:
 134             return 32;
 135         default:
 136             std::abort();
 137             return 0;
 138     }
 139 }
 140
 141 typedef struct _cairo_surface cairo_surface_t;
 142 struct CairoDeleter
 143 {
 144     void operator()(cairo_surface_t* pSurface) const;
 145 };
 146
 147 typedef std::unique_ptr<cairo_surface_t, CairoDeleter> UniqueCairoSurface;
 148
 149 sal_uInt16 GetKeyModCode(Qt::KeyboardModifiers eKeyModifiers);
 150 sal_uInt16 GetMouseModCode(Qt::MouseButtons eButtons);
 151
 152 QImage toQImage(const Image& rImage);
 153
 154 template <typename charT, typename traits>
 155 inline std::basic_ostream<charT, traits>& operator<<(std::basic_ostream<charT, traits>& stream,
 156                                                      const QString& rString)
 157 {
 158     return stream << toOUString(rString);
 159 }
 160
 161 template <typename charT, typename traits>
 162 inline std::basic_ostream<charT, traits>& operator<<(std::basic_ostream<charT, traits>& stream,
 163                                                      const QRect& rRect)
 164 {
 165     return stream << toRectangle(rRect);
 166 }
 167
 168 template <typename charT, typename traits>
 169 inline std::basic_ostream<charT, traits>& operator<<(std::basic_ostream<charT, traits>& stream,
 170                                                      const QSize& rSize)
 171 {
 172     return stream << toSize(rSize);
 173 }
 174
 175 template <typename charT, typename traits>
 176 inline std::basic_ostream<charT, traits>& operator<<(std::basic_ostream<charT, traits>& stream,
 177                                                      const QPoint& rPoint)
 178 {
 179     return stream << toPoint(rPoint);
 180 }
 181
 182 #define CHECK_QT5_USING_X11 (QT_VERSION < QT_VERSION_CHECK(6, 0, 0) && QT5_USING_X11)
 183
 184 #define CHECK_QT6_USING_X11 (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0) && QT6_USING_X11)
 185
 186 #define CHECK_ANY_QT_USING_X11 CHECK_QT5_USING_X11 || CHECK_QT6_USING_X11
 187
 188 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */