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