vcl/osx/DataFlavorMapping.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  * 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 #include <sal/config.h>
  21 #include <sal/log.hxx>
  22
  23 #include "DataFlavorMapping.hxx"
  24 #include "HtmlFmtFlt.hxx"
  25 #include "PictToBmpFlt.hxx"
  26 #include <com/sun/star/datatransfer/UnsupportedFlavorException.hpp>
  27 #include <com/sun/star/datatransfer/XMimeContentType.hpp>
  28 #include <com/sun/star/datatransfer/MimeContentTypeFactory.hpp>
  29 #include <com/sun/star/lang/IllegalArgumentException.hpp>
  30 #include <com/sun/star/uno/Sequence.hxx>
  31 #include <comphelper/processfactory.hxx>
  32
  33 #include <rtl/ustring.hxx>
  34 #include <osl/endian.h>
  35
  36 #include <cassert>
  37 #include <string.h>
  38
  39 #include <premac.h>
  40 #include <Cocoa/Cocoa.h>
  41 #include <postmac.h>
  42
  43 using namespace ::com::sun::star::datatransfer;
  44 using namespace ::com::sun::star::uno;
  45 using namespace com::sun::star::lang;
  46 using namespace cppu;
  47 using namespace std;
  48
  49 namespace
  50 {
  51   /* Determine whether or not a DataFlavor is valid.
  52    */
  53   bool isValidFlavor(const DataFlavor& aFlavor)
  54   {
  55     size_t len = aFlavor.MimeType.getLength();
  56     Type dtype = aFlavor.DataType;
  57     return ((len > 0) && ((dtype == cppu::UnoType<Sequence<sal_Int8>>::get()) || (dtype == cppu::UnoType<OUString>::get())));
  58   }
  59
  60   OUString NSStringToOUString( const NSString* cfString)
  61   {
  62     assert(cfString && "Invalid parameter");
  63
  64     const char* utf8Str = [cfString UTF8String];
  65     unsigned int len = rtl_str_getLength(utf8Str);
  66
  67     return OUString(utf8Str, len, RTL_TEXTENCODING_UTF8);
  68   }
  69
  70   NSString* OUStringToNSString(const OUString& ustring)
  71   {
  72     OString utf8Str = OUStringToOString(ustring, RTL_TEXTENCODING_UTF8);
  73     return [NSString stringWithCString: utf8Str.getStr() encoding: NSUTF8StringEncoding];
  74   }
  75
  76   NSString* PBTYPE_SODX = @"application/x-openoffice-objectdescriptor-xml;windows_formatname=\"Star Object Descriptor (XML)\"";
  77   NSString* PBTYPE_SESX = @"application/x-openoffice-embed-source-xml;windows_formatname=\"Star Embed Source (XML)\"";
  78   NSString* PBTYPE_SLSDX = @"application/x-openoffice-linksrcdescriptor-xml;windows_formatname=\"Star Link Source Descriptor (XML)\"";
  79   NSString* PBTYPE_ESX = @"application/x-openoffice-embed-source-xml;windows_formatname=\"Star Embed Source (XML)\"";
  80   NSString* PBTYPE_LSX = @"application/x-openoffice-link-source-xml;windows_formatname=\"Star Link Source (XML)\"";
  81   NSString* PBTYPE_EOX = @"application/x-openoffice-embedded-obj-xml;windows_formatname=\"Star Embedded Object (XML)\"";
  82   NSString* PBTYPE_SVXB = @"application/x-openoffice-svbx;windows_formatname=\"SVXB (StarView Bitmap/Animation)\"";
  83   NSString* PBTYPE_GDIMF = @"application/x-openoffice-gdimetafile;windows_formatname=\"GDIMetaFile\"";
  84   NSString* PBTYPE_WMF = @"application/x-openoffice-wmf;windows_formatname=\"Image WMF\"";
  85   NSString* PBTYPE_EMF = @"application/x-openoffice-emf;windows_formatname=\"Image EMF\"";
  86
  87   NSString* PBTYPE_DUMMY_INTERNAL = @"application/x-openoffice-internal";
  88
  89   const char* FLAVOR_SODX = "application/x-openoffice-objectdescriptor-xml;windows_formatname=\"Star Object Descriptor (XML)\"";
  90   const char* FLAVOR_SESX = "application/x-openoffice-embed-source-xml;windows_formatname=\"Star Embed Source (XML)\"";
  91   const char* FLAVOR_SLSDX = "application/x-openoffice-linksrcdescriptor-xml;windows_formatname=\"Star Link Source Descriptor (XML)\"";
  92   const char* FLAVOR_ESX = "application/x-openoffice-embed-source-xml;windows_formatname=\"Star Embed Source (XML)\"";
  93   const char* FLAVOR_LSX = "application/x-openoffice-link-source-xml;windows_formatname=\"Star Link Source (XML)\"";
  94   const char* FLAVOR_EOX = "application/x-openoffice-embedded-obj-xml;windows_formatname=\"Star Embedded Object (XML)\"";
  95   const char* FLAVOR_SVXB = "application/x-openoffice-svbx;windows_formatname=\"SVXB (StarView Bitmap/Animation)\"";
  96   const char* FLAVOR_GDIMF = "application/x-openoffice-gdimetafile;windows_formatname=\"GDIMetaFile\"";
  97   const char* FLAVOR_WMF = "application/x-openoffice-wmf;windows_formatname=\"Image WMF\"";
  98   const char* FLAVOR_EMF = "application/x-openoffice-emf;windows_formatname=\"Image EMF\"";
  99
 100   const char* FLAVOR_DUMMY_INTERNAL = "application/x-openoffice-internal";
 101
 102   struct FlavorMap
 103   {
 104     const NSString* SystemFlavor;
 105     const char* OOoFlavor;
 106     const char* HumanPresentableName;
 107     bool DataTypeOUString; // sequence<byte> otherwise
 108   };
 109
 110   /* At the moment it appears as if only MS Office pastes "public.html" to the clipboard.
 111    */
 112   static const FlavorMap flavorMap[] =
 113     {
 114       { NSPasteboardTypeString, "text/plain;charset=utf-16", "Unicode Text (UTF-16)", true },
 115       { NSPasteboardTypeRTF, "text/rtf", "Rich Text Format", false },
 116       { NSPasteboardTypePDF, "application/pdf", "PDF File", false },
 117       { NSPasteboardTypeTIFF, "image/png", "Portable Network Graphics", false },
 118       { NSPasteboardTypeHTML, "text/html", "Plain Html", false },
 119 SAL_WNODEPRECATED_DECLARATIONS_PUSH
 120           // "'NSFilenamesPboardType' is deprecated: first deprecated in macOS 10.14 - Create
 121           // multiple pasteboard items with NSPasteboardTypeFileURL or kUTTypeFileURL instead"
 122       { NSFilenamesPboardType, "application/x-openoffice-filelist;windows_formatname=\"FileList\"", "FileList", false },
 123 SAL_WNODEPRECATED_DECLARATIONS_POP
 124       { PBTYPE_SESX, FLAVOR_SESX, "Star Embed Source (XML)", false },
 125       { PBTYPE_SLSDX, FLAVOR_SLSDX, "Star Link Source Descriptor (XML)", false },
 126       { PBTYPE_ESX, FLAVOR_ESX, "Star Embed Source (XML)", false },
 127       { PBTYPE_LSX, FLAVOR_LSX, "Star Link Source (XML)", false },
 128       { PBTYPE_EOX, FLAVOR_EOX, "Star Embedded Object (XML)", false },
 129       { PBTYPE_SVXB, FLAVOR_SVXB, "SVXB (StarView Bitmap/Animation", false },
 130       { PBTYPE_GDIMF, FLAVOR_GDIMF, "GDIMetaFile", false },
 131       { PBTYPE_WMF, FLAVOR_WMF, "Windows MetaFile", false },
 132       { PBTYPE_EMF, FLAVOR_EMF, "Windows Enhanced MetaFile", false },
 133       { PBTYPE_SODX, FLAVOR_SODX, "Star Object Descriptor (XML)", false },
 134       { PBTYPE_DUMMY_INTERNAL, FLAVOR_DUMMY_INTERNAL, "internal data",false }
 135     };
 136
 137   #define SIZE_FLAVOR_MAP (sizeof(flavorMap)/sizeof(FlavorMap))
 138
 139   bool isByteSequenceType(const Type& theType)
 140   {
 141     return (theType == cppu::UnoType<Sequence<sal_Int8>>::get());
 142   }
 143
 144   bool isOUStringType(const Type& theType)
 145   {
 146     return (theType == cppu::UnoType<OUString>::get() );
 147   }
 148
 149 } // unnamed namespace
 150
 151 /* A base class for other data provider.
 152  */
 153 class DataProviderBaseImpl : public DataProvider
 154 {
 155 public:
 156   DataProviderBaseImpl(const Any& data);
 157   DataProviderBaseImpl(id data);
 158   virtual ~DataProviderBaseImpl() override;
 159
 160 protected:
 161   Any mData;
 162   //NSData* mSystemData;
 163   id mSystemData;
 164 };
 165
 166 DataProviderBaseImpl::DataProviderBaseImpl(const Any& data) :
 167   mData(data),
 168   mSystemData(nil)
 169 {
 170 }
 171
 172 DataProviderBaseImpl::DataProviderBaseImpl(id data) :
 173   mSystemData(data)
 174 {
 175   [mSystemData retain];
 176 }
 177
 178 DataProviderBaseImpl::~DataProviderBaseImpl()
 179 {
 180   if (mSystemData)
 181     {
 182       [mSystemData release];
 183     }
 184 }
 185
 186 class UniDataProvider : public DataProviderBaseImpl
 187 {
 188 public:
 189   UniDataProvider(const Any& data);
 190
 191   UniDataProvider(NSData* data);
 192
 193   virtual NSData* getSystemData() override;
 194
 195   virtual Any getOOoData() override;
 196 };
 197
 198 UniDataProvider::UniDataProvider(const Any& data) :
 199   DataProviderBaseImpl(data)
 200 {
 201 }
 202
 203 UniDataProvider::UniDataProvider(NSData* data) :
 204   DataProviderBaseImpl(data)
 205 {
 206 }
 207
 208 NSData* UniDataProvider::getSystemData()
 209 {
 210   OUString ustr;
 211   mData >>= ustr;
 212
 213   OString strUtf8;
 214   ustr.convertToString(&strUtf8, RTL_TEXTENCODING_UTF8, OUSTRING_TO_OSTRING_CVTFLAGS);
 215
 216   return [NSData dataWithBytes: strUtf8.getStr() length: strUtf8.getLength()];
 217 }
 218
 219 Any UniDataProvider::getOOoData()
 220 {
 221   Any oOOData;
 222
 223   if (mSystemData)
 224     {
 225       oOOData <<= OUString(static_cast<const sal_Char*>([mSystemData bytes]),
 226                                  [mSystemData length],
 227                                  RTL_TEXTENCODING_UTF8);
 228     }
 229   else
 230     {
 231       oOOData = mData;
 232     }
 233
 234   return oOOData;
 235 }
 236
 237 class ByteSequenceDataProvider : public DataProviderBaseImpl
 238 {
 239 public:
 240   ByteSequenceDataProvider(const Any& data);
 241
 242   ByteSequenceDataProvider(NSData* data);
 243
 244   virtual NSData* getSystemData() override;
 245
 246   virtual Any getOOoData() override;
 247 };
 248
 249 ByteSequenceDataProvider::ByteSequenceDataProvider(const Any& data) :
 250   DataProviderBaseImpl(data)
 251 {
 252 }
 253
 254 ByteSequenceDataProvider::ByteSequenceDataProvider(NSData* data) :
 255   DataProviderBaseImpl(data)
 256 {
 257 }
 258
 259 NSData* ByteSequenceDataProvider::getSystemData()
 260 {
 261    Sequence<sal_Int8> rawData;
 262    mData >>= rawData;
 263
 264    return [NSData dataWithBytes: rawData.getArray() length: rawData.getLength()];
 265 }
 266
 267 Any ByteSequenceDataProvider::getOOoData()
 268 {
 269   Any oOOData;
 270
 271   if (mSystemData)
 272     {
 273       unsigned int flavorDataLength = [mSystemData length];
 274       Sequence<sal_Int8> byteSequence;
 275       byteSequence.realloc(flavorDataLength);
 276       memcpy(byteSequence.getArray(), [mSystemData bytes], flavorDataLength);
 277       oOOData <<= byteSequence;
 278     }
 279   else
 280     {
 281       oOOData =  mData;
 282     }
 283
 284   return oOOData;
 285 }
 286
 287 class HTMLFormatDataProvider : public DataProviderBaseImpl
 288 {
 289 public:
 290   HTMLFormatDataProvider(NSData* data);
 291
 292   virtual NSData* getSystemData() override;
 293
 294   virtual Any getOOoData() override;
 295 };
 296
 297 HTMLFormatDataProvider::HTMLFormatDataProvider(NSData* data) :
 298   DataProviderBaseImpl(data)
 299 {
 300 }
 301
 302 NSData* HTMLFormatDataProvider::getSystemData()
 303 {
 304   Sequence<sal_Int8> textHtmlData;
 305   mData >>= textHtmlData;
 306
 307   Sequence<sal_Int8> htmlFormatData = TextHtmlToHTMLFormat(textHtmlData);
 308
 309   return [NSData dataWithBytes: htmlFormatData.getArray() length: htmlFormatData.getLength()];
 310 }
 311
 312 Any HTMLFormatDataProvider::getOOoData()
 313 {
 314   Any oOOData;
 315
 316   if (mSystemData)
 317     {
 318       unsigned int flavorDataLength = [mSystemData length];
 319       Sequence<sal_Int8> unkHtmlData;
 320
 321       unkHtmlData.realloc(flavorDataLength);
 322       memcpy(unkHtmlData.getArray(), [mSystemData bytes], flavorDataLength);
 323
 324       Sequence<sal_Int8>* pPlainHtml = &unkHtmlData;
 325       Sequence<sal_Int8> plainHtml;
 326
 327       if (isHTMLFormat(unkHtmlData))
 328         {
 329           plainHtml = HTMLFormatToTextHtml(unkHtmlData);
 330           pPlainHtml = &plainHtml;
 331         }
 332
 333       oOOData <<= *pPlainHtml;
 334     }
 335   else
 336     {
 337       oOOData = mData;
 338     }
 339
 340   return oOOData;
 341 }
 342
 343 class PNGDataProvider : public DataProviderBaseImpl
 344 {
 345     NSBitmapImageFileType meImageType;
 346 public:
 347     PNGDataProvider( const Any&, NSBitmapImageFileType);
 348
 349     PNGDataProvider( NSData*, NSBitmapImageFileType);
 350
 351     virtual NSData* getSystemData() override;
 352
 353     virtual Any getOOoData() override;
 354 };
 355
 356 PNGDataProvider::PNGDataProvider( const Any& data, NSBitmapImageFileType eImageType) :
 357   DataProviderBaseImpl(data),
 358   meImageType( eImageType )
 359 {
 360 }
 361
 362 PNGDataProvider::PNGDataProvider( NSData* data, NSBitmapImageFileType eImageType) :
 363   DataProviderBaseImpl(data),
 364   meImageType( eImageType )
 365 {
 366 }
 367
 368 NSData* PNGDataProvider::getSystemData()
 369 {
 370     Sequence<sal_Int8> pngData;
 371     mData >>= pngData;
 372
 373     Sequence<sal_Int8> imgData;
 374     NSData* sysData = nullptr;
 375     if( PNGToImage( pngData, imgData, meImageType))
 376         sysData = [NSData dataWithBytes: imgData.getArray() length: imgData.getLength()];
 377
 378     return sysData;
 379 }
 380
 381 /* The AOO 'PCT' filter is not yet good enough to be used
 382    and there is no flavor defined for exchanging 'PCT' with AOO
 383    so we convert 'PCT' to a PNG and provide this to AOO
 384 */
 385 Any PNGDataProvider::getOOoData()
 386 {
 387     Any oOOData;
 388
 389     if( mSystemData)
 390     {
 391         const unsigned int flavorDataLength = [mSystemData length];
 392         Sequence<sal_Int8> imgData( flavorDataLength);
 393         memcpy( imgData.getArray(), [mSystemData bytes], flavorDataLength);
 394
 395         Sequence<sal_Int8> pngData;
 396         if( ImageToPNG( imgData, pngData))
 397             oOOData <<= pngData;
 398     }
 399     else
 400     {
 401         oOOData = mData;
 402     }
 403
 404     return oOOData;
 405 }
 406
 407 class FileListDataProvider : public DataProviderBaseImpl
 408 {
 409 public:
 410   FileListDataProvider(const Any& data);
 411   FileListDataProvider(NSArray* data);
 412
 413   virtual NSData* getSystemData() override;
 414   virtual Any getOOoData() override;
 415 };
 416
 417 FileListDataProvider::FileListDataProvider(const Any& data) :
 418   DataProviderBaseImpl(data)
 419 {
 420 }
 421
 422 FileListDataProvider::FileListDataProvider(NSArray* data) :
 423   DataProviderBaseImpl(data)
 424 {
 425 }
 426
 427 NSData* FileListDataProvider::getSystemData()
 428 {
 429   return [NSData data];
 430 }
 431
 432 Any FileListDataProvider::getOOoData()
 433 {
 434   Any oOOData;
 435
 436   if (mSystemData)
 437     {
 438       size_t length = [mSystemData count];
 439       size_t lenSeqRequired = 0;
 440
 441       for (size_t i = 0; i < length; i++)
 442         {
 443           NSString* fname = [mSystemData objectAtIndex: i];
 444           lenSeqRequired += [fname maximumLengthOfBytesUsingEncoding: NSUnicodeStringEncoding] + sizeof(unichar);
 445         }
 446
 447       Sequence<sal_Int8> oOOFileList(lenSeqRequired);
 448       unichar* pBuffer = reinterpret_cast<unichar*>(oOOFileList.getArray());
 449       memset(pBuffer, 0, lenSeqRequired);
 450
 451       for (size_t i = 0; i < length; i++)
 452         {
 453           NSString* fname = [mSystemData objectAtIndex: i];
 454           [fname getCharacters: pBuffer];
 455           size_t l = [fname length];
 456           pBuffer += l + 1;
 457         }
 458
 459       oOOData <<= oOOFileList;
 460     }
 461   else
 462     {
 463       oOOData = mData;
 464     }
 465
 466   return oOOData;
 467 }
 468
 469 DataFlavorMapper::DataFlavorMapper()
 470 {
 471     Reference<XComponentContext> xContext = comphelper::getProcessComponentContext();
 472     mrXMimeCntFactory = MimeContentTypeFactory::create( xContext );
 473 }
 474
 475 DataFlavorMapper::~DataFlavorMapper()
 476 {
 477     // release potential NSStrings
 478     for( OfficeOnlyTypes::iterator it = maOfficeOnlyTypes.begin(); it != maOfficeOnlyTypes.end(); ++it )
 479     {
 480         [it->second release];
 481         it->second = nil;
 482     }
 483 }
 484
 485 DataFlavor DataFlavorMapper::systemToOpenOfficeFlavor( const NSString* systemDataFlavor) const
 486 {
 487     DataFlavor oOOFlavor;
 488
 489     for (size_t i = 0; i < SIZE_FLAVOR_MAP; i++)
 490     {
 491       if ([systemDataFlavor caseInsensitiveCompare:const_cast<NSString*>(flavorMap[i].SystemFlavor)] == NSOrderedSame)
 492         {
 493           oOOFlavor.MimeType = OUString::createFromAscii(flavorMap[i].OOoFlavor);
 494           oOOFlavor.HumanPresentableName = OUString::createFromAscii(flavorMap[i].HumanPresentableName);
 495           oOOFlavor.DataType = flavorMap[i].DataTypeOUString ? cppu::UnoType<OUString>::get() : cppu::UnoType<Sequence<sal_Int8>>::get();
 496           return oOOFlavor;
 497         }
 498     } // for
 499
 500     // look if this might be an internal type; if it comes in here it must have
 501     // been through openOfficeToSystemFlavor before, so it should then be in the map
 502     OUString aTryFlavor( NSStringToOUString( systemDataFlavor ) );
 503     if( maOfficeOnlyTypes.find( aTryFlavor ) != maOfficeOnlyTypes.end() )
 504     {
 505         oOOFlavor.MimeType = aTryFlavor;
 506         oOOFlavor.HumanPresentableName.clear();
 507         oOOFlavor.DataType = cppu::UnoType<Sequence<sal_Int8>>::get();
 508     }
 509
 510     return oOOFlavor;
 511 }
 512
 513 const NSString* DataFlavorMapper::openOfficeToSystemFlavor( const DataFlavor& oOOFlavor, bool& rbInternal) const
 514 {
 515     const NSString* sysFlavor = nullptr;
 516     rbInternal = false;
 517
 518     for( size_t i = 0; i < SIZE_FLAVOR_MAP; ++i )
 519     {
 520        if (oOOFlavor.MimeType.startsWith(OUString::createFromAscii(flavorMap[i].OOoFlavor)))
 521         {
 522             sysFlavor = flavorMap[i].SystemFlavor;
 523         }
 524     }
 525
 526     if(!sysFlavor)
 527     {
 528         rbInternal = true;
 529         OfficeOnlyTypes::const_iterator it = maOfficeOnlyTypes.find( oOOFlavor.MimeType );
 530
 531         if( it == maOfficeOnlyTypes.end() )
 532             sysFlavor = maOfficeOnlyTypes[ oOOFlavor.MimeType ] = OUStringToNSString( oOOFlavor.MimeType );
 533         else
 534             sysFlavor = it->second;
 535     }
 536
 537     return sysFlavor;
 538 }
 539
 540 NSString* DataFlavorMapper::openOfficeImageToSystemFlavor(NSPasteboard* pPasteboard)
 541 {
 542     NSArray *supportedTypes = [NSArray arrayWithObjects: NSPasteboardTypeTIFF, nil];
 543     NSString *sysFlavor = [pPasteboard availableTypeFromArray:supportedTypes];
 544     return sysFlavor;
 545 }
 546
 547 DataProviderPtr_t DataFlavorMapper::getDataProvider( const NSString* systemFlavor, Reference<XTransferable> const & rTransferable) const
 548 {
 549   DataProviderPtr_t dp;
 550
 551   try
 552     {
 553       DataFlavor oOOFlavor = systemToOpenOfficeFlavor(systemFlavor);
 554
 555       Any data = rTransferable->getTransferData(oOOFlavor);
 556
 557       if (isByteSequenceType(data.getValueType()))
 558         {
 559           /*
 560              the HTMLFormatDataProvider prepends segment information to HTML
 561              this is useful for exchange with MS Word (which brings this stuff from Windows)
 562              but annoying for other applications. Since this extension is not a standard datatype
 563              on the Mac, let us not provide but provide normal HTML
 564
 565           if ([systemFlavor caseInsensitiveCompare: NSHTMLPboardType] == NSOrderedSame)
 566             {
 567               dp = DataProviderPtr_t(new HTMLFormatDataProvider(data));
 568             }
 569           else
 570           */
 571           if ([systemFlavor caseInsensitiveCompare: NSPasteboardTypeTIFF] == NSOrderedSame)
 572             {
 573               dp = DataProviderPtr_t( new PNGDataProvider( data, NSBitmapImageFileTypeTIFF));
 574             }
 575 SAL_WNODEPRECATED_DECLARATIONS_PUSH
 576               // "'NSFilenamesPboardType' is deprecated: first deprecated in macOS 10.14 - Create
 577               // multiple pasteboard items with NSPasteboardTypeFileURL or kUTTypeFileURL instead"
 578           else if ([systemFlavor caseInsensitiveCompare: NSFilenamesPboardType] == NSOrderedSame)
 579 SAL_WNODEPRECATED_DECLARATIONS_POP
 580             {
 581               dp = DataProviderPtr_t(new FileListDataProvider(data));
 582             }
 583           else
 584             {
 585               dp = DataProviderPtr_t(new ByteSequenceDataProvider(data));
 586             }
 587         }
 588       else // Must be OUString type
 589         {
 590           SAL_WARN_IF(
 591               !isOUStringType(data.getValueType()), "vcl",
 592               "must be OUString type");
 593           dp = DataProviderPtr_t(new UniDataProvider(data));
 594         }
 595     }
 596   catch(UnsupportedFlavorException&)
 597     {
 598       // Somebody violates the contract of the clipboard
 599       // interface @see XTransferable
 600     }
 601
 602   return dp;
 603 }
 604
 605 DataProviderPtr_t DataFlavorMapper::getDataProvider( const NSString* /*systemFlavor*/, NSArray* systemData)
 606 {
 607   return DataProviderPtr_t(new FileListDataProvider(systemData));
 608 }
 609
 610 DataProviderPtr_t DataFlavorMapper::getDataProvider( const NSString* systemFlavor, NSData* systemData)
 611 {
 612   DataProviderPtr_t dp;
 613
 614   if ([systemFlavor caseInsensitiveCompare: NSPasteboardTypeString] == NSOrderedSame)
 615     {
 616       dp = DataProviderPtr_t(new UniDataProvider(systemData));
 617     }
 618   else if ([systemFlavor caseInsensitiveCompare: NSPasteboardTypeHTML] == NSOrderedSame)
 619     {
 620       dp = DataProviderPtr_t(new HTMLFormatDataProvider(systemData));
 621     }
 622   else if ([systemFlavor caseInsensitiveCompare: NSPasteboardTypeTIFF] == NSOrderedSame)
 623     {
 624       dp = DataProviderPtr_t( new PNGDataProvider(systemData, NSBitmapImageFileTypeTIFF));
 625     }
 626 SAL_WNODEPRECATED_DECLARATIONS_PUSH
 627       // "'NSFilenamesPboardType' is deprecated: first deprecated in macOS 10.14 - Create multiple
 628       // pasteboard items with NSPasteboardTypeFileURL or kUTTypeFileURL instead"
 629   else if ([systemFlavor caseInsensitiveCompare: NSFilenamesPboardType] == NSOrderedSame)
 630 SAL_WNODEPRECATED_DECLARATIONS_POP
 631     {
 632       //dp = DataProviderPtr_t(new FileListDataProvider(systemData));
 633     }
 634   else
 635     {
 636       dp = DataProviderPtr_t(new ByteSequenceDataProvider(systemData));
 637     }
 638
 639   return dp;
 640 }
 641
 642 bool DataFlavorMapper::isValidMimeContentType(const OUString& contentType) const
 643 {
 644   bool result = true;
 645
 646   try
 647     {
 648       Reference<XMimeContentType> xCntType(mrXMimeCntFactory->createMimeContentType(contentType));
 649     }
 650   catch( IllegalArgumentException& )
 651     {
 652       result = false;
 653     }
 654
 655   return result;
 656 }
 657
 658 NSArray* DataFlavorMapper::flavorSequenceToTypesArray(const css::uno::Sequence<css::datatransfer::DataFlavor>& flavors) const
 659 {
 660   sal_uInt32 nFlavors = flavors.getLength();
 661   NSMutableArray* array = [[NSMutableArray alloc] initWithCapacity: 1];
 662
 663   bool bNeedDummyInternalFlavor(false);
 664
 665   for (sal_uInt32 i = 0; i < nFlavors; i++)
 666   {
 667       if( flavors[i].MimeType.startsWith("image/bmp") )
 668       {
 669           [array addObject: NSPasteboardTypeTIFF];
 670       }
 671       else
 672       {
 673           const NSString* str = openOfficeToSystemFlavor(flavors[i], bNeedDummyInternalFlavor);
 674
 675           if (str != nullptr)
 676           {
 677               [str retain];
 678               [array addObject: str];
 679           }
 680       }
 681   }
 682
 683    // #i89462# #i90747#
 684    // in case no system flavor was found to report
 685    // report at least one so D&D between OOo targets works
 686   if( [array count] == 0 || bNeedDummyInternalFlavor)
 687   {
 688       [array addObject: PBTYPE_DUMMY_INTERNAL];
 689   }
 690
 691   return [array autorelease];
 692 }
 693
 694 css::uno::Sequence<css::datatransfer::DataFlavor> DataFlavorMapper::typesArrayToFlavorSequence(NSArray* types) const
 695 {
 696   int nFormats = [types count];
 697   Sequence<DataFlavor> flavors;
 698
 699   for (int i = 0; i < nFormats; i++)
 700     {
 701       NSString* sysFormat = [types objectAtIndex: i];
 702       DataFlavor oOOFlavor = systemToOpenOfficeFlavor(sysFormat);
 703
 704       if (isValidFlavor(oOOFlavor))
 705         {
 706           flavors.realloc(flavors.getLength() + 1);
 707           flavors[flavors.getLength() - 1] = oOOFlavor;
 708         }
 709     }
 710
 711   return flavors;
 712 }
 713
 714 NSArray* DataFlavorMapper::getAllSupportedPboardTypes()
 715 {
 716   NSMutableArray* array = [[NSMutableArray alloc] initWithCapacity: SIZE_FLAVOR_MAP];
 717
 718   for (sal_uInt32 i = 0; i < SIZE_FLAVOR_MAP; i++)
 719     {
 720       [array addObject: flavorMap[i].SystemFlavor];
 721     }
 722
 723   return [array autorelease];
 724 }
 725
 726 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */