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