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