vcl/aqua/source/dtrans/DataFlavorMapping.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: DataFlavorMapping.cxx,v $
  10  * $Revision: 1.6 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 #include "vcl/unohelp.hxx"
  32 #include <DataFlavorMapping.hxx>
  33 #include "HtmlFmtFlt.hxx"
  34 #include "PictToBmpFlt.hxx"
  35 #include "com/sun/star/datatransfer/UnsupportedFlavorException.hpp"
  36 #include "com/sun/star/datatransfer/XMimeContentType.hpp"
  37 #include "com/sun/star/lang/XMultiServiceFactory.hpp"
  38 #include "com/sun/star/uno/Sequence.hxx"
  39
  40 #include <rtl/ustring.hxx>
  41 #include <rtl/memory.h>
  42 #include <osl/endian.h>
  43
  44 #include <vector>
  45 #include <stdio.h>
  46
  47 #include <premac.h>
  48 #include <QuickTime/QuickTime.h>
  49 #include <postmac.h>
  50
  51 using namespace ::com::sun::star::datatransfer;
  52 using namespace rtl;
  53 using namespace ::com::sun::star::uno;
  54 using namespace com::sun::star::lang;
  55 using namespace cppu;
  56 using namespace std;
  57
  58 namespace // private
  59 {
  60   const Type CPPUTYPE_SEQINT8  = getCppuType((Sequence<sal_Int8>*)0);
  61   const Type CPPUTYPE_OUSTRING = getCppuType( (OUString*)0 );
  62
  63   /* Determine whether or not a DataFlavor is valid.
  64    */
  65   bool isValidFlavor(const DataFlavor& aFlavor)
  66   {
  67     size_t len = aFlavor.MimeType.getLength();
  68     Type dtype = aFlavor.DataType;
  69     return ((len > 0) && ((dtype == CPPUTYPE_SEQINT8) || (dtype == CPPUTYPE_OUSTRING)));
  70   }
  71
  72   typedef vector<sal_Unicode> UnicodeBuffer;
  73
  74   OUString NSStringToOUString(NSString* cfString)
  75   {
  76     BOOST_ASSERT(cfString && "Invalid parameter");
  77
  78     const char* utf8Str = [cfString UTF8String];
  79     unsigned int len = rtl_str_getLength(utf8Str);
  80
  81     return OUString(utf8Str, len, RTL_TEXTENCODING_UTF8);
  82   }
  83
  84   NSString* OUStringToNSString(const OUString& ustring)
  85   {
  86     OString utf8Str = OUStringToOString(ustring, RTL_TEXTENCODING_UTF8);
  87     return [NSString stringWithCString: utf8Str.getStr() encoding: NSUTF8StringEncoding];
  88   }
  89
  90
  91   const NSString* PBTYPE_UT16 = @"CorePasteboardFlavorType 0x75743136";
  92   const NSString* PBTYPE_PICT = @"CorePasteboardFlavorType 0x50494354";
  93   const NSString* PBTYPE_HTML = @"CorePasteboardFlavorType 0x48544D4C";
  94   const NSString* PBTYPE_SODX = @"application/x-openoffice-objectdescriptor-xml;windows_formatname=\"Star Object Descriptor (XML)\"";
  95   const NSString* PBTYPE_SESX = @"application/x-openoffice-embed-source-xml;windows_formatname=\"Star Embed Source (XML)\"";
  96   const NSString* PBTYPE_SLSDX = @"application/x-openoffice-linksrcdescriptor-xml;windows_formatname=\"Star Link Source Descriptor (XML)\"";
  97   const NSString* PBTYPE_ESX = @"application/x-openoffice-embed-source-xml;windows_formatname=\"Star Embed Source (XML)\"";
  98   const NSString* PBTYPE_LSX = @"application/x-openoffice-link-source-xml;windows_formatname=\"Star Link Source (XML)\"";
  99   const NSString* PBTYPE_EOX = @"application/x-openoffice-embedded-obj-xml;windows_formatname=\"Star Embedded Object (XML)\"";
 100   const NSString* PBTYPE_SVXB = @"application/x-openoffice-svbx;windows_formatname=\"SVXB (StarView Bitmap/Animation)\"";
 101   const NSString* PBTYPE_GDIMF = @"application/x-openoffice-gdimetafile;windows_formatname=\"GDIMetaFile\"";
 102   const NSString* PBTYPE_WMF = @"application/x-openoffice-wmf;windows_formatname=\"Image WMF\"";
 103   const NSString* PBTYPE_EMF = @"application/x-openoffice-emf;windows_formatname=\"Image EMF\"";
 104
 105   const NSString* PBTYPE_DUMMY_INTERNAL = @"application/x-openoffice-internal";
 106
 107   const char* FLAVOR_SODX = "application/x-openoffice-objectdescriptor-xml;windows_formatname=\"Star Object Descriptor (XML)\"";
 108   const char* FLAVOR_SESX = "application/x-openoffice-embed-source-xml;windows_formatname=\"Star Embed Source (XML)\"";
 109   const char* FLAVOR_SLSDX = "application/x-openoffice-linksrcdescriptor-xml;windows_formatname=\"Star Link Source Descriptor (XML)\"";
 110   const char* FLAVOR_ESX = "application/x-openoffice-embed-source-xml;windows_formatname=\"Star Embed Source (XML)\"";
 111   const char* FLAVOR_LSX = "application/x-openoffice-link-source-xml;windows_formatname=\"Star Link Source (XML)\"";
 112   const char* FLAVOR_EOX = "application/x-openoffice-embedded-obj-xml;windows_formatname=\"Star Embedded Object (XML)\"";
 113   const char* FLAVOR_SVXB = "application/x-openoffice-svbx;windows_formatname=\"SVXB (StarView Bitmap/Animation)\"";
 114   const char* FLAVOR_GDIMF = "application/x-openoffice-gdimetafile;windows_formatname=\"GDIMetaFile\"";
 115   const char* FLAVOR_WMF = "application/x-openoffice-wmf;windows_formatname=\"Image WMF\"";
 116   const char* FLAVOR_EMF = "application/x-openoffice-emf;windows_formatname=\"Image EMF\"";
 117
 118   const char* FLAVOR_DUMMY_INTERNAL = "application/x-openoffice-internal";
 119
 120
 121   struct FlavorMap
 122   {
 123     NSString* SystemFlavor;
 124     const char* OOoFlavor;
 125     const char* HumanPresentableName;
 126     Type DataType;
 127   };
 128
 129   /* At the moment it appears as if only MS Office pastes "public.html" to the clipboard.
 130    */
 131   FlavorMap flavorMap[] =
 132     {
 133       { NSStringPboardType, "text/plain;charset=utf-16", "Unicode Text (UTF-16)", CPPUTYPE_OUSTRING },
 134       { NSRTFPboardType, "text/richtext", "Rich Text Format", CPPUTYPE_SEQINT8 },
 135       { NSPICTPboardType, "image/bmp", "Windows Bitmap", CPPUTYPE_SEQINT8 },
 136       { NSHTMLPboardType, "text/html", "Plain Html", CPPUTYPE_SEQINT8 },
 137       { NSFilenamesPboardType, "application/x-openoffice-filelist;windows_formatname=\"FileList\"", "FileList", CPPUTYPE_SEQINT8 },
 138       { PBTYPE_SESX, FLAVOR_SESX, "Star Embed Source (XML)", CPPUTYPE_SEQINT8 },
 139       { PBTYPE_SLSDX, FLAVOR_SLSDX, "Star Link Source Descriptor (XML)", CPPUTYPE_SEQINT8 },
 140       { PBTYPE_ESX, FLAVOR_ESX, "Star Embed Source (XML)", CPPUTYPE_SEQINT8 },
 141       { PBTYPE_LSX, FLAVOR_LSX, "Star Link Source (XML)", CPPUTYPE_SEQINT8 },
 142       { PBTYPE_EOX, FLAVOR_EOX, "Star Embedded Object (XML)", CPPUTYPE_SEQINT8 },
 143       { PBTYPE_SVXB, FLAVOR_SVXB, "SVXB (StarView Bitmap/Animation", CPPUTYPE_SEQINT8 },
 144       { PBTYPE_GDIMF, FLAVOR_GDIMF, "GDIMetaFile", CPPUTYPE_SEQINT8 },
 145       { PBTYPE_WMF, FLAVOR_WMF, "Windows MetaFile", CPPUTYPE_SEQINT8 },
 146       { PBTYPE_EMF, FLAVOR_EMF, "Windows Enhanced MetaFile", CPPUTYPE_SEQINT8 },
 147       { PBTYPE_SODX, FLAVOR_SODX, "Star Object Descriptor (XML)", CPPUTYPE_SEQINT8 },
 148       { PBTYPE_DUMMY_INTERNAL, FLAVOR_DUMMY_INTERNAL, "internal data",CPPUTYPE_SEQINT8 }
 149       //          { PBTYPE_UT16, "text/plain;charset=utf-16", "Unicode Text (UTF-16)", CPPUTYPE_OUSTRING }
 150       //          { kUTTypePICT, @"PICT", "image/x-macpict;windows_formatname=\"Mac Pict\"", "Mac Pict", CPPUTYPE_SEQINT8 }
 151       //      { kUTTypeHTML, @"HTML", "text/html", "Plain Html", CPPUTYPE_SEQINT8 }
 152     };
 153
 154
 155   #define SIZE_FLAVOR_MAP (sizeof(flavorMap)/sizeof(FlavorMap))
 156
 157
 158   inline bool isByteSequenceType(const Type& theType)
 159   {
 160     return (theType == CPPUTYPE_SEQINT8);
 161   }
 162
 163   inline bool isOUStringType(const Type& theType)
 164   {
 165     return (theType == CPPUTYPE_OUSTRING);
 166   }
 167
 168 } // namespace private
 169
 170
 171 //###########################
 172
 173 /* A base class for other data provider.
 174  */
 175 class DataProviderBaseImpl : public DataProvider
 176 {
 177 public:
 178   DataProviderBaseImpl(const Any& data);
 179   DataProviderBaseImpl(id data);
 180   virtual ~DataProviderBaseImpl();
 181
 182 protected:
 183   Any mData;
 184   //NSData* mSystemData;
 185   id mSystemData;
 186 };
 187
 188 DataProviderBaseImpl::DataProviderBaseImpl(const Any& data) :
 189   mData(data),
 190   mSystemData(nil)
 191 {
 192 }
 193
 194 DataProviderBaseImpl::DataProviderBaseImpl(id data) :
 195   mSystemData(data)
 196 {
 197   [mSystemData retain];
 198 }
 199
 200
 201 DataProviderBaseImpl::~DataProviderBaseImpl()
 202 {
 203   if (mSystemData)
 204     {
 205       [mSystemData release];
 206     }
 207 }
 208
 209 //#################################
 210
 211 class UniDataProvider : public DataProviderBaseImpl
 212 {
 213 public:
 214   UniDataProvider(const Any& data);
 215
 216   UniDataProvider(NSData* data);
 217
 218   virtual NSData* getSystemData();
 219
 220   virtual Any getOOoData();
 221 };
 222
 223 UniDataProvider::UniDataProvider(const Any& data) :
 224   DataProviderBaseImpl(data)
 225 {
 226 }
 227
 228 UniDataProvider::UniDataProvider(NSData* data) :
 229   DataProviderBaseImpl(data)
 230 {
 231 }
 232
 233 NSData* UniDataProvider::getSystemData()
 234 {
 235   OUString ustr;
 236   mData >>= ustr;
 237
 238   OString strUtf8;
 239   ustr.convertToString(&strUtf8, RTL_TEXTENCODING_UTF8, OUSTRING_TO_OSTRING_CVTFLAGS);
 240
 241   return [NSData dataWithBytes: strUtf8.getStr() length: strUtf8.getLength()];
 242 }
 243
 244 Any UniDataProvider::getOOoData()
 245 {
 246   Any oOOData;
 247
 248   if (mSystemData)
 249     {
 250       oOOData = makeAny(OUString(reinterpret_cast<const sal_Char*>([mSystemData bytes]),
 251                                  [mSystemData length],
 252                                  RTL_TEXTENCODING_UTF8));
 253     }
 254   else
 255     {
 256       oOOData = mData;
 257     }
 258
 259   return oOOData;
 260 }
 261
 262 //###########################
 263
 264 class ByteSequenceDataProvider : public DataProviderBaseImpl
 265 {
 266 public:
 267   ByteSequenceDataProvider(const Any& data);
 268
 269   ByteSequenceDataProvider(NSData* data);
 270
 271   virtual NSData* getSystemData();
 272
 273   virtual Any getOOoData();
 274 };
 275
 276 ByteSequenceDataProvider::ByteSequenceDataProvider(const Any& data) :
 277   DataProviderBaseImpl(data)
 278 {
 279 }
 280
 281 ByteSequenceDataProvider::ByteSequenceDataProvider(NSData* data) :
 282   DataProviderBaseImpl(data)
 283 {
 284 }
 285
 286
 287 NSData* ByteSequenceDataProvider::getSystemData()
 288 {
 289    Sequence<sal_Int8> rawData;
 290    mData >>= rawData;
 291
 292    return [NSData dataWithBytes: rawData.getArray()     length: rawData.getLength()];
 293 }
 294
 295 Any ByteSequenceDataProvider::getOOoData()
 296 {
 297   Any oOOData;
 298
 299   if (mSystemData)
 300     {
 301       unsigned int flavorDataLength = [mSystemData length];
 302       Sequence<sal_Int8> byteSequence;
 303       byteSequence.realloc(flavorDataLength);
 304       memcpy(byteSequence.getArray(), [mSystemData bytes], flavorDataLength);
 305       oOOData = makeAny(byteSequence);
 306     }
 307   else
 308     {
 309       oOOData =  mData;
 310     }
 311
 312   return oOOData;
 313 }
 314
 315
 316 //###########################
 317
 318 class HTMLFormatDataProvider : public DataProviderBaseImpl
 319 {
 320 public:
 321   HTMLFormatDataProvider(const Any& data);
 322
 323   HTMLFormatDataProvider(NSData* data);
 324
 325   virtual NSData* getSystemData();
 326
 327   virtual Any getOOoData();
 328 };
 329
 330 HTMLFormatDataProvider::HTMLFormatDataProvider(const Any& data) :
 331   DataProviderBaseImpl(data)
 332 {
 333 }
 334
 335 HTMLFormatDataProvider::HTMLFormatDataProvider(NSData* data) :
 336   DataProviderBaseImpl(data)
 337 {
 338 }
 339
 340 NSData* HTMLFormatDataProvider::getSystemData()
 341 {
 342   Sequence<sal_Int8> textHtmlData;
 343   mData >>= textHtmlData;
 344
 345   Sequence<sal_Int8> htmlFormatData = TextHtmlToHTMLFormat(textHtmlData);
 346
 347   return [NSData dataWithBytes: htmlFormatData.getArray() length: htmlFormatData.getLength()];
 348 }
 349
 350 Any HTMLFormatDataProvider::getOOoData()
 351 {
 352   Any oOOData;
 353
 354   if (mSystemData)
 355     {
 356       unsigned int flavorDataLength = [mSystemData length];
 357       Sequence<sal_Int8> unkHtmlData;
 358
 359       unkHtmlData.realloc(flavorDataLength);
 360       memcpy(unkHtmlData.getArray(), [mSystemData bytes], flavorDataLength);
 361
 362       Sequence<sal_Int8>* pPlainHtml = &unkHtmlData;
 363       Sequence<sal_Int8> plainHtml;
 364
 365       if (isHTMLFormat(unkHtmlData))
 366         {
 367           plainHtml = HTMLFormatToTextHtml(unkHtmlData);
 368           pPlainHtml = &plainHtml;
 369         }
 370
 371       oOOData = makeAny(*pPlainHtml);
 372     }
 373   else
 374     {
 375       oOOData = mData;
 376     }
 377
 378   return oOOData;
 379 }
 380
 381 //###########################
 382
 383 class BMPDataProvider : public DataProviderBaseImpl
 384 {
 385 public:
 386   BMPDataProvider(const Any& data);
 387
 388   BMPDataProvider(NSData* data);
 389
 390   virtual NSData* getSystemData();
 391
 392   virtual Any getOOoData();
 393 };
 394
 395 BMPDataProvider::BMPDataProvider(const Any& data) :
 396   DataProviderBaseImpl(data)
 397 {
 398 }
 399
 400 BMPDataProvider::BMPDataProvider(NSData* data) :
 401   DataProviderBaseImpl(data)
 402 {
 403 }
 404
 405 NSData* BMPDataProvider::getSystemData()
 406 {
 407   Sequence<sal_Int8> bmpData;
 408   mData >>= bmpData;
 409
 410   Sequence<sal_Int8> pictData;
 411   NSData* sysData = NULL;
 412
 413   if (BMPtoPICT(bmpData, pictData))
 414     {
 415       sysData = [NSData dataWithBytes: pictData.getArray() length: pictData.getLength()];
 416     }
 417
 418   return sysData;
 419 }
 420
 421 /* At the moment the OOo 'PCT' filter is not good enough to be used
 422    and there is no flavor defined for exchanging 'PCT' with OOo so
 423    we will at the moment convert 'PCT' to a Windows BMP and provide
 424    this to OOo
 425 */
 426 Any BMPDataProvider::getOOoData()
 427 {
 428   Any oOOData;
 429
 430   if (mSystemData)
 431     {
 432       unsigned int flavorDataLength = [mSystemData length];
 433       Sequence<sal_Int8> pictData(flavorDataLength);
 434
 435       memcpy(pictData.getArray(), [mSystemData bytes], flavorDataLength);
 436
 437       Sequence<sal_Int8> bmpData;
 438
 439       if (PICTtoBMP(pictData, bmpData))
 440         {
 441           oOOData = makeAny(bmpData);
 442         }
 443     }
 444   else
 445     {
 446       oOOData = mData;
 447     }
 448
 449   return oOOData;
 450 }
 451
 452 //######################
 453
 454 class FileListDataProvider : public DataProviderBaseImpl
 455 {
 456 public:
 457   FileListDataProvider(const Any& data);
 458   FileListDataProvider(NSArray* data);
 459
 460   virtual NSData* getSystemData();
 461   virtual Any getOOoData();
 462 };
 463
 464 FileListDataProvider::FileListDataProvider(const Any& data) :
 465   DataProviderBaseImpl(data)
 466 {
 467 }
 468
 469 FileListDataProvider::FileListDataProvider(NSArray* data) :
 470   DataProviderBaseImpl(data)
 471 {
 472 }
 473
 474 NSData* FileListDataProvider::getSystemData()
 475 {
 476   return [NSData data];
 477 }
 478
 479 Any FileListDataProvider::getOOoData()
 480 {
 481   Any oOOData;
 482
 483   if (mSystemData)
 484     {
 485       size_t length = [mSystemData count];
 486       size_t lenSeqRequired = 0;
 487
 488       for (size_t i = 0; i < length; i++)
 489         {
 490           NSString* fname = [mSystemData objectAtIndex: i];
 491           lenSeqRequired += [fname maximumLengthOfBytesUsingEncoding: NSUnicodeStringEncoding] + sizeof(unichar);
 492         }
 493
 494       Sequence<sal_Int8> oOOFileList(lenSeqRequired);
 495       unichar* pBuffer = reinterpret_cast<unichar*>(oOOFileList.getArray());
 496       rtl_zeroMemory(pBuffer, lenSeqRequired);
 497
 498       for (size_t i = 0; i < length; i++)
 499         {
 500           NSString* fname = [mSystemData objectAtIndex: i];
 501           [fname getCharacters: pBuffer];
 502           size_t l = [fname length];
 503           pBuffer += l + 1;
 504         }
 505
 506       oOOData = makeAny(oOOFileList);
 507     }
 508   else
 509     {
 510       oOOData = mData;
 511     }
 512
 513   return oOOData;
 514 }
 515
 516 //###########################
 517
 518 DataFlavorMapper::DataFlavorMapper()
 519 {
 520     Reference<XMultiServiceFactory> mrServiceManager = vcl::unohelper::GetMultiServiceFactory();
 521     mrXMimeCntFactory = Reference<XMimeContentTypeFactory>(mrServiceManager->createInstance(
 522        OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.datatransfer.MimeContentTypeFactory"))), UNO_QUERY);
 523
 524   if (!mrXMimeCntFactory.is())
 525     throw RuntimeException(OUString(RTL_CONSTASCII_USTRINGPARAM("AquaClipboard: Cannot create com.sun.star.datatransfer.MimeContentTypeFactory")), NULL);
 526 }
 527
 528 DataFlavor DataFlavorMapper::systemToOpenOfficeFlavor(NSString* systemDataFlavor) const
 529 {
 530   DataFlavor oOOFlavor;
 531
 532   for (size_t i = 0; i < SIZE_FLAVOR_MAP; i++)
 533     {
 534       if ([systemDataFlavor caseInsensitiveCompare: flavorMap[i].SystemFlavor] == NSOrderedSame)
 535         {
 536           oOOFlavor.MimeType = OUString::createFromAscii(flavorMap[i].OOoFlavor);
 537           oOOFlavor.HumanPresentableName = OUString(RTL_CONSTASCII_USTRINGPARAM(flavorMap[i].HumanPresentableName));
 538           oOOFlavor.DataType = flavorMap[i].DataType;
 539           return oOOFlavor;
 540         }
 541     } // for
 542
 543   return oOOFlavor;
 544 }
 545
 546 NSString* DataFlavorMapper::openOfficeToSystemFlavor(const DataFlavor& oOOFlavor) const
 547 {
 548   NSString* sysFlavor = NULL;
 549
 550   for (size_t i = 0; i < SIZE_FLAVOR_MAP; i++)
 551     {
 552       if (oOOFlavor.MimeType.compareToAscii(flavorMap[i].OOoFlavor, strlen(flavorMap[i].OOoFlavor)) == 0)
 553         {
 554           sysFlavor = flavorMap[i].SystemFlavor;
 555         }
 556     }
 557
 558   return sysFlavor;
 559 }
 560
 561 DataProviderPtr_t DataFlavorMapper::getDataProvider(NSString* systemFlavor, Reference<XTransferable> rTransferable) const
 562 {
 563   DataProviderPtr_t dp;
 564
 565   try
 566     {
 567       DataFlavor oOOFlavor = systemToOpenOfficeFlavor(systemFlavor);
 568
 569       Any data = rTransferable->getTransferData(oOOFlavor);
 570
 571       if (isByteSequenceType(data.getValueType()))
 572         {
 573           if ([systemFlavor caseInsensitiveCompare: NSHTMLPboardType] == NSOrderedSame)
 574             {
 575               dp = DataProviderPtr_t(new HTMLFormatDataProvider(data));
 576             }
 577           else if ([systemFlavor caseInsensitiveCompare: NSPICTPboardType] == NSOrderedSame)
 578             {
 579               dp = DataProviderPtr_t(new BMPDataProvider(data));
 580             }
 581           else if ([systemFlavor caseInsensitiveCompare: NSFilenamesPboardType] == NSOrderedSame)
 582             {
 583               dp = DataProviderPtr_t(new FileListDataProvider(data));
 584             }
 585           else
 586             {
 587               dp = DataProviderPtr_t(new ByteSequenceDataProvider(data));
 588             }
 589         }
 590       else // Must be OUString type
 591         {
 592           BOOST_ASSERT(isOUStringType(data.getValueType()));
 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) const
 606 {
 607   return DataProviderPtr_t(new FileListDataProvider(systemData));
 608 }
 609
 610 DataProviderPtr_t DataFlavorMapper::getDataProvider(const NSString* systemFlavor, NSData* systemData) const
 611 {
 612   DataProviderPtr_t dp;
 613
 614   if ([systemFlavor caseInsensitiveCompare: NSStringPboardType] == NSOrderedSame)
 615     {
 616       dp = DataProviderPtr_t(new UniDataProvider(systemData));
 617     }
 618   else if ([systemFlavor caseInsensitiveCompare: NSHTMLPboardType] == NSOrderedSame)
 619     {
 620       dp = DataProviderPtr_t(new HTMLFormatDataProvider(systemData));
 621     }
 622   else if ([systemFlavor caseInsensitiveCompare: NSPICTPboardType] == NSOrderedSame)
 623     {
 624       dp = DataProviderPtr_t(new BMPDataProvider(systemData));
 625     }
 626   else if ([systemFlavor caseInsensitiveCompare: NSFilenamesPboardType] == NSOrderedSame)
 627     {
 628       //dp = DataProviderPtr_t(new FileListDataProvider(systemData));
 629     }
 630   else
 631     {
 632       dp = DataProviderPtr_t(new ByteSequenceDataProvider(systemData));
 633     }
 634
 635   return dp;
 636 }
 637
 638 bool DataFlavorMapper::isValidMimeContentType(const rtl::OUString& contentType) const
 639 {
 640   bool result = true;
 641
 642   try
 643     {
 644       Reference<XMimeContentType> xCntType(mrXMimeCntFactory->createMimeContentType(contentType));
 645     }
 646   catch( IllegalArgumentException& )
 647     {
 648       result = false;
 649     }
 650
 651   return result;
 652 }
 653
 654 NSArray* DataFlavorMapper::flavorSequenceToTypesArray(const com::sun::star::uno::Sequence<com::sun::star::datatransfer::DataFlavor>& flavors) const
 655 {
 656   sal_uInt32 nFlavors = flavors.getLength();
 657   NSMutableArray* array = [[NSMutableArray alloc] initWithCapacity: 1];
 658
 659   for (sal_uInt32 i = 0; i < nFlavors; i++)
 660   {
 661       NSString* str = openOfficeToSystemFlavor(flavors[i]);
 662
 663       if (str != NULL)
 664       {
 665           [array addObject: str];
 666       }
 667   }
 668
 669    // #i89462# #i90747#
 670    // in case no system flavor was found to report
 671    // report at least one so D&D between OOo targets works
 672   if( [array count] == 0 )
 673   {
 674       [array addObject: PBTYPE_DUMMY_INTERNAL];
 675   }
 676
 677   return [array autorelease];
 678 }
 679
 680 com::sun::star::uno::Sequence<com::sun::star::datatransfer::DataFlavor> DataFlavorMapper::typesArrayToFlavorSequence(NSArray* types) const
 681 {
 682   int nFormats = [types count];
 683   Sequence<DataFlavor> flavors;
 684
 685   for (int i = 0; i < nFormats; i++)
 686     {
 687       NSString* sysFormat = [types objectAtIndex: i];
 688       DataFlavor oOOFlavor = systemToOpenOfficeFlavor(sysFormat);
 689
 690       if (isValidFlavor(oOOFlavor))
 691         {
 692           flavors.realloc(flavors.getLength() + 1);
 693           flavors[flavors.getLength() - 1] = oOOFlavor;
 694         }
 695     }
 696
 697   return flavors;
 698 }
 699
 700
 701 NSArray* DataFlavorMapper::getAllSupportedPboardTypes() const
 702 {
 703   NSMutableArray* array = [[NSMutableArray alloc] initWithCapacity: SIZE_FLAVOR_MAP];
 704
 705   for (sal_uInt32 i = 0; i < SIZE_FLAVOR_MAP; i++)
 706     {
 707       [array addObject: flavorMap[i].SystemFlavor];
 708     }
 709
 710   return [array autorelease];
 711 }