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