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