vcl/aqua/source/dtrans/aqua_clipboard.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 "aqua_clipboard.hxx"
  21
  22 #include "DataFlavorMapping.hxx"
  23 #include "OSXTransferable.hxx"
  24 #include <com/sun/star/datatransfer/MimeContentTypeFactory.hpp>
  25 #include "comphelper/makesequence.hxx"
  26 #include "comphelper/processfactory.hxx"
  27
  28 #include <boost/assert.hpp>
  29
  30 using namespace com::sun::star::datatransfer;
  31 using namespace com::sun::star::datatransfer::clipboard;
  32 using namespace com::sun::star::lang;
  33 using namespace com::sun::star::uno;
  34 using namespace cppu;
  35 using namespace osl;
  36 using namespace std;
  37 using namespace comphelper;
  38
  39
  40 @implementation EventListener;
  41
  42 -(EventListener*)initWithAquaClipboard: (AquaClipboard*) pcb
  43 {
  44     self = [super init];
  45
  46     if (self)
  47         pAquaClipboard = pcb;
  48
  49     return self;
  50 }
  51
  52 -(void)pasteboard:(NSPasteboard*)sender provideDataForType:(NSString*)type
  53 {
  54     if( pAquaClipboard )
  55         pAquaClipboard->provideDataForType(sender, type);
  56 }
  57
  58 -(void)applicationDidBecomeActive:(NSNotification*)aNotification
  59 {
  60     if( pAquaClipboard )
  61         pAquaClipboard->applicationDidBecomeActive(aNotification);
  62 }
  63
  64 -(void)disposing
  65 {
  66     pAquaClipboard = NULL;
  67 }
  68
  69 @end
  70
  71
  72 OUString clipboard_getImplementationName()
  73 {
  74   return OUString("com.sun.star.datatransfer.clipboard.AquaClipboard");
  75 }
  76
  77 Sequence<OUString> clipboard_getSupportedServiceNames()
  78 {
  79   return makeSequence(OUString("com.sun.star.datatransfer.clipboard.SystemClipboard"));
  80 }
  81
  82
  83 AquaClipboard::AquaClipboard(NSPasteboard* pasteboard, bool bUseSystemPasteboard) :
  84   WeakComponentImplHelper3<XSystemClipboard, XFlushableClipboard, XServiceInfo>(m_aMutex),
  85   mIsSystemPasteboard(bUseSystemPasteboard)
  86 {
  87     Reference<XComponentContext> xContext = comphelper::getProcessComponentContext();
  88
  89     mrXMimeCntFactory = MimeContentTypeFactory::create(xContext);
  90
  91   mpDataFlavorMapper = DataFlavorMapperPtr_t(new DataFlavorMapper());
  92
  93   if (pasteboard != NULL)
  94     {
  95       mPasteboard = pasteboard;
  96       mIsSystemPasteboard = false;
  97     }
  98   else
  99     {
 100       mPasteboard = bUseSystemPasteboard ? [NSPasteboard generalPasteboard] :
 101         [NSPasteboard pasteboardWithName: NSDragPboard];
 102
 103       if (mPasteboard == nil)
 104         {
 105           throw RuntimeException("AquaClipboard: Cannot create Cocoa pasteboard",
 106                 static_cast<XClipboardEx*>(this));
 107         }
 108     }
 109
 110   [mPasteboard retain];
 111
 112   mEventListener = [[EventListener alloc] initWithAquaClipboard: this];
 113
 114   if (mEventListener == nil)
 115     {
 116       [mPasteboard release];
 117
 118       throw RuntimeException(
 119             OUString("AquaClipboard: Cannot create pasteboard change listener"),
 120             static_cast<XClipboardEx*>(this));
 121     }
 122
 123   if (mIsSystemPasteboard)
 124     {
 125       NSNotificationCenter* notificationCenter = [NSNotificationCenter defaultCenter];
 126
 127       [notificationCenter addObserver: mEventListener
 128        selector: @selector(applicationDidBecomeActive:)
 129        name: @"NSApplicationDidBecomeActiveNotification"
 130        object: [NSApplication sharedApplication]];
 131     }
 132
 133   mPasteboardChangeCount = [mPasteboard changeCount];
 134 }
 135
 136
 137 AquaClipboard::~AquaClipboard()
 138 {
 139   if (mIsSystemPasteboard)
 140     {
 141       [[NSNotificationCenter defaultCenter] removeObserver: mEventListener];
 142     }
 143
 144   [mEventListener disposing];
 145   [mEventListener release];
 146   [mPasteboard release];
 147 }
 148
 149
 150 Reference<XTransferable> SAL_CALL AquaClipboard::getContents() throw(RuntimeException)
 151 {
 152   MutexGuard aGuard(m_aMutex);
 153
 154   // Shortcut: If we are clipboard owner already we don't need
 155   // to drag the data through the system clipboard
 156   if (mXClipboardContent.is())
 157     {
 158       return mXClipboardContent;
 159     }
 160
 161   return Reference<XTransferable>(new OSXTransferable(mrXMimeCntFactory,
 162                                                       mpDataFlavorMapper,
 163                                                       mPasteboard));
 164 }
 165
 166
 167 void SAL_CALL AquaClipboard::setContents(const Reference<XTransferable>& xTransferable,
 168     const Reference<XClipboardOwner>& xClipboardOwner)
 169         throw( RuntimeException )
 170 {
 171     NSArray* types = xTransferable.is() ?
 172         mpDataFlavorMapper->flavorSequenceToTypesArray(xTransferable->getTransferDataFlavors()) :
 173         [NSArray array];
 174
 175     ClearableMutexGuard aGuard(m_aMutex);
 176
 177     Reference<XClipboardOwner> oldOwner(mXClipboardOwner);
 178     mXClipboardOwner = xClipboardOwner;
 179
 180     Reference<XTransferable> oldContent(mXClipboardContent);
 181     mXClipboardContent = xTransferable;
 182
 183     mPasteboardChangeCount = [mPasteboard declareTypes: types owner: mEventListener];
 184
 185     aGuard.clear();
 186
 187     // if we are already the owner of the clipboard
 188     // then fire lost ownership event
 189     if (oldOwner.is())
 190     {
 191         fireLostClipboardOwnershipEvent(oldOwner, oldContent);
 192     }
 193
 194     fireClipboardChangedEvent();
 195 }
 196
 197
 198 OUString SAL_CALL AquaClipboard::getName() throw( RuntimeException )
 199 {
 200   return OUString();
 201 }
 202
 203
 204 sal_Int8 SAL_CALL AquaClipboard::getRenderingCapabilities() throw( RuntimeException )
 205 {
 206     return 0;
 207 }
 208
 209
 210 void SAL_CALL AquaClipboard::addClipboardListener(const Reference< XClipboardListener >& listener)
 211   throw( RuntimeException )
 212 {
 213   MutexGuard aGuard(m_aMutex);
 214
 215   if (!listener.is())
 216      throw IllegalArgumentException("empty reference",
 217                                    static_cast<XClipboardEx*>(this), 1);
 218
 219   mClipboardListeners.push_back(listener);
 220 }
 221
 222
 223 void SAL_CALL AquaClipboard::removeClipboardListener(const Reference< XClipboardListener >& listener)
 224   throw( RuntimeException )
 225 {
 226   MutexGuard aGuard(m_aMutex);
 227
 228   if (!listener.is())
 229      throw IllegalArgumentException("empty reference",
 230                                    static_cast<XClipboardEx*>(this), 1);
 231
 232   mClipboardListeners.remove(listener);
 233 }
 234
 235
 236 void AquaClipboard::applicationDidBecomeActive(NSNotification*)
 237 {
 238   ClearableMutexGuard aGuard(m_aMutex);
 239
 240   int currentPboardChgCount = [mPasteboard changeCount];
 241
 242   if (currentPboardChgCount != mPasteboardChangeCount)
 243     {
 244       mPasteboardChangeCount = currentPboardChgCount;
 245
 246       // Clear clipboard content and owner and send lostOwnership
 247       // notification to the old clipboard owner as well as
 248       // ClipboardChanged notification to any clipboard listener
 249       Reference<XClipboardOwner> oldOwner(mXClipboardOwner);
 250       mXClipboardOwner.clear();
 251
 252       Reference<XTransferable> oldContent(mXClipboardContent);
 253       mXClipboardContent.clear();
 254
 255       aGuard.clear();
 256
 257       if (oldOwner.is())
 258         {
 259           fireLostClipboardOwnershipEvent(oldOwner, oldContent);
 260         }
 261
 262       fireClipboardChangedEvent();
 263     }
 264 }
 265
 266
 267 void AquaClipboard::fireClipboardChangedEvent()
 268 {
 269     ClearableMutexGuard aGuard(m_aMutex);
 270
 271     list<Reference< XClipboardListener > > listeners(mClipboardListeners);
 272     ClipboardEvent aEvent;
 273
 274     if (listeners.begin() != listeners.end())
 275       {
 276         aEvent = ClipboardEvent(static_cast<OWeakObject*>(this), getContents());
 277       }
 278
 279     aGuard.clear();
 280
 281     while (listeners.begin() != listeners.end())
 282     {
 283         if (listeners.front().is())
 284           {
 285             try { listeners.front()->changedContents(aEvent); }
 286             catch (RuntimeException&) { }
 287           }
 288         listeners.pop_front();
 289     }
 290 }
 291
 292
 293 void AquaClipboard::fireLostClipboardOwnershipEvent(Reference<XClipboardOwner> oldOwner, Reference<XTransferable> oldContent)
 294 {
 295   BOOST_ASSERT(oldOwner.is());
 296
 297   try { oldOwner->lostOwnership(static_cast<XClipboardEx*>(this), oldContent); }
 298   catch(RuntimeException&) { }
 299 }
 300
 301
 302 void AquaClipboard::provideDataForType(NSPasteboard* sender, NSString* type)
 303 {
 304     if( mXClipboardContent.is() )
 305     {
 306         DataProviderPtr_t dp = mpDataFlavorMapper->getDataProvider(type, mXClipboardContent);
 307         NSData* pBoardData = NULL;
 308
 309         if (dp.get() != NULL)
 310         {
 311             pBoardData = (NSData*)dp->getSystemData();
 312             [sender setData: pBoardData forType: type];
 313         }
 314     }
 315 }
 316
 317
 318 //------------------------------------------------
 319 // XFlushableClipboard
 320 //------------------------------------------------
 321
 322 void SAL_CALL AquaClipboard::flushClipboard()
 323   throw(RuntimeException)
 324 {
 325     if (mXClipboardContent.is())
 326     {
 327           Sequence<DataFlavor> flavorList = mXClipboardContent->getTransferDataFlavors();
 328         sal_uInt32 nFlavors = flavorList.getLength();
 329         bool bInternal(false);
 330
 331         for (sal_uInt32 i = 0; i < nFlavors; i++)
 332         {
 333             NSString* sysType = mpDataFlavorMapper->openOfficeToSystemFlavor(flavorList[i], bInternal);
 334
 335             if (sysType != NULL)
 336             {
 337                 provideDataForType(mPasteboard, sysType);
 338             }
 339         }
 340         mXClipboardContent.clear();
 341     }
 342 }
 343
 344
 345 NSPasteboard* AquaClipboard::getPasteboard() const
 346 {
 347   return mPasteboard;
 348 }
 349
 350
 351 //-------------------------------------------------
 352 // XServiceInfo
 353 //-------------------------------------------------
 354
 355 OUString SAL_CALL AquaClipboard::getImplementationName() throw( RuntimeException )
 356 {
 357   return clipboard_getImplementationName();
 358 }
 359
 360
 361 sal_Bool SAL_CALL AquaClipboard::supportsService( const OUString& /*ServiceName*/ ) throw( RuntimeException )
 362 {
 363     return sal_False;
 364 }
 365
 366
 367 Sequence< OUString > SAL_CALL AquaClipboard::getSupportedServiceNames() throw( RuntimeException )
 368 {
 369   return clipboard_getSupportedServiceNames();
 370 }
 371
 372 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */