vcl/qt5/QtTransferable.cxx

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