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