vcl/qt5/QtTransferable.cxx

   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  */
  10
  11 #include <QtTransferable.hxx>
  12
  13 #include <comphelper/sequence.hxx>
  14 #include <sal/log.hxx>
  15 #include <o3tl/string_view.hxx>
  16
  17 #include <QtWidgets/QApplication>
  18
  19 #include <QtInstance.hxx>
  20 #include <QtTools.hxx>
  21
  22 #include <cassert>
  23
  24 static bool lcl_textMimeInfo(std::u16string_view rMimeString, bool& bHaveNoCharset,
  25                              bool& bHaveUTF16, bool& bHaveUTF8)
  26 {
  27     sal_Int32 nIndex = 0;
  28     if (o3tl::getToken(rMimeString, 0, ';', nIndex) == u"text/plain")
  29     {
  30         std::u16string_view aToken(o3tl::getToken(rMimeString, 0, ';', nIndex));
  31         if (aToken == u"charset=utf-16")
  32             bHaveUTF16 = true;
  33         else if (aToken == u"charset=utf-8")
  34             bHaveUTF8 = true;
  35         else if (aToken.empty())
  36             bHaveNoCharset = true;
  37         else // we just handle UTF-16 and UTF-8, everything else is "bytes"
  38             return false;
  39         return true;
  40     }
  41     return false;
  42 }
  43
  44 QtTransferable::QtTransferable(const QMimeData* pMimeData)
  45     : m_pMimeData(pMimeData)
  46     , m_bProvideUTF16FromOtherEncoding(false)
  47 {
  48     assert(pMimeData);
  49 }
  50
  51 css::uno::Sequence<css::datatransfer::DataFlavor> SAL_CALL QtTransferable::getTransferDataFlavors()
  52 {
  53     // it's just filled once, ever, so just try to get it without locking first
  54     if (m_aMimeTypeSeq.hasElements())
  55         return m_aMimeTypeSeq;
  56
  57     // better safe then sorry; preventing broken usage
  58     // DnD should not be shared and Clipboard access runs in the GUI thread
  59     osl::MutexGuard aGuard(m_aMutex);
  60     if (m_aMimeTypeSeq.hasElements())
  61         return m_aMimeTypeSeq;
  62
  63     QStringList aFormatList(m_pMimeData->formats());
  64     // we might add the UTF-16 mime text variant later
  65     const int nMimeTypeSeqSize = aFormatList.size() + 1;
  66     bool bHaveNoCharset = false, bHaveUTF16 = false, bHaveUTF8 = false;
  67     css::uno::Sequence<css::datatransfer::DataFlavor> aMimeTypeSeq(nMimeTypeSeqSize);
  68     auto pMimeTypeSeq = aMimeTypeSeq.getArray();
  69
  70     css::datatransfer::DataFlavor aFlavor;
  71     int nMimeTypeCount = 0;
  72
  73     for (const QString& rMimeType : aFormatList)
  74     {
  75         // filter out non-MIME types such as TARGETS, MULTIPLE, TIMESTAMP
  76         if (rMimeType.indexOf('/') == -1)
  77             continue;
  78
  79         // gtk3 thinks it is not well defined - skip too
  80         if (rMimeType == QStringLiteral("text/plain;charset=unicode"))
  81             continue;
  82
  83         // LO doesn't like 'text/plain', so we have to provide UTF-16
  84         bool bIsNoCharset = false, bIsUTF16 = false, bIsUTF8 = false;
  85         if (lcl_textMimeInfo(toOUString(rMimeType), bIsNoCharset, bIsUTF16, bIsUTF8))
  86         {
  87             bHaveNoCharset |= bIsNoCharset;
  88             bHaveUTF16 |= bIsUTF16;
  89             bHaveUTF8 |= bIsUTF8;
  90             if (bIsUTF16)
  91                 aFlavor.DataType = cppu::UnoType<OUString>::get();
  92             else
  93                 aFlavor.DataType = cppu::UnoType<css::uno::Sequence<sal_Int8>>::get();
  94         }
  95         else
  96             aFlavor.DataType = cppu::UnoType<css::uno::Sequence<sal_Int8>>::get();
  97
  98         aFlavor.MimeType = toOUString(rMimeType);
  99         assert(nMimeTypeCount < nMimeTypeSeqSize);
 100         pMimeTypeSeq[nMimeTypeCount] = aFlavor;
 101         nMimeTypeCount++;
 102     }
 103
 104     m_bProvideUTF16FromOtherEncoding = (bHaveNoCharset || bHaveUTF8) && !bHaveUTF16;
 105     if (m_bProvideUTF16FromOtherEncoding)
 106     {
 107         aFlavor.MimeType = "text/plain;charset=utf-16";
 108         aFlavor.DataType = cppu::UnoType<OUString>::get();
 109         assert(nMimeTypeCount < nMimeTypeSeqSize);
 110         pMimeTypeSeq[nMimeTypeCount] = aFlavor;
 111         nMimeTypeCount++;
 112     }
 113
 114     aMimeTypeSeq.realloc(nMimeTypeCount);
 115
 116     m_aMimeTypeSeq = aMimeTypeSeq;
 117     return m_aMimeTypeSeq;
 118 }
 119
 120 sal_Bool SAL_CALL
 121 QtTransferable::isDataFlavorSupported(const css::datatransfer::DataFlavor& rFlavor)
 122 {
 123     const auto aSeq = getTransferDataFlavors();
 124     return std::any_of(aSeq.begin(), aSeq.end(), [&](const css::datatransfer::DataFlavor& aFlavor) {
 125         return rFlavor.MimeType == aFlavor.MimeType;
 126     });
 127 }
 128
 129 css::uno::Any SAL_CALL QtTransferable::getTransferData(const css::datatransfer::DataFlavor& rFlavor)
 130 {
 131     css::uno::Any aAny;
 132     if (!isDataFlavorSupported(rFlavor))
 133         return aAny;
 134
 135     if (rFlavor.MimeType == "text/plain;charset=utf-16")
 136     {
 137         OUString aString;
 138         if (m_bProvideUTF16FromOtherEncoding)
 139         {
 140             if (m_pMimeData->hasFormat("text/plain;charset=utf-8"))
 141             {
 142                 QByteArray aByteData(m_pMimeData->data(QStringLiteral("text/plain;charset=utf-8")));
 143                 aString = OUString::fromUtf8(reinterpret_cast<const char*>(aByteData.data()));
 144             }
 145             else
 146             {
 147                 QByteArray aByteData(m_pMimeData->data(QStringLiteral("text/plain")));
 148                 aString = OUString(reinterpret_cast<const char*>(aByteData.data()),
 149                                    aByteData.size(), osl_getThreadTextEncoding());
 150             }
 151         }
 152         else
 153         {
 154             QByteArray aByteData(m_pMimeData->data(toQString(rFlavor.MimeType)));
 155             aString = OUString(reinterpret_cast<const sal_Unicode*>(aByteData.data()),
 156                                aByteData.size() / 2);
 157         }
 158         aAny <<= aString;
 159     }
 160     else
 161     {
 162         QByteArray aByteData(m_pMimeData->data(toQString(rFlavor.MimeType)));
 163         css::uno::Sequence<sal_Int8> aSeq(reinterpret_cast<const sal_Int8*>(aByteData.data()),
 164                                           aByteData.size());
 165         aAny <<= aSeq;
 166     }
 167
 168     return aAny;
 169 }
 170
 171 QtClipboardTransferable::QtClipboardTransferable(const QClipboard::Mode aMode,
 172                                                  const QMimeData* pMimeData)
 173     : QtTransferable(pMimeData)
 174     , m_aMode(aMode)
 175 {
 176 }
 177
 178 bool QtClipboardTransferable::hasInFlightChanged() const
 179 {
 180     const bool bChanged(mimeData() != QApplication::clipboard()->mimeData(m_aMode));
 181     SAL_WARN_IF(bChanged, "vcl.qt", "In flight clipboard change detected - broken clipboard read!");
 182     return bChanged;
 183 }
 184
 185 css::uno::Any SAL_CALL
 186 QtClipboardTransferable::getTransferData(const css::datatransfer::DataFlavor& rFlavor)
 187 {
 188     css::uno::Any aAny;
 189     auto* pSalInst(GetQtInstance());
 190     SolarMutexGuard g;
 191     pSalInst->RunInMainThread([&, this]() {
 192         if (!hasInFlightChanged())
 193             aAny = QtTransferable::getTransferData(rFlavor);
 194     });
 195     return aAny;
 196 }
 197
 198 css::uno::Sequence<css::datatransfer::DataFlavor>
 199     SAL_CALL QtClipboardTransferable::getTransferDataFlavors()
 200 {
 201     css::uno::Sequence<css::datatransfer::DataFlavor> aSeq;
 202     auto* pSalInst(GetQtInstance());
 203     SolarMutexGuard g;
 204     pSalInst->RunInMainThread([&, this]() {
 205         if (!hasInFlightChanged())
 206             aSeq = QtTransferable::getTransferDataFlavors();
 207     });
 208     return aSeq;
 209 }
 210
 211 sal_Bool SAL_CALL
 212 QtClipboardTransferable::isDataFlavorSupported(const css::datatransfer::DataFlavor& rFlavor)
 213 {
 214     bool bIsSupported = false;
 215     auto* pSalInst(GetQtInstance());
 216     SolarMutexGuard g;
 217     pSalInst->RunInMainThread([&, this]() {
 218         if (!hasInFlightChanged())
 219             bIsSupported = QtTransferable::isDataFlavorSupported(rFlavor);
 220     });
 221     return bIsSupported;
 222 }
 223
 224 QtMimeData::QtMimeData(const css::uno::Reference<css::datatransfer::XTransferable>& xTrans)
 225     : m_aContents(xTrans)
 226     , m_bHaveNoCharset(false)
 227     , m_bHaveUTF8(false)
 228 {
 229     assert(xTrans.is());
 230 }
 231
 232 bool QtMimeData::deepCopy(QMimeData** const pMimeCopy) const
 233 {
 234     if (!pMimeCopy)
 235         return false;
 236
 237     QMimeData* pMimeData = new QMimeData();
 238     for (QString& format : formats())
 239     {
 240         QByteArray aData = data(format);
 241         // Checking for custom MIME types
 242         if (format.startsWith("application/x-qt"))
 243         {
 244             // Retrieving true format name
 245             int indexBegin = format.indexOf('"') + 1;
 246             int indexEnd = format.indexOf('"', indexBegin);
 247             format = format.mid(indexBegin, indexEnd - indexBegin);
 248         }
 249         pMimeData->setData(format, aData);
 250     }
 251
 252     *pMimeCopy = pMimeData;
 253     return true;
 254 }
 255
 256 QStringList QtMimeData::formats() const
 257 {
 258     if (!m_aMimeTypeList.isEmpty())
 259         return m_aMimeTypeList;
 260
 261     const css::uno::Sequence<css::datatransfer::DataFlavor> aFormats
 262         = m_aContents->getTransferDataFlavors();
 263     QStringList aList;
 264     bool bHaveUTF16 = false;
 265
 266     for (const auto& rFlavor : aFormats)
 267     {
 268         aList << toQString(rFlavor.MimeType);
 269         lcl_textMimeInfo(rFlavor.MimeType, m_bHaveNoCharset, bHaveUTF16, m_bHaveUTF8);
 270     }
 271
 272     // we provide a locale encoded and a UTF-8 variant, if missing
 273     if (m_bHaveNoCharset || bHaveUTF16 || m_bHaveUTF8)
 274     {
 275         // if there is a text representation from LO point of view, it'll be UTF-16
 276         assert(bHaveUTF16);
 277         if (!m_bHaveUTF8)
 278             aList << QStringLiteral("text/plain;charset=utf-8");
 279         if (!m_bHaveNoCharset)
 280             aList << QStringLiteral("text/plain");
 281     }
 282
 283     m_aMimeTypeList = aList;
 284     return m_aMimeTypeList;
 285 }
 286
 287 #if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
 288 QVariant QtMimeData::retrieveData(const QString& mimeType, QVariant::Type) const
 289 #else
 290 QVariant QtMimeData::retrieveData(const QString& mimeType, QMetaType) const
 291 #endif
 292 {
 293     if (!hasFormat(mimeType))
 294         return QVariant();
 295
 296     css::datatransfer::DataFlavor aFlavor;
 297     aFlavor.MimeType = toOUString(mimeType);
 298     aFlavor.DataType = cppu::UnoType<css::uno::Sequence<sal_Int8>>::get();
 299
 300     bool bWantNoCharset = false, bWantUTF16 = false, bWantUTF8 = false;
 301     if (lcl_textMimeInfo(aFlavor.MimeType, bWantNoCharset, bWantUTF16, bWantUTF8))
 302     {
 303         if ((bWantNoCharset && !m_bHaveNoCharset) || (bWantUTF8 && !m_bHaveUTF8))
 304         {
 305             aFlavor.MimeType = "text/plain;charset=utf-16";
 306             aFlavor.DataType = cppu::UnoType<OUString>::get();
 307         }
 308         else if (bWantUTF16)
 309             aFlavor.DataType = cppu::UnoType<OUString>::get();
 310     }
 311
 312     css::uno::Any aValue;
 313
 314     try
 315     {
 316         // tdf#129809 take a reference in case m_aContents is replaced during this call
 317         css::uno::Reference<com::sun::star::datatransfer::XTransferable> xCurrentContents(
 318             m_aContents);
 319         aValue = xCurrentContents->getTransferData(aFlavor);
 320     }
 321     catch (...)
 322     {
 323     }
 324
 325     QByteArray aByteArray;
 326     if (aValue.getValueTypeClass() == css::uno::TypeClass_STRING)
 327     {
 328         OUString aString;
 329         aValue >>= aString;
 330
 331         if (bWantUTF8)
 332         {
 333             OString aUTF8String(OUStringToOString(aString, RTL_TEXTENCODING_UTF8));
 334             aByteArray = QByteArray(aUTF8String.getStr(), aUTF8String.getLength());
 335         }
 336         else if (bWantNoCharset)
 337         {
 338             OString aLocaleString(OUStringToOString(aString, osl_getThreadTextEncoding()));
 339             aByteArray = QByteArray(aLocaleString.getStr(), aLocaleString.getLength());
 340         }
 341         else if (bWantUTF16)
 342         {
 343             aByteArray = QByteArray(reinterpret_cast<const char*>(aString.getStr()),
 344                                     aString.getLength() * 2);
 345         }
 346         else
 347             return QVariant(toQString(aString));
 348     }
 349     else
 350     {
 351         css::uno::Sequence<sal_Int8> aData;
 352         aValue >>= aData;
 353         aByteArray
 354             = QByteArray(reinterpret_cast<const char*>(aData.getConstArray()), aData.getLength());
 355     }
 356     return QVariant::fromValue(aByteArray);
 357 }
 358
 359 bool QtMimeData::hasFormat(const QString& mimeType) const { return formats().contains(mimeType); }
 360
 361 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */