1 /************************************************************** 2 * 3 * Licensed to the Apache Software Foundation (ASF) under one 4 * or more contributor license agreements. See the NOTICE file 5 * distributed with this work for additional information 6 * regarding copyright ownership. The ASF licenses this file 7 * to you under the Apache License, Version 2.0 (the 8 * "License"); you may not use this file except in compliance 9 * with the License. You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, 14 * software distributed under the License is distributed on an 15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16 * KIND, either express or implied. See the License for the 17 * specific language governing permissions and limitations 18 * under the License. 19 * 20 *************************************************************/ 21 22 23 24 // MARKER(update_precomp.py): autogen include statement, do not remove 25 #include "precompiled_vcl.hxx" 26 27 #include "unx/saldisp.hxx" 28 #include "unx/saldata.hxx" 29 30 #include <unistd.h> 31 #include <stdio.h> 32 #include <string.h> 33 #include <sys/time.h> 34 35 #include "tools/prex.h" 36 #include <X11/Xatom.h> 37 #include <X11/keysym.h> 38 #include <X11/Xutil.h> 39 #include "tools/postx.h" 40 #if defined(LINUX) || defined(NETBSD) || defined (FREEBSD) 41 #include <sys/poll.h> 42 #else 43 #include <poll.h> 44 #endif 45 #include <sal/alloca.h> 46 47 #include <X11_selection.hxx> 48 #include <X11_clipboard.hxx> 49 #include <X11_transferable.hxx> 50 #include <X11_dndcontext.hxx> 51 #include <bmp.hxx> 52 53 #include "vcl/svapp.hxx" 54 55 // pointer bitmaps 56 #include <copydata_curs.h> 57 #include <copydata_mask.h> 58 #include <movedata_curs.h> 59 #include <movedata_mask.h> 60 #include <linkdata_curs.h> 61 #include <linkdata_mask.h> 62 #include <nodrop_curs.h> 63 #include <nodrop_mask.h> 64 #include <com/sun/star/datatransfer/dnd/DNDConstants.hpp> 65 #include <com/sun/star/awt/MouseEvent.hpp> 66 #include <com/sun/star/awt/MouseButton.hpp> 67 #include <rtl/tencinfo.h> 68 #include <osl/process.h> 69 70 #include <comphelper/processfactory.hxx> 71 #include <vos/mutex.hxx> 72 73 #define DRAG_EVENT_MASK ButtonPressMask |\ 74 ButtonReleaseMask |\ 75 PointerMotionMask |\ 76 EnterWindowMask |\ 77 LeaveWindowMask 78 79 namespace { 80 81 namespace css = com::sun::star; 82 83 } 84 85 using namespace com::sun::star::datatransfer; 86 using namespace com::sun::star::datatransfer::dnd; 87 using namespace com::sun::star::lang; 88 using namespace com::sun::star::awt; 89 using namespace com::sun::star::uno; 90 using namespace com::sun::star::frame; 91 using namespace cppu; 92 using namespace osl; 93 using namespace rtl; 94 95 using namespace x11; 96 97 // stubs to satisfy solaris compiler's rather rigid linking warning 98 extern "C" 99 { 100 static void call_SelectionManager_run( void * pMgr ) 101 { 102 SelectionManager::run( pMgr ); 103 } 104 105 static void call_SelectionManager_runDragExecute( void * pMgr ) 106 { 107 SelectionManager::runDragExecute( pMgr ); 108 } 109 } 110 111 112 static const long nXdndProtocolRevision = 5; 113 114 // mapping between mime types (or what the office thinks of mime types) 115 // and X convention types 116 struct NativeTypeEntry 117 { 118 Atom nAtom; 119 const char* pType; // Mime encoding on our side 120 const char* pNativeType; // string corresponding to nAtom for the case of nAtom being uninitialized 121 int nFormat; // the corresponding format 122 }; 123 124 // the convention for Xdnd is mime types as specified by the corresponding 125 // RFC's with the addition that text/plain without charset tag contains iso8859-1 126 // sadly some applications (e.g. gtk) do not honor the mimetype only rule, 127 // so for compatibility add UTF8_STRING 128 static NativeTypeEntry aXdndConversionTab[] = 129 { 130 { 0, "text/plain;charset=iso8859-1", "text/plain", 8 }, 131 { 0, "text/plain;charset=utf-8", "UTF8_STRING", 8 } 132 }; 133 134 // for clipboard and primary selections there is only a convention for text 135 // that the encoding name of the text is taken as type in all capitalized letters 136 static NativeTypeEntry aNativeConversionTab[] = 137 { 138 { 0, "text/plain;charset=utf-16", "ISO10646-1", 16 }, 139 { 0, "text/plain;charset=utf-8", "UTF8_STRING", 8 }, 140 { 0, "text/plain;charset=utf-8", "UTF-8", 8 }, 141 { 0, "text/plain;charset=utf-8", "text/plain;charset=UTF-8", 8 }, 142 // ISO encodings 143 { 0, "text/plain;charset=iso8859-2", "ISO8859-2", 8 }, 144 { 0, "text/plain;charset=iso8859-3", "ISO8859-3", 8 }, 145 { 0, "text/plain;charset=iso8859-4", "ISO8859-4", 8 }, 146 { 0, "text/plain;charset=iso8859-5", "ISO8859-5", 8 }, 147 { 0, "text/plain;charset=iso8859-6", "ISO8859-6", 8 }, 148 { 0, "text/plain;charset=iso8859-7", "ISO8859-7", 8 }, 149 { 0, "text/plain;charset=iso8859-8", "ISO8859-8", 8 }, 150 { 0, "text/plain;charset=iso8859-9", "ISO8859-9", 8 }, 151 { 0, "text/plain;charset=iso8859-10", "ISO8859-10", 8 }, 152 { 0, "text/plain;charset=iso8859-13", "ISO8859-13", 8 }, 153 { 0, "text/plain;charset=iso8859-14", "ISO8859-14", 8 }, 154 { 0, "text/plain;charset=iso8859-15", "ISO8859-15", 8 }, 155 // asian encodings 156 { 0, "text/plain;charset=jisx0201.1976-0", "JISX0201.1976-0", 8 }, 157 { 0, "text/plain;charset=jisx0208.1983-0", "JISX0208.1983-0", 8 }, 158 { 0, "text/plain;charset=jisx0208.1990-0", "JISX0208.1990-0", 8 }, 159 { 0, "text/plain;charset=jisx0212.1990-0", "JISX0212.1990-0", 8 }, 160 { 0, "text/plain;charset=gb2312.1980-0", "GB2312.1980-0", 8 }, 161 { 0, "text/plain;charset=ksc5601.1992-0", "KSC5601.1992-0", 8 }, 162 // eastern european encodings 163 { 0, "text/plain;charset=koi8-r", "KOI8-R", 8 }, 164 { 0, "text/plain;charset=koi8-u", "KOI8-U", 8 }, 165 // String (== iso8859-1) 166 { XA_STRING, "text/plain;charset=iso8859-1", "STRING", 8 }, 167 // special for compound text 168 { 0, "text/plain;charset=compound_text", "COMPOUND_TEXT", 8 }, 169 170 // PIXMAP 171 { XA_PIXMAP, "image/bmp", "PIXMAP", 32 } 172 }; 173 174 rtl_TextEncoding x11::getTextPlainEncoding( const OUString& rMimeType ) 175 { 176 rtl_TextEncoding aEncoding = RTL_TEXTENCODING_DONTKNOW; 177 OUString aMimeType( rMimeType.toAsciiLowerCase() ); 178 sal_Int32 nIndex = 0; 179 if( aMimeType.getToken( 0, ';', nIndex ).equalsAsciiL( "text/plain" , 10 ) ) 180 { 181 if( aMimeType.getLength() == 10 ) // only "text/plain" 182 aEncoding = RTL_TEXTENCODING_ISO_8859_1; 183 else 184 { 185 while( nIndex != -1 ) 186 { 187 OUString aToken = aMimeType.getToken( 0, ';', nIndex ); 188 sal_Int32 nPos = 0; 189 if( aToken.getToken( 0, '=', nPos ).equalsAsciiL( "charset", 7 ) ) 190 { 191 OString aEncToken = OUStringToOString( aToken.getToken( 0, '=', nPos ), RTL_TEXTENCODING_ISO_8859_1 ); 192 aEncoding = rtl_getTextEncodingFromUnixCharset( aEncToken.getStr() ); 193 if( aEncoding == RTL_TEXTENCODING_DONTKNOW ) 194 { 195 if( aEncToken.equalsIgnoreAsciiCase( "utf-8" ) ) 196 aEncoding = RTL_TEXTENCODING_UTF8; 197 } 198 if( aEncoding != RTL_TEXTENCODING_DONTKNOW ) 199 break; 200 } 201 } 202 } 203 } 204 #if OSL_DEBUG_LEVEL > 1 205 if( aEncoding == RTL_TEXTENCODING_DONTKNOW ) 206 fprintf( stderr, "getTextPlainEncoding( %s ) failed\n", OUStringToOString( rMimeType, RTL_TEXTENCODING_ISO_8859_1 ).getStr() ); 207 #endif 208 return aEncoding; 209 } 210 211 // ------------------------------------------------------------------------ 212 213 ::std::hash_map< OUString, SelectionManager*, OUStringHash >& SelectionManager::getInstances() 214 { 215 static ::std::hash_map< OUString, SelectionManager*, OUStringHash > aInstances; 216 return aInstances; 217 } 218 219 // ------------------------------------------------------------------------ 220 221 SelectionManager::SelectionManager() : 222 m_nIncrementalThreshold( 15*1024 ), 223 m_pDisplay( NULL ), 224 m_aThread( NULL ), 225 m_aDragExecuteThread( NULL ), 226 m_aWindow( None ), 227 m_nSelectionTimeout( 0 ), 228 m_nSelectionTimestamp( CurrentTime ), 229 m_bDropEnterSent( true ), 230 m_aCurrentDropWindow( None ), 231 m_nDropTime( None ), 232 m_nLastDropAction( 0 ), 233 m_nLastX( 0 ), 234 m_nLastY( 0 ), 235 m_nDropTimestamp( 0 ), 236 m_bDropWaitingForCompletion( false ), 237 m_aDropWindow( None ), 238 m_aDropProxy( None ), 239 m_aDragSourceWindow( None ), 240 m_nLastDragX( 0 ), 241 m_nLastDragY( 0 ), 242 m_nNoPosX( 0 ), 243 m_nNoPosY( 0 ), 244 m_nNoPosWidth( 0 ), 245 m_nNoPosHeight( 0 ), 246 m_nDragButton( 0 ), 247 m_nUserDragAction( 0 ), 248 m_nTargetAcceptAction( 0 ), 249 m_nSourceActions( 0 ), 250 m_bLastDropAccepted( false ), 251 m_bDropSuccess( false ), 252 m_bDropSent( false ), 253 m_bWaitingForPrimaryConversion( false ), 254 m_nDragTimestamp( None ), 255 m_aMoveCursor( None ), 256 m_aCopyCursor( None ), 257 m_aLinkCursor( None ), 258 m_aNoneCursor( None ), 259 m_aCurrentCursor( None ), 260 m_nCurrentProtocolVersion( nXdndProtocolRevision ), 261 m_nCLIPBOARDAtom( None ), 262 m_nTARGETSAtom( None ), 263 m_nTIMESTAMPAtom( None ), 264 m_nTEXTAtom( None ), 265 m_nINCRAtom( None ), 266 m_nCOMPOUNDAtom( None ), 267 m_nMULTIPLEAtom( None ), 268 m_nUTF16Atom( None ), 269 m_nImageBmpAtom( None ), 270 m_nXdndAware( None ), 271 m_nXdndEnter( None ), 272 m_nXdndLeave( None ), 273 m_nXdndPosition( None ), 274 m_nXdndStatus( None ), 275 m_nXdndDrop( None ), 276 m_nXdndFinished( None ), 277 m_nXdndSelection( None ), 278 m_nXdndTypeList( None ), 279 m_nXdndProxy( None ), 280 m_nXdndActionCopy( None ), 281 m_nXdndActionMove( None ), 282 m_nXdndActionLink( None ), 283 m_nXdndActionAsk( None ), 284 m_nXdndActionPrivate( None ), 285 m_bShutDown( false ) 286 { 287 m_aDropEnterEvent.data.l[0] = None; 288 m_aDragRunning.reset(); 289 } 290 291 XLIB_Cursor SelectionManager::createCursor( const char* pPointerData, const char* pMaskData, int width, int height, int hotX, int hotY ) 292 { 293 Pixmap aPointer; 294 Pixmap aMask; 295 XColor aBlack, aWhite; 296 297 aBlack.pixel = BlackPixel( m_pDisplay, 0 ); 298 aBlack.red = aBlack.green = aBlack.blue = 0; 299 aBlack.flags = DoRed | DoGreen | DoBlue; 300 301 aWhite.pixel = WhitePixel( m_pDisplay, 0 ); 302 aWhite.red = aWhite.green = aWhite.blue = 0xffff; 303 aWhite.flags = DoRed | DoGreen | DoBlue; 304 305 aPointer = 306 XCreateBitmapFromData( m_pDisplay, 307 m_aWindow, 308 pPointerData, 309 width, 310 height ); 311 aMask 312 = XCreateBitmapFromData( m_pDisplay, 313 m_aWindow, 314 pMaskData, 315 width, 316 height ); 317 XLIB_Cursor aCursor = 318 XCreatePixmapCursor( m_pDisplay, aPointer, aMask, 319 &aBlack, &aWhite, 320 hotX, 321 hotY ); 322 XFreePixmap( m_pDisplay, aPointer ); 323 XFreePixmap( m_pDisplay, aMask ); 324 325 return aCursor; 326 } 327 328 void SelectionManager::initialize( const Sequence< Any >& arguments ) throw (::com::sun::star::uno::Exception) 329 { 330 MutexGuard aGuard(m_aMutex); 331 332 if( ! m_xDisplayConnection.is() ) 333 { 334 /* 335 * first argument must be a ::com::sun::star::awt::XDisplayConnection 336 * from this we will get the XEvents of the vcl event loop by 337 * registering us as XEventHandler on it. 338 * 339 * implementor's note: 340 * FIXME: 341 * finally the clipboard and XDND service is back in the module it belongs 342 * now cleanup and sharing of resources with the normal vcl event loop 343 * needs to be added. The display used whould be that of the normal event loop 344 * and synchronization should be done via the SolarMutex. 345 */ 346 if( arguments.getLength() > 0 ) 347 arguments.getConstArray()[0] >>= m_xDisplayConnection; 348 if( ! m_xDisplayConnection.is() ) 349 { 350 #if 0 351 // for the time being try to live without XDisplayConnection 352 // for the sake of clipboard service 353 // clipboard service should be initialized with a XDisplayConnection 354 // in the future 355 Exception aExc; 356 aExc.Message = OUString::createFromAscii( "initialize me with a valid XDisplayConnection" ); 357 aExc.Context = static_cast< OWeakObject* >(this); 358 throw aExc; 359 #endif 360 } 361 else 362 m_xDisplayConnection->addEventHandler( Any(), this, ~0 ); 363 } 364 365 if( !m_xBitmapConverter.is() ) 366 { 367 if( arguments.getLength() > 2 ) 368 arguments.getConstArray()[2] >>= m_xBitmapConverter; 369 } 370 371 OUString aParam; 372 if( ! m_pDisplay ) 373 { 374 OUString aUDisplay; 375 if( m_xDisplayConnection.is() ) 376 { 377 Any aIdentifier; 378 aIdentifier = m_xDisplayConnection->getIdentifier(); 379 aIdentifier >>= aUDisplay; 380 } 381 382 OString aDisplayName( OUStringToOString( aUDisplay, RTL_TEXTENCODING_ISO_8859_1 ) ); 383 384 m_pDisplay = XOpenDisplay( aDisplayName.getLength() ? aDisplayName.getStr() : NULL ); 385 386 if( m_pDisplay ) 387 { 388 #ifdef SYNCHRONIZE 389 XSynchronize( m_pDisplay, True ); 390 #endif 391 // clipboard selection 392 m_nCLIPBOARDAtom = getAtom( OUString::createFromAscii( "CLIPBOARD" ) ); 393 394 // special targets 395 m_nTARGETSAtom = getAtom( OUString::createFromAscii( "TARGETS" ) ); 396 m_nTIMESTAMPAtom = getAtom( OUString::createFromAscii( "TIMESTAMP" ) ); 397 m_nTEXTAtom = getAtom( OUString::createFromAscii( "TEXT" ) ); 398 m_nINCRAtom = getAtom( OUString::createFromAscii( "INCR" ) ); 399 m_nCOMPOUNDAtom = getAtom( OUString::createFromAscii( "COMPOUND_TEXT" ) ); 400 m_nMULTIPLEAtom = getAtom( OUString::createFromAscii( "MULTIPLE" ) ); 401 m_nUTF16Atom = getAtom( OUString::createFromAscii( "ISO10646-1" ) ); 402 // m_nUTF16Atom = getAtom( OUString::createFromAscii( "text/plain;charset=ISO-10646-UCS-2" ) ); 403 m_nImageBmpAtom = getAtom( OUString::createFromAscii( "image/bmp" ) ); 404 405 // Atoms for Xdnd protocol 406 m_nXdndAware = getAtom( OUString::createFromAscii( "XdndAware" ) ); 407 m_nXdndEnter = getAtom( OUString::createFromAscii( "XdndEnter" ) ); 408 m_nXdndLeave = getAtom( OUString::createFromAscii( "XdndLeave" ) ); 409 m_nXdndPosition = getAtom( OUString::createFromAscii( "XdndPosition" ) ); 410 m_nXdndStatus = getAtom( OUString::createFromAscii( "XdndStatus" ) ); 411 m_nXdndDrop = getAtom( OUString::createFromAscii( "XdndDrop" ) ); 412 m_nXdndFinished = getAtom( OUString::createFromAscii( "XdndFinished" ) ); 413 m_nXdndSelection = getAtom( OUString::createFromAscii( "XdndSelection" ) ); 414 m_nXdndTypeList = getAtom( OUString::createFromAscii( "XdndTypeList" ) ); 415 m_nXdndProxy = getAtom( OUString::createFromAscii( "XdndProxy" ) ); 416 m_nXdndActionCopy = getAtom( OUString::createFromAscii( "XdndActionCopy" ) ); 417 m_nXdndActionMove = getAtom( OUString::createFromAscii( "XdndActionMove" ) ); 418 m_nXdndActionLink = getAtom( OUString::createFromAscii( "XdndActionLink" ) ); 419 m_nXdndActionAsk = getAtom( OUString::createFromAscii( "XdndActionAsk" ) ); 420 m_nXdndActionPrivate= getAtom( OUString::createFromAscii( "XdndActionPrivate" ) ); 421 422 // initialize map with member none 423 m_aAtomToString[ 0 ]= OUString::createFromAscii( "None" ); 424 m_aAtomToString[ XA_PRIMARY ] = OUString::createFromAscii( "PRIMARY" ); 425 426 // create a (invisible) message window 427 m_aWindow = XCreateSimpleWindow( m_pDisplay, DefaultRootWindow( m_pDisplay ), 428 10, 10, 10, 10, 0, 0, 1 ); 429 430 // initialize threshold for incremetal transfers 431 // ICCCM says it should be smaller that the max request size 432 // which in turn is guaranteed to be at least 16k bytes 433 m_nIncrementalThreshold = XMaxRequestSize( m_pDisplay ) - 1024; 434 435 if( m_aWindow ) 436 { 437 #define createCursorFromXPM(name) createCursor((const char*)name##curs##_bits, (const char*)name##mask##_bits, name##curs_width, name##curs_height, name##curs_x_hot, name##curs_y_hot ); 438 // initialize default cursors 439 m_aMoveCursor = createCursorFromXPM( movedata_); 440 m_aCopyCursor = createCursorFromXPM( copydata_); 441 m_aLinkCursor = createCursorFromXPM( linkdata_); 442 m_aNoneCursor = createCursorFromXPM( nodrop_); 443 444 // just interested in SelectionClear/Notify/Request and PropertyChange 445 XSelectInput( m_pDisplay, m_aWindow, PropertyChangeMask ); 446 // create the transferable for Drag operations 447 m_xDropTransferable = new X11Transferable( *this, static_cast< OWeakObject* >(this), m_nXdndSelection ); 448 registerHandler( m_nXdndSelection, *this ); 449 450 m_aThread = osl_createSuspendedThread( call_SelectionManager_run, this ); 451 if( m_aThread ) 452 osl_resumeThread( m_aThread ); 453 #if OSL_DEBUG_LEVEL > 1 454 else 455 fprintf( stderr, "SelectionManager::initialize: creation of dispatch thread failed !\n" ); 456 #endif 457 } 458 } 459 } 460 } 461 462 // ------------------------------------------------------------------------ 463 464 SelectionManager::~SelectionManager() 465 { 466 #if OSL_DEBUG_LEVEL > 1 467 fprintf( stderr, "SelectionManager::~SelectionManager (%s)\n", m_pDisplay ? DisplayString(m_pDisplay) : "no display" ); 468 #endif 469 { 470 MutexGuard aGuard( *Mutex::getGlobalMutex() ); 471 472 ::std::hash_map< OUString, SelectionManager*, OUStringHash >::iterator it; 473 for( it = getInstances().begin(); it != getInstances().end(); ++it ) 474 if( it->second == this ) 475 { 476 getInstances().erase( it ); 477 break; 478 } 479 } 480 481 if( m_aThread ) 482 { 483 osl_terminateThread( m_aThread ); 484 osl_joinWithThread( m_aThread ); 485 osl_destroyThread( m_aThread ); 486 } 487 488 if( m_aDragExecuteThread ) 489 { 490 osl_terminateThread( m_aDragExecuteThread ); 491 osl_joinWithThread( m_aDragExecuteThread ); 492 m_aDragExecuteThread = NULL; 493 // thread handle is freed in dragDoDispatch() 494 } 495 496 MutexGuard aGuard(m_aMutex); 497 498 #if OSL_DEBUG_LEVEL > 1 499 fprintf( stderr, "shutting down SelectionManager\n" ); 500 #endif 501 502 if( m_xDisplayConnection.is() ) 503 { 504 m_xDisplayConnection->removeEventHandler( Any(), this ); 505 m_xDisplayConnection.clear(); 506 } 507 508 if( m_pDisplay ) 509 { 510 deregisterHandler( m_nXdndSelection ); 511 // destroy message window 512 if( m_aWindow ) 513 XDestroyWindow( m_pDisplay, m_aWindow ); 514 // release cursors 515 if (m_aMoveCursor != None) 516 XFreeCursor(m_pDisplay, m_aMoveCursor); 517 if (m_aCopyCursor != None) 518 XFreeCursor(m_pDisplay, m_aCopyCursor); 519 if (m_aLinkCursor != None) 520 XFreeCursor(m_pDisplay, m_aLinkCursor); 521 if (m_aNoneCursor != None) 522 XFreeCursor(m_pDisplay, m_aNoneCursor); 523 524 // paranoia setting, the drag thread should have 525 // done that already 526 XUngrabPointer( m_pDisplay, CurrentTime ); 527 XUngrabKeyboard( m_pDisplay, CurrentTime ); 528 529 XCloseDisplay( m_pDisplay ); 530 } 531 } 532 533 // ------------------------------------------------------------------------ 534 535 SelectionAdaptor* SelectionManager::getAdaptor( Atom selection ) 536 { 537 ::std::hash_map< Atom, Selection* >::iterator it = 538 m_aSelections.find( selection ); 539 return it != m_aSelections.end() ? it->second->m_pAdaptor : NULL; 540 } 541 542 // ------------------------------------------------------------------------ 543 544 OUString SelectionManager::convertFromCompound( const char* pText, int nLen ) 545 { 546 MutexGuard aGuard( m_aMutex ); 547 OUString aRet; 548 if( nLen < 0 ) 549 nLen = strlen( pText ); 550 551 char** pTextList = NULL; 552 int nTexts = 0; 553 554 XTextProperty aProp; 555 aProp.value = (unsigned char*)pText; 556 aProp.encoding = m_nCOMPOUNDAtom; 557 aProp.format = 8; 558 aProp.nitems = nLen; 559 XmbTextPropertyToTextList( m_pDisplay, 560 &aProp, 561 &pTextList, 562 &nTexts ); 563 rtl_TextEncoding aEncoding = osl_getThreadTextEncoding(); 564 for( int i = 0; i < nTexts; i++ ) 565 aRet += OStringToOUString( pTextList[i], aEncoding ); 566 567 if( pTextList ) 568 XFreeStringList( pTextList ); 569 570 return aRet; 571 } 572 573 // ------------------------------------------------------------------------ 574 575 OString SelectionManager::convertToCompound( const OUString& rText ) 576 { 577 MutexGuard aGuard( m_aMutex ); 578 XTextProperty aProp; 579 aProp.value = NULL; 580 aProp.encoding = XA_STRING; 581 aProp.format = 8; 582 aProp.nitems = 0; 583 584 OString aRet( rText.getStr(), rText.getLength(), osl_getThreadTextEncoding() ); 585 char* pT = const_cast<char*>(aRet.getStr()); 586 587 XmbTextListToTextProperty( m_pDisplay, 588 &pT, 589 1, 590 XCompoundTextStyle, 591 &aProp ); 592 if( aProp.value ) 593 { 594 aRet = (char*)aProp.value; 595 XFree( aProp.value ); 596 #ifdef SOLARIS 597 /* #97070# 598 * for currently unknown reasons XmbTextListToTextProperty on Solaris returns 599 * no data in ISO8859-n encodings (at least for n = 1, 15) 600 * in these encodings the directly converted text does the 601 * trick, also. 602 */ 603 if( ! aRet.getLength() && rText.getLength() ) 604 aRet = OUStringToOString( rText, osl_getThreadTextEncoding() ); 605 #endif 606 } 607 else 608 aRet = OString(); 609 610 return aRet; 611 } 612 613 // ------------------------------------------------------------------------ 614 615 bool SelectionManager::convertData( 616 const css::uno::Reference< XTransferable >& xTransferable, 617 Atom nType, 618 Atom nSelection, 619 int& rFormat, 620 Sequence< sal_Int8 >& rData ) 621 { 622 bool bSuccess = false; 623 624 if( ! xTransferable.is() ) 625 return bSuccess; 626 627 try 628 { 629 630 DataFlavor aFlavor; 631 aFlavor.MimeType = convertTypeFromNative( nType, nSelection, rFormat ); 632 633 sal_Int32 nIndex = 0; 634 if( aFlavor.MimeType.getToken( 0, ';', nIndex ).compareToAscii( "text/plain" ) == 0 ) 635 { 636 if( aFlavor.MimeType.getToken( 0, ';', nIndex ).compareToAscii( "charset=utf-16" ) == 0 ) 637 aFlavor.DataType = getCppuType( (OUString *) 0 ); 638 else 639 aFlavor.DataType = getCppuType( (Sequence< sal_Int8 >*)0 ); 640 } 641 else 642 aFlavor.DataType = getCppuType( (Sequence< sal_Int8 >*)0 ); 643 644 if( xTransferable->isDataFlavorSupported( aFlavor ) ) 645 { 646 Any aValue( xTransferable->getTransferData( aFlavor ) ); 647 if( aValue.getValueTypeClass() == TypeClass_STRING ) 648 { 649 OUString aString; 650 aValue >>= aString; 651 rData = Sequence< sal_Int8 >( (sal_Int8*)aString.getStr(), aString.getLength() * sizeof( sal_Unicode ) ); 652 bSuccess = true; 653 } 654 else if( aValue.getValueType() == getCppuType( (Sequence< sal_Int8 >*)0 ) ) 655 { 656 aValue >>= rData; 657 bSuccess = true; 658 } 659 } 660 else if( aFlavor.MimeType.compareToAscii( "text/plain", 10 ) == 0 ) 661 { 662 rtl_TextEncoding aEncoding = RTL_TEXTENCODING_DONTKNOW; 663 bool bCompoundText = false; 664 if( nType == m_nCOMPOUNDAtom ) 665 bCompoundText = true; 666 else 667 aEncoding = getTextPlainEncoding( aFlavor.MimeType ); 668 if( aEncoding != RTL_TEXTENCODING_DONTKNOW || bCompoundText ) 669 { 670 aFlavor.MimeType = OUString::createFromAscii( "text/plain;charset=utf-16" ); 671 aFlavor.DataType = getCppuType( (OUString *) 0 ); 672 if( xTransferable->isDataFlavorSupported( aFlavor ) ) 673 { 674 Any aValue( xTransferable->getTransferData( aFlavor ) ); 675 OUString aString; 676 aValue >>= aString; 677 OString aByteString( bCompoundText ? convertToCompound( aString ) : OUStringToOString( aString, aEncoding ) ); 678 rData = Sequence< sal_Int8 >( (sal_Int8*)aByteString.getStr(), aByteString.getLength() * sizeof( sal_Char ) ); 679 bSuccess = true; 680 } 681 } 682 } 683 } 684 // various exceptions possible ... which all lead to a failed conversion 685 // so simplify here to a catch all 686 catch(...) 687 { 688 } 689 690 return bSuccess; 691 } 692 693 // ------------------------------------------------------------------------ 694 695 SelectionManager& SelectionManager::get( const OUString& rDisplayName ) 696 { 697 MutexGuard aGuard( *Mutex::getGlobalMutex() ); 698 699 OUString aDisplayName( rDisplayName ); 700 if( ! aDisplayName.getLength() ) 701 aDisplayName = OStringToOUString( getenv( "DISPLAY" ), RTL_TEXTENCODING_ISO_8859_1 ); 702 SelectionManager* pInstance = NULL; 703 704 ::std::hash_map< OUString, SelectionManager*, OUStringHash >::iterator it = getInstances().find( aDisplayName ); 705 if( it != getInstances().end() ) 706 pInstance = it->second; 707 else pInstance = getInstances()[ aDisplayName ] = new SelectionManager(); 708 709 return *pInstance; 710 } 711 712 // ------------------------------------------------------------------------ 713 714 const OUString& SelectionManager::getString( Atom aAtom ) 715 { 716 MutexGuard aGuard(m_aMutex); 717 718 ::std::hash_map< Atom, OUString >::const_iterator it; 719 if( ( it = m_aAtomToString.find( aAtom ) ) == m_aAtomToString.end() ) 720 { 721 static OUString aEmpty; 722 char* pAtom = m_pDisplay ? XGetAtomName( m_pDisplay, aAtom ) : NULL; 723 if( ! pAtom ) 724 return aEmpty; 725 OUString aString( OStringToOUString( pAtom, RTL_TEXTENCODING_ISO_8859_1 ) ); 726 XFree( pAtom ); 727 m_aStringToAtom[ aString ] = aAtom; 728 m_aAtomToString[ aAtom ] = aString; 729 } 730 return m_aAtomToString[ aAtom ]; 731 } 732 733 // ------------------------------------------------------------------------ 734 735 Atom SelectionManager::getAtom( const OUString& rString ) 736 { 737 MutexGuard aGuard(m_aMutex); 738 739 ::std::hash_map< OUString, Atom, OUStringHash >::const_iterator it; 740 if( ( it = m_aStringToAtom.find( rString ) ) == m_aStringToAtom.end() ) 741 { 742 static Atom nNoDisplayAtoms = 1; 743 Atom aAtom = m_pDisplay ? XInternAtom( m_pDisplay, OUStringToOString( rString, RTL_TEXTENCODING_ISO_8859_1).getStr(), False ) : nNoDisplayAtoms++; 744 m_aStringToAtom[ rString ] = aAtom; 745 m_aAtomToString[ aAtom ] = rString; 746 } 747 return m_aStringToAtom[ rString ]; 748 } 749 750 // ------------------------------------------------------------------------ 751 752 bool SelectionManager::requestOwnership( Atom selection ) 753 { 754 bool bSuccess = false; 755 if( m_pDisplay && m_aWindow ) 756 { 757 MutexGuard aGuard(m_aMutex); 758 759 SelectionAdaptor* pAdaptor = getAdaptor( selection ); 760 if( pAdaptor ) 761 { 762 XSetSelectionOwner( m_pDisplay, selection, m_aWindow, CurrentTime ); 763 if( XGetSelectionOwner( m_pDisplay, selection ) == m_aWindow ) 764 bSuccess = true; 765 #if OSL_DEBUG_LEVEL > 1 766 fprintf( stderr, "%s ownership for selection %s\n", 767 bSuccess ? "acquired" : "failed to acquire", 768 OUStringToOString( getString( selection ), RTL_TEXTENCODING_ISO_8859_1 ).getStr() ); 769 #endif 770 Selection* pSel = m_aSelections[ selection ]; 771 pSel->m_bOwner = bSuccess; 772 delete pSel->m_pPixmap; 773 pSel->m_pPixmap = NULL; 774 pSel->m_nOrigTimestamp = m_nSelectionTimestamp; 775 } 776 #if OSL_DEBUG_LEVEL > 1 777 else 778 fprintf( stderr, "no adaptor for selection %s\n", 779 OUStringToOString( getString( selection ), RTL_TEXTENCODING_ISO_8859_1 ).getStr() ); 780 781 if( pAdaptor->getTransferable().is() ) 782 { 783 Sequence< DataFlavor > aTypes = pAdaptor->getTransferable()->getTransferDataFlavors(); 784 for( int i = 0; i < aTypes.getLength(); i++ ) 785 { 786 fprintf( stderr, " %s\n", OUStringToOString( aTypes.getConstArray()[i].MimeType, RTL_TEXTENCODING_ISO_8859_1 ).getStr() ); 787 } 788 } 789 #endif 790 } 791 return bSuccess; 792 } 793 794 // ------------------------------------------------------------------------ 795 796 void SelectionManager::convertTypeToNative( const OUString& rType, Atom selection, int& rFormat, ::std::list< Atom >& rConversions, bool bPushFront ) 797 { 798 NativeTypeEntry* pTab = selection == m_nXdndSelection ? aXdndConversionTab : aNativeConversionTab; 799 int nTabEntries = selection == m_nXdndSelection 800 ? sizeof(aXdndConversionTab)/sizeof(aXdndConversionTab[0]) : 801 sizeof(aNativeConversionTab)/sizeof(aNativeConversionTab[0]); 802 803 OString aType( OUStringToOString( rType, RTL_TEXTENCODING_ISO_8859_1 ) ); 804 rFormat = 0; 805 for( int i = 0; i < nTabEntries; i++ ) 806 { 807 if( aType.equalsIgnoreAsciiCase( pTab[i].pType ) ) 808 { 809 if( ! pTab[i].nAtom ) 810 pTab[i].nAtom = getAtom( OStringToOUString( pTab[i].pNativeType, RTL_TEXTENCODING_ISO_8859_1 ) ); 811 rFormat = pTab[i].nFormat; 812 if( bPushFront ) 813 rConversions.push_front( pTab[i].nAtom ); 814 else 815 rConversions.push_back( pTab[i].nAtom ); 816 if( pTab[i].nFormat == XA_PIXMAP ) 817 { 818 if( bPushFront ) 819 { 820 rConversions.push_front( XA_VISUALID ); 821 rConversions.push_front( XA_COLORMAP ); 822 } 823 else 824 { 825 rConversions.push_back( XA_VISUALID ); 826 rConversions.push_back( XA_COLORMAP ); 827 } 828 } 829 } 830 } 831 if( ! rFormat ) 832 rFormat = 8; // byte buffer 833 if( bPushFront ) 834 rConversions.push_front( getAtom( rType ) ); 835 else 836 rConversions.push_back( getAtom( rType ) ); 837 }; 838 839 // ------------------------------------------------------------------------ 840 841 void SelectionManager::getNativeTypeList( const Sequence< DataFlavor >& rTypes, std::list< Atom >& rOutTypeList, Atom targetselection ) 842 { 843 rOutTypeList.clear(); 844 845 int nFormat; 846 int nFlavors = rTypes.getLength(); 847 const DataFlavor* pFlavors = rTypes.getConstArray(); 848 bool bHaveText = false; 849 for( int i = 0; i < nFlavors; i++ ) 850 { 851 if( pFlavors[i].MimeType.compareToAscii( "text/plain", 10 ) == 0) 852 bHaveText = true; 853 else 854 convertTypeToNative( pFlavors[i].MimeType, targetselection, nFormat, rOutTypeList ); 855 } 856 if( bHaveText ) 857 { 858 if( targetselection != m_nXdndSelection ) 859 { 860 // only mimetypes should go into Xdnd type list 861 rOutTypeList.push_front( XA_STRING ); 862 rOutTypeList.push_front( m_nCOMPOUNDAtom ); 863 } 864 convertTypeToNative( OUString::createFromAscii( "text/plain;charset=utf-8" ), targetselection, nFormat, rOutTypeList, true ); 865 } 866 if( targetselection != m_nXdndSelection ) 867 rOutTypeList.push_back( m_nMULTIPLEAtom ); 868 } 869 870 // ------------------------------------------------------------------------ 871 872 OUString SelectionManager::convertTypeFromNative( Atom nType, Atom selection, int& rFormat ) 873 { 874 NativeTypeEntry* pTab = selection == m_nXdndSelection ? aXdndConversionTab : aNativeConversionTab; 875 int nTabEntries = selection == m_nXdndSelection 876 ? sizeof(aXdndConversionTab)/sizeof(aXdndConversionTab[0]) : 877 sizeof(aNativeConversionTab)/sizeof(aNativeConversionTab[0]); 878 879 for( int i = 0; i < nTabEntries; i++ ) 880 { 881 if( ! pTab[i].nAtom ) 882 pTab[i].nAtom = getAtom( OStringToOUString( pTab[i].pNativeType, RTL_TEXTENCODING_ISO_8859_1 ) ); 883 if( nType == pTab[i].nAtom ) 884 { 885 rFormat = pTab[i].nFormat; 886 return OStringToOUString( pTab[i].pType, RTL_TEXTENCODING_ISO_8859_1 ); 887 } 888 } 889 rFormat = 8; 890 return getString( nType ); 891 } 892 893 // ------------------------------------------------------------------------ 894 895 bool SelectionManager::getPasteData( Atom selection, Atom type, Sequence< sal_Int8 >& rData ) 896 { 897 ResettableMutexGuard aGuard(m_aMutex); 898 ::std::hash_map< Atom, Selection* >::iterator it; 899 bool bSuccess = false; 900 901 #if OSL_DEBUG_LEVEL > 1 902 OUString aSelection( getString( selection ) ); 903 OUString aType( getString( type ) ); 904 fprintf( stderr, "getPasteData( %s, native: %s )\n", 905 OUStringToOString( aSelection, RTL_TEXTENCODING_ISO_8859_1 ).getStr(), 906 OUStringToOString( aType, RTL_TEXTENCODING_ISO_8859_1 ).getStr() 907 ); 908 #endif 909 910 if( ! m_pDisplay ) 911 return false; 912 913 it = m_aSelections.find( selection ); 914 if( it == m_aSelections.end() ) 915 return false; 916 917 XLIB_Window aSelectionOwner = XGetSelectionOwner( m_pDisplay, selection ); 918 if( aSelectionOwner == None ) 919 return false; 920 if( aSelectionOwner == m_aWindow ) 921 { 922 // probably bad timing led us here 923 #if OSL_DEBUG_LEVEL > 1 924 fprintf( stderr, "Innere Nabelschau\n" ); 925 #endif 926 return false; 927 } 928 929 // ICCCM recommends to destroy property before convert request unless 930 // parameters are transported; we do only in case of MULTIPLE, 931 // so destroy property unless target is MULTIPLE 932 if( type != m_nMULTIPLEAtom ) 933 XDeleteProperty( m_pDisplay, m_aWindow, selection ); 934 935 XConvertSelection( m_pDisplay, selection, type, selection, m_aWindow, selection == m_nXdndSelection ? m_nDropTime : CurrentTime ); 936 it->second->m_eState = Selection::WaitingForResponse; 937 it->second->m_aRequestedType = type; 938 it->second->m_aData = Sequence< sal_Int8 >(); 939 it->second->m_aDataArrived.reset(); 940 // really start the request; if we don't flush the 941 // queue the request won't leave it because there are no more 942 // X calls after this until the data arrived or timeout 943 XFlush( m_pDisplay ); 944 945 // do a reschedule 946 struct timeval tv_last, tv_current; 947 gettimeofday( &tv_last, NULL ); 948 tv_current = tv_last; 949 950 XEvent aEvent; 951 do 952 { 953 bool bAdjustTime = false; 954 { 955 bool bHandle = false; 956 957 if( XCheckTypedEvent( m_pDisplay, 958 PropertyNotify, 959 &aEvent 960 ) ) 961 { 962 bHandle = true; 963 if( aEvent.xproperty.window == m_aWindow 964 && aEvent.xproperty.atom == selection ) 965 bAdjustTime = true; 966 } 967 else 968 if( XCheckTypedEvent( m_pDisplay, 969 SelectionClear, 970 &aEvent 971 ) ) 972 { 973 bHandle = true; 974 } 975 else 976 if( XCheckTypedEvent( m_pDisplay, 977 SelectionRequest, 978 &aEvent 979 ) ) 980 bHandle = true; 981 else 982 if( XCheckTypedEvent( m_pDisplay, 983 SelectionNotify, 984 &aEvent 985 ) ) 986 { 987 bHandle = true; 988 if( aEvent.xselection.selection == selection 989 && ( aEvent.xselection.requestor == m_aWindow || 990 aEvent.xselection.requestor == m_aCurrentDropWindow ) 991 ) 992 bAdjustTime = true; 993 } 994 else 995 { 996 TimeValue aTVal; 997 aTVal.Seconds = 0; 998 aTVal.Nanosec = 100000000; 999 aGuard.clear(); 1000 osl_waitThread( &aTVal ); 1001 aGuard.reset(); 1002 } 1003 if( bHandle ) 1004 { 1005 aGuard.clear(); 1006 handleXEvent( aEvent ); 1007 aGuard.reset(); 1008 } 1009 } 1010 gettimeofday( &tv_current, NULL ); 1011 if( bAdjustTime ) 1012 tv_last = tv_current; 1013 } while( ! it->second->m_aDataArrived.check() && (tv_current.tv_sec - tv_last.tv_sec) < getSelectionTimeout() ); 1014 1015 #if OSL_DEBUG_LEVEL > 1 1016 if( (tv_current.tv_sec - tv_last.tv_sec) > getSelectionTimeout() ) 1017 fprintf( stderr, "timed out\n" ); 1018 #endif 1019 if( it->second->m_aDataArrived.check() && 1020 it->second->m_aData.getLength() ) 1021 { 1022 rData = it->second->m_aData; 1023 bSuccess = true; 1024 } 1025 #if OSL_DEBUG_LEVEL > 1 1026 else 1027 fprintf( stderr, "conversion unsuccessfull\n" ); 1028 #endif 1029 return bSuccess; 1030 } 1031 1032 // ------------------------------------------------------------------------ 1033 1034 bool SelectionManager::getPasteData( Atom selection, const ::rtl::OUString& rType, Sequence< sal_Int8 >& rData ) 1035 { 1036 int nFormat; 1037 bool bSuccess = false; 1038 1039 ::std::hash_map< Atom, Selection* >::iterator it; 1040 { 1041 MutexGuard aGuard(m_aMutex); 1042 1043 it = m_aSelections.find( selection ); 1044 if( it == m_aSelections.end() ) 1045 return false; 1046 } 1047 1048 if( it->second->m_aTypes.getLength() == 0 ) 1049 { 1050 Sequence< DataFlavor > aFlavors; 1051 getPasteDataTypes( selection, aFlavors ); 1052 if( it->second->m_aTypes.getLength() == 0 ) 1053 return false; 1054 } 1055 1056 const Sequence< DataFlavor >& rTypes( it->second->m_aTypes ); 1057 const std::vector< Atom >& rNativeTypes( it->second->m_aNativeTypes ); 1058 #if OSL_DEBUG_LEVEL > 1 1059 fprintf( stderr, "getPasteData( \"%s\", \"%s\" )\n", 1060 OUStringToOString( getString( selection ), RTL_TEXTENCODING_ISO_8859_1 ).getStr(), 1061 OUStringToOString( rType, RTL_TEXTENCODING_ISO_8859_1 ).getStr() ); 1062 #endif 1063 1064 if( rType.equalsAsciiL( "text/plain;charset=utf-16", 25 ) ) 1065 { 1066 // lets see if we have UTF16 else try to find something convertible 1067 if( it->second->m_aTypes.getLength() && ! it->second->m_bHaveUTF16 ) 1068 { 1069 Sequence< sal_Int8 > aData; 1070 if( it->second->m_aUTF8Type != None && 1071 getPasteData( selection, 1072 it->second->m_aUTF8Type, 1073 aData ) 1074 ) 1075 { 1076 OUString aRet( (const sal_Char*)aData.getConstArray(), aData.getLength(), RTL_TEXTENCODING_UTF8 ); 1077 rData = Sequence< sal_Int8 >( (sal_Int8*)aRet.getStr(), (aRet.getLength()+1)*sizeof( sal_Unicode ) ); 1078 bSuccess = true; 1079 } 1080 else if( it->second->m_bHaveCompound && 1081 getPasteData( selection, 1082 m_nCOMPOUNDAtom, 1083 aData ) 1084 ) 1085 { 1086 OUString aRet( convertFromCompound( (const char*)aData.getConstArray(), aData.getLength() ) ); 1087 rData = Sequence< sal_Int8 >( (sal_Int8*)aRet.getStr(), (aRet.getLength()+1)*sizeof( sal_Unicode ) ); 1088 bSuccess = true; 1089 } 1090 else 1091 { 1092 for( int i = 0; i < rTypes.getLength(); i++ ) 1093 { 1094 rtl_TextEncoding aEncoding = getTextPlainEncoding( rTypes.getConstArray()[i].MimeType ); 1095 if( aEncoding != RTL_TEXTENCODING_DONTKNOW && 1096 aEncoding != RTL_TEXTENCODING_UNICODE && 1097 getPasteData( selection, 1098 rNativeTypes[i], 1099 aData ) 1100 ) 1101 { 1102 #if OSL_DEBUG_LEVEL > 1 1103 fprintf( stderr, "using \"%s\" instead of \"%s\"\n", 1104 OUStringToOString( rTypes.getConstArray()[i].MimeType, RTL_TEXTENCODING_ISO_8859_1 ).getStr(), 1105 OUStringToOString( rType, RTL_TEXTENCODING_ISO_8859_1 ).getStr() 1106 ); 1107 #endif 1108 OString aConvert( (sal_Char*)aData.getConstArray(), aData.getLength() ); 1109 OUString aUTF( OStringToOUString( aConvert, aEncoding ) ); 1110 rData = Sequence< sal_Int8 >( (sal_Int8*)aUTF.getStr(), (aUTF.getLength()+1)*sizeof( sal_Unicode ) ); 1111 bSuccess = true; 1112 break; 1113 } 1114 } 1115 } 1116 } 1117 } 1118 else if( rType.equalsAsciiL( "image/bmp", 9 ) ) 1119 { 1120 // #i83376# try if someone has the data in image/bmp already before 1121 // doing the PIXMAP stuff (e.g. the gimp has this) 1122 bSuccess = getPasteData( selection, m_nImageBmpAtom, rData ); 1123 #if OSL_DEBUG_LEVEL > 1 1124 if( bSuccess ) 1125 fprintf( stderr, "got %d bytes of image/bmp\n", (int)rData.getLength() ); 1126 #endif 1127 if( ! bSuccess ) 1128 { 1129 Pixmap aPixmap = None; 1130 Colormap aColormap = None; 1131 1132 // prepare property for MULTIPLE request 1133 Sequence< sal_Int8 > aData; 1134 Atom pTypes[4] = { XA_PIXMAP, XA_PIXMAP, 1135 XA_COLORMAP, XA_COLORMAP }; 1136 { 1137 MutexGuard aGuard(m_aMutex); 1138 1139 XChangeProperty( m_pDisplay, 1140 m_aWindow, 1141 selection, 1142 XA_ATOM, 1143 32, 1144 PropModeReplace, 1145 (unsigned char*)pTypes, 1146 4 ); 1147 } 1148 1149 // try MULTIPLE request 1150 if( getPasteData( selection, m_nMULTIPLEAtom, aData ) ) 1151 { 1152 Atom* pReturnedTypes = (Atom*)aData.getArray(); 1153 if( pReturnedTypes[0] == XA_PIXMAP && pReturnedTypes[1] == XA_PIXMAP ) 1154 { 1155 MutexGuard aGuard(m_aMutex); 1156 1157 Atom type = None; 1158 int format = 0; 1159 unsigned long nItems = 0; 1160 unsigned long nBytes = 0; 1161 unsigned char* pReturn = NULL; 1162 XGetWindowProperty( m_pDisplay, m_aWindow, XA_PIXMAP, 0, 1, True, XA_PIXMAP, &type, &format, &nItems, &nBytes, &pReturn ); 1163 if( pReturn ) 1164 { 1165 if( type == XA_PIXMAP ) 1166 aPixmap = *(Pixmap*)pReturn; 1167 XFree( pReturn ); 1168 pReturn = NULL; 1169 if( pReturnedTypes[2] == XA_COLORMAP && pReturnedTypes[3] == XA_COLORMAP ) 1170 { 1171 XGetWindowProperty( m_pDisplay, m_aWindow, XA_COLORMAP, 0, 1, True, XA_COLORMAP, &type, &format, &nItems, &nBytes, &pReturn ); 1172 if( pReturn ) 1173 { 1174 if( type == XA_COLORMAP ) 1175 aColormap = *(Colormap*)pReturn; 1176 XFree( pReturn ); 1177 } 1178 } 1179 } 1180 #if OSL_DEBUG_LEVEL > 1 1181 else 1182 { 1183 fprintf( stderr, "could not get PIXMAP property: type=%s, format=%d, items=%ld, bytes=%ld, ret=0x%p\n", OUStringToOString( getString( type ), RTL_TEXTENCODING_ISO_8859_1 ).getStr(), format, nItems, nBytes, pReturn ); 1184 } 1185 #endif 1186 } 1187 } 1188 1189 if( aPixmap == None ) 1190 { 1191 // perhaps two normal requests will work 1192 if( getPasteData( selection, XA_PIXMAP, aData ) ) 1193 { 1194 aPixmap = *(Pixmap*)aData.getArray(); 1195 if( aColormap == None && getPasteData( selection, XA_COLORMAP, aData ) ) 1196 aColormap = *(Colormap*)aData.getArray(); 1197 } 1198 } 1199 1200 // convert data if possible 1201 if( aPixmap != None ) 1202 { 1203 MutexGuard aGuard(m_aMutex); 1204 1205 sal_Int32 nOutSize = 0; 1206 sal_uInt8* pBytes = X11_getBmpFromPixmap( m_pDisplay, aPixmap, aColormap, nOutSize ); 1207 if( pBytes && nOutSize ) 1208 { 1209 rData = Sequence< sal_Int8 >( nOutSize ); 1210 memcpy( rData.getArray(), pBytes, nOutSize ); 1211 X11_freeBmp( pBytes ); 1212 bSuccess = true; 1213 } 1214 } 1215 } 1216 } 1217 1218 if( ! bSuccess ) 1219 { 1220 ::std::list< Atom > aTypes; 1221 convertTypeToNative( rType, selection, nFormat, aTypes ); 1222 ::std::list< Atom >::const_iterator type_it; 1223 Atom nSelectedType = None; 1224 for( type_it = aTypes.begin(); type_it != aTypes.end() && nSelectedType == None; ++type_it ) 1225 { 1226 for( unsigned int i = 0; i < rNativeTypes.size() && nSelectedType == None; i++ ) 1227 if( rNativeTypes[i] == *type_it ) 1228 nSelectedType = *type_it; 1229 } 1230 if( nSelectedType != None ) 1231 bSuccess = getPasteData( selection, nSelectedType, rData ); 1232 } 1233 #if OSL_DEBUG_LEVEL > 1 1234 fprintf( stderr, "getPasteData for selection %s and data type %s returns %s, returned sequence has length %ld\n", 1235 OUStringToOString( getString( selection ), RTL_TEXTENCODING_ISO_8859_1 ).getStr(), 1236 OUStringToOString( rType, RTL_TEXTENCODING_ISO_8859_1 ).getStr(), 1237 bSuccess ? "true" : "false", 1238 rData.getLength() 1239 ); 1240 #endif 1241 return bSuccess; 1242 } 1243 1244 // ------------------------------------------------------------------------ 1245 1246 bool SelectionManager::getPasteDataTypes( Atom selection, Sequence< DataFlavor >& rTypes ) 1247 { 1248 ::std::hash_map< Atom, Selection* >::iterator it; 1249 { 1250 MutexGuard aGuard(m_aMutex); 1251 1252 it = m_aSelections.find( selection ); 1253 if( it != m_aSelections.end() && 1254 it->second->m_aTypes.getLength() && 1255 abs( it->second->m_nLastTimestamp - time( NULL ) ) < 2 1256 ) 1257 { 1258 rTypes = it->second->m_aTypes; 1259 return true; 1260 } 1261 } 1262 1263 bool bSuccess = false; 1264 bool bHaveUTF16 = false; 1265 Atom aUTF8Type = None; 1266 bool bHaveCompound = false; 1267 bool bHaveText = false; 1268 Sequence< sal_Int8 > aAtoms; 1269 1270 if( selection == m_nXdndSelection ) 1271 { 1272 // xdnd sends first three types with XdndEnter 1273 // if more than three types are supported then the XDndTypeList 1274 // property on the source window is used 1275 if( m_aDropEnterEvent.data.l[0] && m_aCurrentDropWindow ) 1276 { 1277 if( m_aDropEnterEvent.data.l[1] & 1 ) 1278 { 1279 const unsigned int atomcount = 256; 1280 // more than three types; look in property 1281 MutexGuard aGuard(m_aMutex); 1282 1283 Atom nType; 1284 int nFormat; 1285 unsigned long nItems, nBytes; 1286 unsigned char* pBytes = NULL; 1287 1288 XGetWindowProperty( m_pDisplay, m_aDropEnterEvent.data.l[0], 1289 m_nXdndTypeList, 0, atomcount, False, 1290 XA_ATOM, 1291 &nType, &nFormat, &nItems, &nBytes, &pBytes ); 1292 #if OSL_DEBUG_LEVEL > 1 1293 fprintf( stderr, "have %ld data types in XdndTypeList\n", nItems ); 1294 #endif 1295 if( nItems == atomcount && nBytes > 0 ) 1296 { 1297 // wow ... more than 256 types ! 1298 aAtoms.realloc( sizeof( Atom )*atomcount+nBytes ); 1299 memcpy( aAtoms.getArray(), pBytes, sizeof( Atom )*atomcount ); 1300 XFree( pBytes ); 1301 pBytes = NULL; 1302 XGetWindowProperty( m_pDisplay, m_aDropEnterEvent.data.l[0], 1303 m_nXdndTypeList, atomcount, nBytes/sizeof(Atom), 1304 False, XA_ATOM, 1305 &nType, &nFormat, &nItems, &nBytes, &pBytes ); 1306 { 1307 memcpy( aAtoms.getArray()+atomcount*sizeof(Atom), pBytes, nItems*sizeof(Atom) ); 1308 XFree( pBytes ); 1309 } 1310 } 1311 else 1312 { 1313 aAtoms.realloc( sizeof(Atom)*nItems ); 1314 memcpy( aAtoms.getArray(), pBytes, nItems*sizeof(Atom) ); 1315 XFree( pBytes ); 1316 } 1317 } 1318 else 1319 { 1320 // one to three types 1321 int n = 0, i; 1322 for( i = 0; i < 3; i++ ) 1323 if( m_aDropEnterEvent.data.l[2+i] ) 1324 n++; 1325 #if OSL_DEBUG_LEVEL > 1 1326 fprintf( stderr, "have %d data types in XdndEnter\n", n ); 1327 #endif 1328 aAtoms.realloc( sizeof(Atom)*n ); 1329 for( i = 0, n = 0; i < 3; i++ ) 1330 if( m_aDropEnterEvent.data.l[2+i] ) 1331 ((Atom*)aAtoms.getArray())[n++] = m_aDropEnterEvent.data.l[2+i]; 1332 } 1333 } 1334 } 1335 // get data of type TARGETS 1336 else if( ! getPasteData( selection, m_nTARGETSAtom, aAtoms ) ) 1337 aAtoms = Sequence< sal_Int8 >(); 1338 1339 std::vector< Atom > aNativeTypes; 1340 if( aAtoms.getLength() ) 1341 { 1342 sal_Int32 nAtoms = aAtoms.getLength() / sizeof(Atom); 1343 Atom* pAtoms = (Atom*)aAtoms.getArray(); 1344 rTypes.realloc( nAtoms ); 1345 aNativeTypes.resize( nAtoms ); 1346 DataFlavor* pFlavors = rTypes.getArray(); 1347 sal_Int32 nNativeTypesIndex = 0; 1348 while( nAtoms-- ) 1349 { 1350 #if OSL_DEBUG_LEVEL > 1 1351 if( *pAtoms && *pAtoms < 0x01000000 ) 1352 fprintf( stderr, "native type: %s\n", OUStringToOString( getString( *pAtoms ), RTL_TEXTENCODING_ISO_8859_1 ).getStr() ); 1353 #endif 1354 if( *pAtoms == m_nCOMPOUNDAtom ) 1355 bHaveText = bHaveCompound = true; 1356 else if( *pAtoms && *pAtoms < 0x01000000 ) 1357 { 1358 int nFormat; 1359 pFlavors->MimeType = convertTypeFromNative( *pAtoms, selection, nFormat ); 1360 pFlavors->DataType = getCppuType( (Sequence< sal_Int8 >*)0 ); 1361 sal_Int32 nIndex = 0; 1362 if( pFlavors->MimeType.getToken( 0, ';', nIndex ).equalsAsciiL( "text/plain", 10 ) ) 1363 { 1364 OUString aToken(pFlavors->MimeType.getToken( 0, ';', nIndex )); 1365 // omit text/plain;charset=unicode since it is not well defined 1366 if( aToken.compareToAscii( "charset=unicode" ) == 0 ) 1367 { 1368 pAtoms++; 1369 continue; 1370 } 1371 bHaveText = true; 1372 if( aToken.compareToAscii( "charset=utf-16" ) == 0 ) 1373 { 1374 bHaveUTF16 = true; 1375 pFlavors->DataType = getCppuType( (OUString*)0 ); 1376 } 1377 else if( aToken.compareToAscii( "charset=utf-8" ) == 0 ) 1378 { 1379 aUTF8Type = *pAtoms; 1380 } 1381 } 1382 pFlavors++; 1383 aNativeTypes[ nNativeTypesIndex ] = *pAtoms; 1384 nNativeTypesIndex++; 1385 } 1386 pAtoms++; 1387 } 1388 if( (pFlavors - rTypes.getArray()) < rTypes.getLength() ) 1389 rTypes.realloc(pFlavors - rTypes.getArray()); 1390 bSuccess = rTypes.getLength() ? true : false; 1391 if( bHaveText && ! bHaveUTF16 ) 1392 { 1393 int i = 0; 1394 1395 int nNewFlavors = rTypes.getLength()+1; 1396 Sequence< DataFlavor > aTemp( nNewFlavors ); 1397 for( i = 0; i < nNewFlavors-1; i++ ) 1398 aTemp.getArray()[i+1] = rTypes.getConstArray()[i]; 1399 aTemp.getArray()[0].MimeType = OUString::createFromAscii( "text/plain;charset=utf-16" ); 1400 aTemp.getArray()[0].DataType = getCppuType( (OUString*)0 ); 1401 rTypes = aTemp; 1402 1403 std::vector< Atom > aNativeTemp( nNewFlavors ); 1404 for( i = 0; i < nNewFlavors-1; i++ ) 1405 aNativeTemp[ i + 1 ] = aNativeTypes[ i ]; 1406 aNativeTemp[0] = None; 1407 aNativeTypes = aNativeTemp; 1408 } 1409 } 1410 1411 { 1412 MutexGuard aGuard(m_aMutex); 1413 1414 it = m_aSelections.find( selection ); 1415 if( it != m_aSelections.end() ) 1416 { 1417 if( bSuccess ) 1418 { 1419 it->second->m_aTypes = rTypes; 1420 it->second->m_aNativeTypes = aNativeTypes; 1421 it->second->m_nLastTimestamp = time( NULL ); 1422 it->second->m_bHaveUTF16 = bHaveUTF16; 1423 it->second->m_aUTF8Type = aUTF8Type; 1424 it->second->m_bHaveCompound = bHaveCompound; 1425 } 1426 else 1427 { 1428 it->second->m_aTypes = Sequence< DataFlavor >(); 1429 it->second->m_aNativeTypes = std::vector< Atom >(); 1430 it->second->m_nLastTimestamp = 0; 1431 it->second->m_bHaveUTF16 = false; 1432 it->second->m_aUTF8Type = None; 1433 it->second->m_bHaveCompound = false; 1434 } 1435 } 1436 } 1437 1438 #if OSL_DEBUG_LEVEL > 1 1439 // if( selection != m_nCLIPBOARDAtom ) 1440 { 1441 fprintf( stderr, "SelectionManager::getPasteDataTypes( %s ) = %s\n", OUStringToOString( getString( selection ), RTL_TEXTENCODING_ISO_8859_1 ).getStr(), bSuccess ? "true" : "false" ); 1442 for( int i = 0; i < rTypes.getLength(); i++ ) 1443 fprintf( stderr, "type: %s\n", OUStringToOString( rTypes.getConstArray()[i].MimeType, RTL_TEXTENCODING_ISO_8859_1 ).getStr() ); 1444 } 1445 #endif 1446 1447 return bSuccess; 1448 } 1449 1450 // ------------------------------------------------------------------------ 1451 1452 PixmapHolder* SelectionManager::getPixmapHolder( Atom selection ) 1453 { 1454 std::hash_map< Atom, Selection* >::const_iterator it = m_aSelections.find( selection ); 1455 if( it == m_aSelections.end() ) 1456 return NULL; 1457 if( ! it->second->m_pPixmap ) 1458 it->second->m_pPixmap = new PixmapHolder( m_pDisplay ); 1459 return it->second->m_pPixmap; 1460 } 1461 1462 static sal_Size GetTrueFormatSize(int nFormat) 1463 { 1464 // http://mail.gnome.org/archives/wm-spec-list/2003-March/msg00067.html 1465 return nFormat == 32 ? sizeof(long) : nFormat/8; 1466 } 1467 1468 bool SelectionManager::sendData( SelectionAdaptor* pAdaptor, 1469 XLIB_Window requestor, 1470 Atom target, 1471 Atom property, 1472 Atom selection ) 1473 { 1474 ResettableMutexGuard aGuard( m_aMutex ); 1475 1476 // handle targets related to image/bmp 1477 if( target == XA_COLORMAP || target == XA_PIXMAP || target == XA_BITMAP || target == XA_VISUALID ) 1478 { 1479 PixmapHolder* pPixmap = getPixmapHolder( selection ); 1480 if( ! pPixmap ) return false; 1481 XID nValue = None; 1482 1483 // handle colormap request 1484 if( target == XA_COLORMAP ) 1485 nValue = (XID)pPixmap->getColormap(); 1486 else if( target == XA_VISUALID ) 1487 nValue = (XID)pPixmap->getVisualID(); 1488 else if( target == XA_PIXMAP || target == XA_BITMAP ) 1489 { 1490 nValue = (XID)pPixmap->getPixmap(); 1491 if( nValue == None ) 1492 { 1493 // first conversion 1494 Sequence< sal_Int8 > aData; 1495 int nFormat; 1496 aGuard.clear(); 1497 bool bConverted = convertData( pAdaptor->getTransferable(), target, selection, nFormat, aData ); 1498 aGuard.reset(); 1499 if( bConverted ) 1500 { 1501 // get pixmap again since clearing the guard could have invalidated 1502 // the pixmap in another thread 1503 pPixmap = getPixmapHolder( selection ); 1504 // conversion succeeded, so aData contains image/bmp now 1505 if( pPixmap->needsConversion( (const sal_uInt8*)aData.getConstArray() ) 1506 && m_xBitmapConverter.is() ) 1507 { 1508 #if OSL_DEBUG_LEVEL > 1 1509 fprintf( stderr, "trying bitmap conversion\n" ); 1510 #endif 1511 css::uno::Reference<XBitmap> xBM( new BmpTransporter( aData ) ); 1512 Sequence<Any> aArgs(2), aOutArgs; 1513 Sequence<sal_Int16> aOutIndex; 1514 aArgs.getArray()[0] = makeAny( xBM ); 1515 aArgs.getArray()[1] = makeAny( (sal_uInt16)pPixmap->getDepth() ); 1516 aGuard.clear(); 1517 try 1518 { 1519 Any aResult = 1520 m_xBitmapConverter->invoke( OUString::createFromAscii( "convert-bitmap-depth" ), 1521 aArgs, aOutIndex, aOutArgs ); 1522 if( aResult >>= xBM ) 1523 aData = xBM->getDIB(); 1524 } 1525 catch(...) 1526 { 1527 #if OSL_DEBUG_LEVEL > 1 1528 fprintf( stderr, "exception in bitmap converter\n" ); 1529 #endif 1530 } 1531 aGuard.reset(); 1532 } 1533 // get pixmap again since clearing the guard could have invalidated 1534 // the pixmap in another thread 1535 pPixmap = getPixmapHolder( selection ); 1536 nValue = (XID)pPixmap->setBitmapData( (const sal_uInt8*)aData.getConstArray() ); 1537 } 1538 if( nValue == None ) 1539 return false; 1540 } 1541 if( target == XA_BITMAP ) 1542 nValue = (XID)pPixmap->getBitmap(); 1543 } 1544 1545 XChangeProperty( m_pDisplay, 1546 requestor, 1547 property, 1548 target, 1549 32, 1550 PropModeReplace, 1551 (const unsigned char*)&nValue, 1552 1); 1553 return true; 1554 } 1555 1556 /* 1557 * special target TEXT allows us to transfer 1558 * the data in an encoding of our choice 1559 * COMPOUND_TEXT will work with most applications 1560 */ 1561 if( target == m_nTEXTAtom ) 1562 target = m_nCOMPOUNDAtom; 1563 1564 Sequence< sal_Int8 > aData; 1565 int nFormat; 1566 aGuard.clear(); 1567 bool bConverted = convertData( pAdaptor->getTransferable(), target, selection, nFormat, aData ); 1568 aGuard.reset(); 1569 if( bConverted ) 1570 { 1571 // conversion succeeded 1572 if( aData.getLength() > m_nIncrementalThreshold ) 1573 { 1574 #if OSL_DEBUG_LEVEL > 1 1575 fprintf( stderr, "using INCR protocol\n" ); 1576 std::hash_map< XLIB_Window, std::hash_map< Atom, IncrementalTransfer > >::const_iterator win_it = m_aIncrementals.find( requestor ); 1577 if( win_it != m_aIncrementals.end() ) 1578 { 1579 std::hash_map< Atom, IncrementalTransfer >::const_iterator inc_it = win_it->second.find( property ); 1580 if( inc_it != win_it->second.end() ) 1581 { 1582 const IncrementalTransfer& rInc = inc_it->second; 1583 fprintf( stderr, "premature end and new start for INCR transfer for window 0x%lx, property %s, type %s\n", 1584 rInc.m_aRequestor, 1585 OUStringToOString( getString( rInc.m_aProperty ), RTL_TEXTENCODING_ISO_8859_1 ).getStr(), 1586 OUStringToOString( getString( rInc.m_aTarget ), RTL_TEXTENCODING_ISO_8859_1 ).getStr() 1587 ); 1588 } 1589 } 1590 #endif 1591 1592 // insert IncrementalTransfer 1593 IncrementalTransfer& rInc = m_aIncrementals[ requestor ][ property ]; 1594 rInc.m_aData = aData; 1595 rInc.m_nBufferPos = 0; 1596 rInc.m_aRequestor = requestor; 1597 rInc.m_aProperty = property; 1598 rInc.m_aTarget = target; 1599 rInc.m_nFormat = nFormat; 1600 rInc.m_nTransferStartTime = time( NULL ); 1601 1602 // use incr protocol, signal start to requestor 1603 long nMinSize = m_nIncrementalThreshold; 1604 XSelectInput( m_pDisplay, requestor, PropertyChangeMask ); 1605 XChangeProperty( m_pDisplay, requestor, property, 1606 m_nINCRAtom, 32, PropModeReplace, (unsigned char*)&nMinSize, 1 ); 1607 XFlush( m_pDisplay ); 1608 } 1609 else 1610 { 1611 sal_Size nUnitSize = GetTrueFormatSize(nFormat); 1612 XChangeProperty( m_pDisplay, 1613 requestor, 1614 property, 1615 target, 1616 nFormat, 1617 PropModeReplace, 1618 (const unsigned char*)aData.getConstArray(), 1619 aData.getLength()/nUnitSize ); 1620 } 1621 } 1622 #if OSL_DEBUG_LEVEL > 1 1623 else 1624 fprintf( stderr, "convertData failed for type: %s \n", 1625 OUStringToOString( convertTypeFromNative( target, selection, nFormat ), RTL_TEXTENCODING_ISO_8859_1 ).getStr() ); 1626 #endif 1627 return bConverted; 1628 } 1629 1630 // ------------------------------------------------------------------------ 1631 1632 bool SelectionManager::handleSelectionRequest( XSelectionRequestEvent& rRequest ) 1633 { 1634 ResettableMutexGuard aGuard( m_aMutex ); 1635 #if OSL_DEBUG_LEVEL > 1 1636 fprintf( stderr, "handleSelectionRequest for selection %s and target %s\n", 1637 OUStringToOString( getString( rRequest.selection ), RTL_TEXTENCODING_ISO_8859_1 ).getStr(), 1638 OUStringToOString( getString( rRequest.target ), RTL_TEXTENCODING_ISO_8859_1 ).getStr() 1639 ); 1640 #endif 1641 1642 XEvent aNotify; 1643 1644 aNotify.type = SelectionNotify; 1645 aNotify.xselection.display = rRequest.display; 1646 aNotify.xselection.send_event = True; 1647 aNotify.xselection.requestor = rRequest.requestor; 1648 aNotify.xselection.selection = rRequest.selection; 1649 aNotify.xselection.time = rRequest.time; 1650 aNotify.xselection.target = rRequest.target; 1651 aNotify.xselection.property = None; 1652 1653 SelectionAdaptor* pAdaptor = getAdaptor( rRequest.selection ); 1654 // ensure that we still own that selection 1655 if( pAdaptor && 1656 XGetSelectionOwner( m_pDisplay, rRequest.selection ) == m_aWindow ) 1657 { 1658 css::uno::Reference< XTransferable > xTrans( pAdaptor->getTransferable() ); 1659 if( rRequest.target == m_nTARGETSAtom ) 1660 { 1661 // someone requests our types 1662 if( xTrans.is() ) 1663 { 1664 aGuard.clear(); 1665 Sequence< DataFlavor > aFlavors = xTrans->getTransferDataFlavors(); 1666 aGuard.reset(); 1667 1668 ::std::list< Atom > aConversions; 1669 getNativeTypeList( aFlavors, aConversions, rRequest.selection ); 1670 1671 int i, nTypes = aConversions.size(); 1672 Atom* pTypes = (Atom*)alloca( nTypes * sizeof( Atom ) ); 1673 std::list< Atom >::const_iterator it; 1674 for( i = 0, it = aConversions.begin(); i < nTypes; i++, ++it ) 1675 pTypes[i] = *it; 1676 XChangeProperty( m_pDisplay, rRequest.requestor, rRequest.property, 1677 XA_ATOM, 32, PropModeReplace, (const unsigned char*)pTypes, nTypes ); 1678 aNotify.xselection.property = rRequest.property; 1679 #if OSL_DEBUG_LEVEL > 1 1680 fprintf( stderr, "sending type list:\n" ); 1681 for( int k = 0; k < nTypes; k++ ) 1682 fprintf( stderr, " %s\n", pTypes[k] ? XGetAtomName( m_pDisplay, pTypes[k] ) : "<None>" ); 1683 #endif 1684 } 1685 } 1686 else if( rRequest.target == m_nTIMESTAMPAtom ) 1687 { 1688 long nTimeStamp = (long)m_aSelections[rRequest.selection]->m_nOrigTimestamp; 1689 XChangeProperty( m_pDisplay, rRequest.requestor, rRequest.property, 1690 XA_INTEGER, 32, PropModeReplace, (const unsigned char*)&nTimeStamp, 1 ); 1691 aNotify.xselection.property = rRequest.property; 1692 #if OSL_DEBUG_LEVEL > 1 1693 fprintf( stderr, "sending timestamp: %d\n", (int)nTimeStamp ); 1694 #endif 1695 } 1696 else 1697 { 1698 bool bEventSuccess = false; 1699 if( rRequest.target == m_nMULTIPLEAtom ) 1700 { 1701 // get all targets 1702 Atom nType = None; 1703 int nFormat = 0; 1704 unsigned long nItems = 0, nBytes = 0; 1705 unsigned char* pData = NULL; 1706 1707 // get number of atoms 1708 XGetWindowProperty( m_pDisplay, 1709 rRequest.requestor, 1710 rRequest.property, 1711 0, 0, 1712 False, 1713 AnyPropertyType, 1714 &nType, &nFormat, 1715 &nItems, &nBytes, 1716 &pData ); 1717 if( nFormat == 32 && nBytes/4 ) 1718 { 1719 if( pData ) // ?? should not happen 1720 { 1721 XFree( pData ); 1722 pData = NULL; 1723 } 1724 XGetWindowProperty( m_pDisplay, 1725 rRequest.requestor, 1726 rRequest.property, 1727 0, nBytes/4, 1728 False, 1729 nType, 1730 &nType, &nFormat, 1731 &nItems, &nBytes, 1732 &pData ); 1733 if( pData && nItems ) 1734 { 1735 #if OSL_DEBUG_LEVEL > 1 1736 fprintf( stderr, "found %ld atoms in MULTIPLE request\n", nItems ); 1737 #endif 1738 bEventSuccess = true; 1739 bool bResetAtoms = false; 1740 Atom* pAtoms = (Atom*)pData; 1741 aGuard.clear(); 1742 for( unsigned int i = 0; i < nItems; i += 2 ) 1743 { 1744 #if OSL_DEBUG_LEVEL > 1 1745 fprintf( stderr, " %s => %s: ", 1746 OUStringToOString( getString( pAtoms[i] ), RTL_TEXTENCODING_ISO_8859_1 ).getStr(), 1747 OUStringToOString( getString( pAtoms[i+1] ), RTL_TEXTENCODING_ISO_8859_1 ).getStr() ); 1748 #endif 1749 bool bSuccess = sendData( pAdaptor, rRequest.requestor, pAtoms[i], pAtoms[i+1], rRequest.selection ); 1750 #if OSL_DEBUG_LEVEL > 1 1751 fprintf( stderr, "%s\n", bSuccess ? "succeeded" : "failed" ); 1752 #endif 1753 if( ! bSuccess ) 1754 { 1755 pAtoms[i] = None; 1756 bResetAtoms = true; 1757 } 1758 } 1759 aGuard.reset(); 1760 if( bResetAtoms ) 1761 XChangeProperty( m_pDisplay, 1762 rRequest.requestor, 1763 rRequest.property, 1764 XA_ATOM, 1765 32, 1766 PropModeReplace, 1767 pData, 1768 nBytes/4 ); 1769 } 1770 if( pData ) 1771 XFree( pData ); 1772 } 1773 #if OSL_DEBUG_LEVEL > 1 1774 else 1775 { 1776 fprintf( stderr, "could not get type list from \"%s\" of type \"%s\" on requestor 0x%lx, requestor has properties:", 1777 OUStringToOString( getString( rRequest.property ), RTL_TEXTENCODING_ISO_8859_1 ).getStr(), 1778 OUStringToOString( getString( nType ), RTL_TEXTENCODING_ISO_8859_1 ).getStr(), 1779 rRequest.requestor ); 1780 int nProps = 0; 1781 Atom* pProps = XListProperties( m_pDisplay, rRequest.requestor, &nProps ); 1782 if( pProps ) 1783 { 1784 for( int i = 0; i < nProps; i++ ) 1785 fprintf( stderr, " \"%s\"", OUStringToOString( getString( pProps[i]), RTL_TEXTENCODING_ISO_8859_1 ).getStr() ); 1786 XFree( pProps ); 1787 } 1788 } 1789 #endif 1790 } 1791 else 1792 { 1793 aGuard.clear(); 1794 bEventSuccess = sendData( pAdaptor, rRequest.requestor, rRequest.target, rRequest.property, rRequest.selection ); 1795 aGuard.reset(); 1796 } 1797 if( bEventSuccess ) 1798 { 1799 aNotify.xselection.target = rRequest.target; 1800 aNotify.xselection.property = rRequest.property; 1801 } 1802 } 1803 aGuard.clear(); 1804 xTrans.clear(); 1805 aGuard.reset(); 1806 } 1807 XSendEvent( m_pDisplay, rRequest.requestor, False, 0, &aNotify ); 1808 1809 if( rRequest.selection == XA_PRIMARY && 1810 m_bWaitingForPrimaryConversion && 1811 m_xDragSourceListener.is() ) 1812 { 1813 DragSourceDropEvent dsde; 1814 dsde.Source = static_cast< OWeakObject* >(this); 1815 dsde.DragSourceContext = new DragSourceContext( m_aDropWindow, rRequest.time, *this ); 1816 dsde.DragSource = static_cast< XDragSource* >(this); 1817 if( aNotify.xselection.property != None ) 1818 { 1819 dsde.DropAction = DNDConstants::ACTION_COPY; 1820 dsde.DropSuccess = sal_True; 1821 } 1822 else 1823 { 1824 dsde.DropAction = DNDConstants::ACTION_NONE; 1825 dsde.DropSuccess = sal_False; 1826 } 1827 css::uno::Reference< XDragSourceListener > xListener( m_xDragSourceListener ); 1828 m_xDragSourceListener.clear(); 1829 aGuard.clear(); 1830 if( xListener.is() ) 1831 xListener->dragDropEnd( dsde ); 1832 } 1833 1834 // we handled the event in any case by answering 1835 return true; 1836 } 1837 1838 // ------------------------------------------------------------------------ 1839 1840 bool SelectionManager::handleReceivePropertyNotify( XPropertyEvent& rNotify ) 1841 { 1842 MutexGuard aGuard( m_aMutex ); 1843 // data we requested arrived 1844 #if OSL_DEBUG_LEVEL > 1 1845 fprintf( stderr, "handleReceivePropertyNotify for property %s\n", 1846 OUStringToOString( getString( rNotify.atom ), RTL_TEXTENCODING_ISO_8859_1 ).getStr() ); 1847 #endif 1848 bool bHandled = false; 1849 1850 ::std::hash_map< Atom, Selection* >::iterator it = 1851 m_aSelections.find( rNotify.atom ); 1852 if( it != m_aSelections.end() && 1853 rNotify.state == PropertyNewValue && 1854 ( it->second->m_eState == Selection::WaitingForResponse || 1855 it->second->m_eState == Selection::WaitingForData || 1856 it->second->m_eState == Selection::IncrementalTransfer 1857 ) 1858 ) 1859 { 1860 // MULTIPLE requests are only complete after selection notify 1861 if( it->second->m_aRequestedType == m_nMULTIPLEAtom && 1862 ( it->second->m_eState == Selection::WaitingForResponse || 1863 it->second->m_eState == Selection::WaitingForData ) ) 1864 return false; 1865 1866 bHandled = true; 1867 1868 Atom nType = None; 1869 int nFormat = 0; 1870 unsigned long nItems = 0, nBytes = 0; 1871 unsigned char* pData = NULL; 1872 1873 // get type and length 1874 XGetWindowProperty( m_pDisplay, 1875 rNotify.window, 1876 rNotify.atom, 1877 0, 0, 1878 False, 1879 AnyPropertyType, 1880 &nType, &nFormat, 1881 &nItems, &nBytes, 1882 &pData ); 1883 #if OSL_DEBUG_LEVEL > 1 1884 fprintf( stderr, "found %ld bytes data of type %s and format %d, items = %ld\n", 1885 nBytes, 1886 OUStringToOString( getString( nType ), RTL_TEXTENCODING_ISO_8859_1 ).getStr(), 1887 nFormat, nItems ); 1888 #endif 1889 if( pData ) 1890 { 1891 XFree( pData ); 1892 pData = NULL; 1893 } 1894 1895 if( nType == m_nINCRAtom ) 1896 { 1897 // start data transfer 1898 XDeleteProperty( m_pDisplay, rNotify.window, rNotify.atom ); 1899 it->second->m_eState = Selection::IncrementalTransfer; 1900 } 1901 else if( nType != None ) 1902 { 1903 XGetWindowProperty( m_pDisplay, 1904 rNotify.window, 1905 rNotify.atom, 1906 0, nBytes/4 +1, 1907 True, 1908 nType, 1909 &nType, &nFormat, 1910 &nItems, &nBytes, 1911 &pData ); 1912 #if OSL_DEBUG_LEVEL > 1 1913 fprintf( stderr, "read %ld items data of type %s and format %d, %ld bytes left in property\n", 1914 nItems, 1915 OUStringToOString( getString( nType ), RTL_TEXTENCODING_ISO_8859_1 ).getStr(), 1916 nFormat, nBytes ); 1917 #endif 1918 1919 sal_Size nUnitSize = GetTrueFormatSize(nFormat); 1920 1921 if( it->second->m_eState == Selection::WaitingForData || 1922 it->second->m_eState == Selection::WaitingForResponse ) 1923 { 1924 // copy data 1925 it->second->m_aData = Sequence< sal_Int8 >( (sal_Int8*)pData, nItems*nUnitSize ); 1926 it->second->m_eState = Selection::Inactive; 1927 it->second->m_aDataArrived.set(); 1928 } 1929 else if( it->second->m_eState == Selection::IncrementalTransfer ) 1930 { 1931 if( nItems ) 1932 { 1933 // append data 1934 Sequence< sal_Int8 > aData( it->second->m_aData.getLength() + nItems*nUnitSize ); 1935 memcpy( aData.getArray(), it->second->m_aData.getArray(), it->second->m_aData.getLength() ); 1936 memcpy( aData.getArray() + it->second->m_aData.getLength(), pData, nItems*nUnitSize ); 1937 it->second->m_aData = aData; 1938 } 1939 else 1940 { 1941 it->second->m_eState = Selection::Inactive; 1942 it->second->m_aDataArrived.set(); 1943 } 1944 } 1945 if( pData ) 1946 XFree( pData ); 1947 } 1948 else if( it->second->m_eState == Selection::IncrementalTransfer ) 1949 { 1950 it->second->m_eState = Selection::Inactive; 1951 it->second->m_aDataArrived.set(); 1952 } 1953 } 1954 return bHandled; 1955 } 1956 1957 // ------------------------------------------------------------------------ 1958 1959 bool SelectionManager::handleSendPropertyNotify( XPropertyEvent& rNotify ) 1960 { 1961 MutexGuard aGuard( m_aMutex ); 1962 1963 // ready for next part of a IncrementalTransfer 1964 #if OSL_DEBUG_LEVEL > 1 1965 fprintf( stderr, "handleSendPropertyNotify for property %s (%s)\n", 1966 OUStringToOString( getString( rNotify.atom ), RTL_TEXTENCODING_ISO_8859_1 ).getStr(), 1967 rNotify.state == PropertyNewValue ? "new value" : ( rNotify.state == PropertyDelete ? "deleted" : "unknown") 1968 ); 1969 #endif 1970 1971 bool bHandled = false; 1972 // feed incrementals 1973 if( rNotify.state == PropertyDelete ) 1974 { 1975 std::hash_map< XLIB_Window, std::hash_map< Atom, IncrementalTransfer > >::iterator it; 1976 it = m_aIncrementals.find( rNotify.window ); 1977 if( it != m_aIncrementals.end() ) 1978 { 1979 bHandled = true; 1980 int nCurrentTime = time( NULL ); 1981 std::hash_map< Atom, IncrementalTransfer >::iterator inc_it; 1982 // throw out aborted transfers 1983 std::list< Atom > aTimeouts; 1984 for( inc_it = it->second.begin(); inc_it != it->second.end(); ++inc_it ) 1985 { 1986 if( (nCurrentTime - inc_it->second.m_nTransferStartTime) > (getSelectionTimeout()+2) ) 1987 { 1988 aTimeouts.push_back( inc_it->first ); 1989 #if OSL_DEBUG_LEVEL > 1 1990 const IncrementalTransfer& rInc = inc_it->second; 1991 fprintf( stderr, "timeout on INCR transfer for window 0x%lx, property %s, type %s\n", 1992 rInc.m_aRequestor, 1993 OUStringToOString( getString( rInc.m_aProperty ), RTL_TEXTENCODING_ISO_8859_1 ).getStr(), 1994 OUStringToOString( getString( rInc.m_aTarget ), RTL_TEXTENCODING_ISO_8859_1 ).getStr() 1995 ); 1996 #endif 1997 } 1998 } 1999 2000 while( aTimeouts.begin() != aTimeouts.end() ) 2001 { 2002 // transfer broken, might even be a new client with the 2003 // same window id 2004 it->second.erase( aTimeouts.front() ); 2005 aTimeouts.pop_front(); 2006 } 2007 2008 inc_it = it->second.find( rNotify.atom ); 2009 if( inc_it != it->second.end() ) 2010 { 2011 IncrementalTransfer& rInc = inc_it->second; 2012 2013 int nBytes = rInc.m_aData.getLength() - rInc.m_nBufferPos; 2014 nBytes = (nBytes > m_nIncrementalThreshold) ? m_nIncrementalThreshold : nBytes; 2015 if( nBytes < 0 ) // sanity check 2016 nBytes = 0; 2017 #if OSL_DEBUG_LEVEL > 1 2018 fprintf( stderr, "pushing %d bytes: \"%.*s\"...\n", 2019 nBytes, nBytes > 32 ? 32 : nBytes, 2020 (const unsigned char*)rInc.m_aData.getConstArray()+rInc.m_nBufferPos ); 2021 #endif 2022 2023 sal_Size nUnitSize = GetTrueFormatSize(rInc.m_nFormat); 2024 2025 XChangeProperty( m_pDisplay, 2026 rInc.m_aRequestor, 2027 rInc.m_aProperty, 2028 rInc.m_aTarget, 2029 rInc.m_nFormat, 2030 PropModeReplace, 2031 (const unsigned char*)rInc.m_aData.getConstArray()+rInc.m_nBufferPos, 2032 nBytes/nUnitSize ); 2033 rInc.m_nBufferPos += nBytes; 2034 rInc.m_nTransferStartTime = nCurrentTime; 2035 2036 if( nBytes == 0 ) // transfer finished 2037 { 2038 #if OSL_DEBUG_LEVEL > 1 2039 fprintf( stderr, "finished INCR transfer for window 0x%lx, property %s, type %s\n", 2040 rInc.m_aRequestor, 2041 OUStringToOString( getString( rInc.m_aProperty ), RTL_TEXTENCODING_ISO_8859_1 ).getStr(), 2042 OUStringToOString( getString( rInc.m_aTarget ), RTL_TEXTENCODING_ISO_8859_1 ).getStr() 2043 ); 2044 #endif 2045 it->second.erase( inc_it ); 2046 } 2047 2048 } 2049 // eventually clean up the hash map 2050 if( it->second.begin() == it->second.end() ) 2051 m_aIncrementals.erase( it ); 2052 } 2053 } 2054 return bHandled; 2055 } 2056 2057 // ------------------------------------------------------------------------ 2058 2059 bool SelectionManager::handleSelectionNotify( XSelectionEvent& rNotify ) 2060 { 2061 MutexGuard aGuard( m_aMutex ); 2062 2063 bool bHandled = false; 2064 2065 // notification about success/failure of one of our conversion requests 2066 #if OSL_DEBUG_LEVEL > 1 2067 OUString aSelection( getString( rNotify.selection ) ); 2068 OUString aProperty( OUString::createFromAscii( "None" ) ); 2069 if( rNotify.property ) 2070 aProperty = getString( rNotify.property ); 2071 fprintf( stderr, "handleSelectionNotify for selection %s and property %s (0x%lx)\n", 2072 OUStringToOString( aSelection, RTL_TEXTENCODING_ISO_8859_1 ).getStr(), 2073 OUStringToOString( aProperty, RTL_TEXTENCODING_ISO_8859_1 ).getStr(), 2074 rNotify.property 2075 ); 2076 if( rNotify.requestor != m_aWindow && rNotify.requestor != m_aCurrentDropWindow ) 2077 fprintf( stderr, "Warning: selection notify for unknown window 0x%lx\n", rNotify.requestor ); 2078 #endif 2079 ::std::hash_map< Atom, Selection* >::iterator it = 2080 m_aSelections.find( rNotify.selection ); 2081 if ( 2082 (rNotify.requestor == m_aWindow || rNotify.requestor == m_aCurrentDropWindow) && 2083 it != m_aSelections.end() && 2084 ( 2085 (it->second->m_eState == Selection::WaitingForResponse) || 2086 (it->second->m_eState == Selection::WaitingForData) 2087 ) 2088 ) 2089 { 2090 bHandled = true; 2091 if( it->second->m_aRequestedType == m_nMULTIPLEAtom ) 2092 { 2093 Atom nType = None; 2094 int nFormat = 0; 2095 unsigned long nItems = 0, nBytes = 0; 2096 unsigned char* pData = NULL; 2097 2098 // get type and length 2099 XGetWindowProperty( m_pDisplay, 2100 rNotify.requestor, 2101 rNotify.property, 2102 0, 256, 2103 False, 2104 AnyPropertyType, 2105 &nType, &nFormat, 2106 &nItems, &nBytes, 2107 &pData ); 2108 if( nBytes ) // HUGE request !!! 2109 { 2110 if( pData ) 2111 XFree( pData ); 2112 XGetWindowProperty( m_pDisplay, 2113 rNotify.requestor, 2114 rNotify.property, 2115 0, 256+(nBytes+3)/4, 2116 False, 2117 AnyPropertyType, 2118 &nType, &nFormat, 2119 &nItems, &nBytes, 2120 &pData ); 2121 } 2122 it->second->m_eState = Selection::Inactive; 2123 sal_Size nUnitSize = GetTrueFormatSize(nFormat); 2124 it->second->m_aData = Sequence< sal_Int8 >((sal_Int8*)pData, nItems * nUnitSize); 2125 it->second->m_aDataArrived.set(); 2126 if( pData ) 2127 XFree( pData ); 2128 } 2129 // WaitingForData can actually happen; some 2130 // applications (e.g. cmdtool on Solaris) first send 2131 // a success and then cancel it. Weird ! 2132 else if( rNotify.property == None ) 2133 { 2134 // conversion failed, stop transfer 2135 it->second->m_eState = Selection::Inactive; 2136 it->second->m_aData = Sequence< sal_Int8 >(); 2137 it->second->m_aDataArrived.set(); 2138 } 2139 // get the bytes, by INCR if necessary 2140 else 2141 it->second->m_eState = Selection::WaitingForData; 2142 } 2143 #if OSL_DEBUG_LEVEL > 1 2144 else if( it != m_aSelections.end() ) 2145 fprintf( stderr, "Warning: selection in state %d\n", it->second->m_eState ); 2146 #endif 2147 return bHandled; 2148 } 2149 2150 // ------------------------------------------------------------------------ 2151 2152 bool SelectionManager::handleDropEvent( XClientMessageEvent& rMessage ) 2153 { 2154 ResettableMutexGuard aGuard(m_aMutex); 2155 2156 // handle drop related events 2157 XLIB_Window aSource = rMessage.data.l[0]; 2158 XLIB_Window aTarget = rMessage.window; 2159 2160 bool bHandled = false; 2161 2162 ::std::hash_map< XLIB_Window, DropTargetEntry >::iterator it = 2163 m_aDropTargets.find( aTarget ); 2164 2165 #if OSL_DEBUG_LEVEL > 1 2166 if( rMessage.message_type == m_nXdndEnter || 2167 rMessage.message_type == m_nXdndLeave || 2168 rMessage.message_type == m_nXdndDrop || 2169 rMessage.message_type == m_nXdndPosition ) 2170 { 2171 fprintf( stderr, "got drop event %s, ", OUStringToOString( getString( rMessage.message_type ), RTL_TEXTENCODING_ASCII_US).getStr() ); 2172 if( it == m_aDropTargets.end() ) 2173 fprintf( stderr, "but no target found\n" ); 2174 else if( ! it->second.m_pTarget->m_bActive ) 2175 fprintf( stderr, "but target is inactive\n" ); 2176 else if( m_aDropEnterEvent.data.l[0] != None && (XLIB_Window)m_aDropEnterEvent.data.l[0] != aSource ) 2177 fprintf( stderr, "but source 0x%lx is unknown (expected 0x%lx or 0)\n", aSource, m_aDropEnterEvent.data.l[0] ); 2178 else 2179 fprintf( stderr, "processing.\n" ); 2180 } 2181 #endif 2182 2183 if( it != m_aDropTargets.end() && it->second.m_pTarget->m_bActive && 2184 m_bDropWaitingForCompletion && m_aDropEnterEvent.data.l[0] ) 2185 { 2186 bHandled = true; 2187 OSL_ENSURE( 0, "someone forgot to call dropComplete ?" ); 2188 // some listener forgot to call dropComplete in the last operation 2189 // let us end it now and accept the new enter event 2190 aGuard.clear(); 2191 dropComplete( sal_False, m_aCurrentDropWindow, m_nDropTime ); 2192 aGuard.reset(); 2193 } 2194 2195 if( it != m_aDropTargets.end() && 2196 it->second.m_pTarget->m_bActive && 2197 ( m_aDropEnterEvent.data.l[0] == None || XLIB_Window(m_aDropEnterEvent.data.l[0]) == aSource ) 2198 ) 2199 { 2200 if( rMessage.message_type == m_nXdndEnter ) 2201 { 2202 bHandled = true; 2203 m_aDropEnterEvent = rMessage; 2204 m_bDropEnterSent = false; 2205 m_aCurrentDropWindow = aTarget; 2206 m_nCurrentProtocolVersion = m_aDropEnterEvent.data.l[1] >> 24; 2207 #if OSL_DEBUG_LEVEL > 1 2208 fprintf( stderr, "received XdndEnter on 0x%lx\n", aTarget ); 2209 #endif 2210 } 2211 else if( 2212 rMessage.message_type == m_nXdndPosition && 2213 aSource == XLIB_Window(m_aDropEnterEvent.data.l[0]) 2214 ) 2215 { 2216 bHandled = true; 2217 m_nDropTime = m_nCurrentProtocolVersion > 0 ? rMessage.data.l[3] : CurrentTime; 2218 if( ! m_bDropEnterSent ) 2219 m_nDropTimestamp = m_nDropTime; 2220 2221 XLIB_Window aChild; 2222 XTranslateCoordinates( m_pDisplay, 2223 it->second.m_aRootWindow, 2224 it->first, 2225 rMessage.data.l[2] >> 16, 2226 rMessage.data.l[2] & 0xffff, 2227 &m_nLastX, &m_nLastY, 2228 &aChild ); 2229 2230 #if OSL_DEBUG_LEVEL > 1 2231 fprintf( stderr, "received XdndPosition on 0x%lx (%d, %d)\n", aTarget, m_nLastX, m_nLastY ); 2232 #endif 2233 DropTargetDragEnterEvent aEvent; 2234 aEvent.Source = static_cast< XDropTarget* >(it->second.m_pTarget); 2235 aEvent.Context = new DropTargetDragContext( m_aCurrentDropWindow, m_nDropTimestamp, *this ); 2236 aEvent.LocationX = m_nLastX; 2237 aEvent.LocationY = m_nLastY; 2238 aEvent.SourceActions = m_nSourceActions; 2239 if( m_nCurrentProtocolVersion < 2 ) 2240 aEvent.DropAction = DNDConstants::ACTION_COPY; 2241 else if( Atom(rMessage.data.l[4]) == m_nXdndActionCopy ) 2242 aEvent.DropAction = DNDConstants::ACTION_COPY; 2243 else if( Atom(rMessage.data.l[4]) == m_nXdndActionMove ) 2244 aEvent.DropAction = DNDConstants::ACTION_MOVE; 2245 else if( Atom(rMessage.data.l[4]) == m_nXdndActionLink ) 2246 aEvent.DropAction = DNDConstants::ACTION_LINK; 2247 else if( Atom(rMessage.data.l[4]) == m_nXdndActionAsk ) 2248 // currently no interface to implement ask 2249 aEvent.DropAction = ~0; 2250 else 2251 aEvent.DropAction = DNDConstants::ACTION_NONE; 2252 2253 m_nLastDropAction = aEvent.DropAction; 2254 if( ! m_bDropEnterSent ) 2255 { 2256 m_bDropEnterSent = true; 2257 aEvent.SupportedDataFlavors = m_xDropTransferable->getTransferDataFlavors(); 2258 aGuard.clear(); 2259 it->second->dragEnter( aEvent ); 2260 } 2261 else 2262 { 2263 aGuard.clear(); 2264 it->second->dragOver( aEvent ); 2265 } 2266 } 2267 else if( 2268 rMessage.message_type == m_nXdndLeave && 2269 aSource == XLIB_Window(m_aDropEnterEvent.data.l[0]) 2270 ) 2271 { 2272 bHandled = true; 2273 #if OSL_DEBUG_LEVEL > 1 2274 fprintf( stderr, "received XdndLeave on 0x%lx\n", aTarget ); 2275 #endif 2276 DropTargetEvent aEvent; 2277 aEvent.Source = static_cast< XDropTarget* >(it->second.m_pTarget); 2278 m_aDropEnterEvent.data.l[0] = None; 2279 if( m_aCurrentDropWindow == aTarget ) 2280 m_aCurrentDropWindow = None; 2281 m_nCurrentProtocolVersion = nXdndProtocolRevision; 2282 aGuard.clear(); 2283 it->second->dragExit( aEvent ); 2284 } 2285 else if( 2286 rMessage.message_type == m_nXdndDrop && 2287 aSource == XLIB_Window(m_aDropEnterEvent.data.l[0]) 2288 ) 2289 { 2290 bHandled = true; 2291 m_nDropTime = m_nCurrentProtocolVersion > 0 ? rMessage.data.l[2] : CurrentTime; 2292 2293 #if OSL_DEBUG_LEVEL > 1 2294 fprintf( stderr, "received XdndDrop on 0x%lx (%d, %d)\n", aTarget, m_nLastX, m_nLastY ); 2295 #endif 2296 if( m_bLastDropAccepted ) 2297 { 2298 DropTargetDropEvent aEvent; 2299 aEvent.Source = static_cast< XDropTarget* >(it->second.m_pTarget); 2300 aEvent.Context = new DropTargetDropContext( m_aCurrentDropWindow, m_nDropTimestamp, *this ); 2301 aEvent.LocationX = m_nLastX; 2302 aEvent.LocationY = m_nLastY; 2303 aEvent.DropAction = m_nLastDropAction; 2304 // there is nothing corresponding to source supported actions 2305 // every source can do link, copy and move 2306 aEvent.SourceActions= m_nLastDropAction; 2307 aEvent.Transferable = m_xDropTransferable; 2308 2309 m_bDropWaitingForCompletion = true; 2310 aGuard.clear(); 2311 it->second->drop( aEvent ); 2312 } 2313 else 2314 { 2315 #if OSL_DEBUG_LEVEL > 1 2316 fprintf( stderr, "XdndDrop canceled due to m_bLastDropAccepted = fale\n" ); 2317 #endif 2318 DropTargetEvent aEvent; 2319 aEvent.Source = static_cast< XDropTarget* >(it->second.m_pTarget); 2320 aGuard.clear(); 2321 it->second->dragExit( aEvent ); 2322 // reset the drop status, notify source 2323 dropComplete( sal_False, m_aCurrentDropWindow, m_nDropTime ); 2324 } 2325 } 2326 } 2327 return bHandled; 2328 } 2329 2330 /* 2331 * methods for XDropTargetDropContext 2332 */ 2333 2334 void SelectionManager::dropComplete( sal_Bool bSuccess, XLIB_Window aDropWindow, XLIB_Time ) 2335 { 2336 ClearableMutexGuard aGuard(m_aMutex); 2337 2338 if( aDropWindow == m_aCurrentDropWindow ) 2339 { 2340 if( m_xDragSourceListener.is() ) 2341 { 2342 DragSourceDropEvent dsde; 2343 dsde.Source = static_cast< OWeakObject* >(this); 2344 dsde.DragSourceContext = new DragSourceContext( m_aDropWindow, m_nDragTimestamp, *this ); 2345 dsde.DragSource = static_cast< XDragSource* >(this); 2346 dsde.DropAction = getUserDragAction(); 2347 dsde.DropSuccess = bSuccess; 2348 css::uno::Reference< XDragSourceListener > xListener = m_xDragSourceListener; 2349 m_xDragSourceListener.clear(); 2350 2351 aGuard.clear(); 2352 xListener->dragDropEnd( dsde ); 2353 } 2354 else if( m_aDropEnterEvent.data.l[0] && m_aCurrentDropWindow ) 2355 { 2356 XEvent aEvent; 2357 aEvent.xclient.type = ClientMessage; 2358 aEvent.xclient.display = m_pDisplay; 2359 aEvent.xclient.window = m_aDropEnterEvent.data.l[0]; 2360 aEvent.xclient.message_type = m_nXdndFinished; 2361 aEvent.xclient.format = 32; 2362 aEvent.xclient.data.l[0] = m_aCurrentDropWindow; 2363 aEvent.xclient.data.l[1] = bSuccess ? 1 : 0; 2364 aEvent.xclient.data.l[2] = 0; 2365 aEvent.xclient.data.l[3] = 0; 2366 aEvent.xclient.data.l[4] = 0; 2367 if( bSuccess ) 2368 { 2369 if( m_nLastDropAction & DNDConstants::ACTION_MOVE ) 2370 aEvent.xclient.data.l[2] = m_nXdndActionMove; 2371 else if( m_nLastDropAction & DNDConstants::ACTION_COPY ) 2372 aEvent.xclient.data.l[2] = m_nXdndActionCopy; 2373 else if( m_nLastDropAction & DNDConstants::ACTION_LINK ) 2374 aEvent.xclient.data.l[2] = m_nXdndActionLink; 2375 } 2376 2377 #if OSL_DEBUG_LEVEL > 1 2378 fprintf( stderr, "Sending XdndFinished to 0x%lx\n", 2379 m_aDropEnterEvent.data.l[0] 2380 ); 2381 #endif 2382 2383 XSendEvent( m_pDisplay, m_aDropEnterEvent.data.l[0], 2384 False, NoEventMask, & aEvent ); 2385 2386 m_aDropEnterEvent.data.l[0] = None; 2387 m_aCurrentDropWindow = None; 2388 m_nCurrentProtocolVersion = nXdndProtocolRevision; 2389 } 2390 m_bDropWaitingForCompletion = false; 2391 } 2392 else 2393 OSL_ASSERT( "dropComplete from invalid DropTargetDropContext" ); 2394 } 2395 2396 /* 2397 * methods for XDropTargetDragContext 2398 */ 2399 2400 // ------------------------------------------------------------------------ 2401 2402 void SelectionManager::sendDragStatus( Atom nDropAction ) 2403 { 2404 ClearableMutexGuard aGuard(m_aMutex); 2405 2406 if( m_xDragSourceListener.is() ) 2407 { 2408 sal_Int8 nNewDragAction; 2409 if( nDropAction == m_nXdndActionMove ) 2410 nNewDragAction = DNDConstants::ACTION_MOVE; 2411 else if( nDropAction == m_nXdndActionCopy ) 2412 nNewDragAction = DNDConstants::ACTION_COPY; 2413 else if( nDropAction == m_nXdndActionLink ) 2414 nNewDragAction = DNDConstants::ACTION_LINK; 2415 else 2416 nNewDragAction = DNDConstants::ACTION_NONE; 2417 nNewDragAction &= m_nSourceActions; 2418 2419 if( nNewDragAction != m_nTargetAcceptAction ) 2420 { 2421 setCursor( getDefaultCursor( nNewDragAction ), m_aDropWindow, m_nDragTimestamp ); 2422 m_nTargetAcceptAction = nNewDragAction; 2423 } 2424 2425 DragSourceDragEvent dsde; 2426 dsde.Source = static_cast< OWeakObject* >(this); 2427 dsde.DragSourceContext = new DragSourceContext( m_aDropWindow, m_nDragTimestamp, *this ); 2428 dsde.DragSource = static_cast< XDragSource* >(this); 2429 dsde.DropAction = m_nSourceActions; 2430 dsde.UserAction = getUserDragAction(); 2431 2432 css::uno::Reference< XDragSourceListener > xListener( m_xDragSourceListener ); 2433 // caution: do not change anything after this 2434 aGuard.clear(); 2435 if( xListener.is() ) 2436 xListener->dragOver( dsde ); 2437 } 2438 else if( m_aDropEnterEvent.data.l[0] && m_aCurrentDropWindow ) 2439 { 2440 XEvent aEvent; 2441 aEvent.xclient.type = ClientMessage; 2442 aEvent.xclient.display = m_pDisplay; 2443 aEvent.xclient.window = m_aDropEnterEvent.data.l[0]; 2444 aEvent.xclient.message_type = m_nXdndStatus; 2445 aEvent.xclient.format = 32; 2446 aEvent.xclient.data.l[0] = m_aCurrentDropWindow; 2447 aEvent.xclient.data.l[1] = 2; 2448 if( nDropAction == m_nXdndActionMove || 2449 nDropAction == m_nXdndActionLink || 2450 nDropAction == m_nXdndActionCopy ) 2451 aEvent.xclient.data.l[1] |= 1; 2452 aEvent.xclient.data.l[2] = 0; 2453 aEvent.xclient.data.l[3] = 0; 2454 aEvent.xclient.data.l[4] = m_nCurrentProtocolVersion > 1 ? nDropAction : 0; 2455 2456 #if OSL_DEBUG_LEVEL > 1 2457 fprintf( stderr, "Sending XdndStatus to 0x%lx with action %s\n", 2458 m_aDropEnterEvent.data.l[0], 2459 OUStringToOString( getString( nDropAction ), RTL_TEXTENCODING_ISO_8859_1 ).getStr() 2460 ); 2461 #endif 2462 2463 XSendEvent( m_pDisplay, m_aDropEnterEvent.data.l[0], 2464 False, NoEventMask, & aEvent ); 2465 XFlush( m_pDisplay ); 2466 } 2467 } 2468 2469 // ------------------------------------------------------------------------ 2470 2471 sal_Int8 SelectionManager::getUserDragAction() const 2472 { 2473 return (m_nTargetAcceptAction != DNDConstants::ACTION_DEFAULT) ? m_nTargetAcceptAction : m_nUserDragAction; 2474 } 2475 2476 // ------------------------------------------------------------------------ 2477 2478 bool SelectionManager::updateDragAction( int modifierState ) 2479 { 2480 bool bRet = false; 2481 2482 sal_Int8 nNewDropAction = DNDConstants::ACTION_MOVE; 2483 if( ( modifierState & ShiftMask ) && ! ( modifierState & ControlMask ) ) 2484 nNewDropAction = DNDConstants::ACTION_MOVE; 2485 else if( ( modifierState & ControlMask ) && ! ( modifierState & ShiftMask ) ) 2486 nNewDropAction = DNDConstants::ACTION_COPY; 2487 else if( ( modifierState & ShiftMask ) && ( modifierState & ControlMask ) ) 2488 nNewDropAction = DNDConstants::ACTION_LINK; 2489 if( m_nCurrentProtocolVersion < 0 && m_aDropWindow != None ) 2490 nNewDropAction = DNDConstants::ACTION_COPY; 2491 nNewDropAction &= m_nSourceActions; 2492 2493 if( ! ( modifierState & ( ControlMask | ShiftMask ) ) ) 2494 { 2495 if( ! nNewDropAction ) 2496 { 2497 // default to an action so the user does not have to press 2498 // keys explicitly 2499 if( m_nSourceActions & DNDConstants::ACTION_MOVE ) 2500 nNewDropAction = DNDConstants::ACTION_MOVE; 2501 else if( m_nSourceActions & DNDConstants::ACTION_COPY ) 2502 nNewDropAction = DNDConstants::ACTION_COPY; 2503 else if( m_nSourceActions & DNDConstants::ACTION_LINK ) 2504 nNewDropAction = DNDConstants::ACTION_LINK; 2505 } 2506 nNewDropAction |= DNDConstants::ACTION_DEFAULT; 2507 } 2508 2509 if( nNewDropAction != m_nUserDragAction || m_nTargetAcceptAction != DNDConstants::ACTION_DEFAULT ) 2510 { 2511 #if OSL_DEBUG_LEVEL > 1 2512 fprintf( stderr, "updateDragAction: %x -> %x\n", (int)m_nUserDragAction, (int)nNewDropAction ); 2513 #endif 2514 bRet = true; 2515 m_nUserDragAction = nNewDropAction; 2516 2517 DragSourceDragEvent dsde; 2518 dsde.Source = static_cast< OWeakObject* >(this); 2519 dsde.DragSourceContext = new DragSourceContext( m_aDropWindow, m_nDragTimestamp, *this ); 2520 dsde.DragSource = static_cast< XDragSource* >(this); 2521 dsde.DropAction = m_nUserDragAction; 2522 dsde.UserAction = m_nUserDragAction; 2523 m_nTargetAcceptAction = DNDConstants::ACTION_DEFAULT; // invalidate last accept 2524 m_xDragSourceListener->dropActionChanged( dsde ); 2525 } 2526 return bRet; 2527 } 2528 2529 // ------------------------------------------------------------------------ 2530 2531 void SelectionManager::sendDropPosition( bool bForce, XLIB_Time eventTime ) 2532 { 2533 ClearableMutexGuard aGuard(m_aMutex); 2534 2535 if( m_bDropSent ) 2536 return; 2537 2538 ::std::hash_map< XLIB_Window, DropTargetEntry >::const_iterator it = 2539 m_aDropTargets.find( m_aDropWindow ); 2540 if( it != m_aDropTargets.end() ) 2541 { 2542 if( it->second.m_pTarget->m_bActive ) 2543 { 2544 int x, y; 2545 XLIB_Window aChild; 2546 XTranslateCoordinates( m_pDisplay, it->second.m_aRootWindow, m_aDropWindow, m_nLastDragX, m_nLastDragY, &x, &y, &aChild ); 2547 DropTargetDragEvent dtde; 2548 dtde.Source = static_cast< OWeakObject* >(it->second.m_pTarget ); 2549 dtde.Context = new DropTargetDragContext( m_aCurrentDropWindow, m_nDropTimestamp, *this ); 2550 dtde.LocationX = x; 2551 dtde.LocationY = y; 2552 dtde.DropAction = getUserDragAction(); 2553 dtde.SourceActions = m_nSourceActions; 2554 aGuard.clear(); 2555 it->second->dragOver( dtde ); 2556 } 2557 } 2558 else if( bForce || 2559 2560 m_nLastDragX < m_nNoPosX || m_nLastDragX >= m_nNoPosX+m_nNoPosWidth || 2561 m_nLastDragY < m_nNoPosY || m_nLastDragY >= m_nNoPosY+m_nNoPosHeight 2562 ) 2563 { 2564 // send XdndPosition 2565 XEvent aEvent; 2566 aEvent.type = ClientMessage; 2567 aEvent.xclient.display = m_pDisplay; 2568 aEvent.xclient.format = 32; 2569 aEvent.xclient.message_type = m_nXdndPosition; 2570 aEvent.xclient.window = m_aDropWindow; 2571 aEvent.xclient.data.l[0] = m_aWindow; 2572 aEvent.xclient.data.l[1] = 0; 2573 aEvent.xclient.data.l[2] = m_nLastDragX << 16 | (m_nLastDragY&0xffff); 2574 aEvent.xclient.data.l[3] = eventTime; 2575 2576 if( m_nUserDragAction & DNDConstants::ACTION_COPY ) 2577 aEvent.xclient.data.l[4]=m_nXdndActionCopy; 2578 else if( m_nUserDragAction & DNDConstants::ACTION_MOVE ) 2579 aEvent.xclient.data.l[4]=m_nXdndActionMove; 2580 else if( m_nUserDragAction & DNDConstants::ACTION_LINK ) 2581 aEvent.xclient.data.l[4]=m_nXdndActionLink; 2582 else 2583 aEvent.xclient.data.l[4]=m_nXdndActionCopy; 2584 XSendEvent( m_pDisplay, m_aDropProxy, False, NoEventMask, &aEvent ); 2585 m_nNoPosX = m_nNoPosY = m_nNoPosWidth = m_nNoPosHeight = 0; 2586 } 2587 } 2588 2589 // ------------------------------------------------------------------------ 2590 2591 bool SelectionManager::handleDragEvent( XEvent& rMessage ) 2592 { 2593 if( ! m_xDragSourceListener.is() ) 2594 return false; 2595 2596 ResettableMutexGuard aGuard(m_aMutex); 2597 2598 bool bHandled = false; 2599 2600 // for shortcut 2601 ::std::hash_map< XLIB_Window, DropTargetEntry >::const_iterator it = 2602 m_aDropTargets.find( m_aDropWindow ); 2603 #if OSL_DEBUG_LEVEL > 1 2604 switch( rMessage.type ) 2605 { 2606 case ClientMessage: 2607 fprintf( stderr, "handleDragEvent: %s\n", OUStringToOString( getString( rMessage.xclient.message_type ), RTL_TEXTENCODING_ISO_8859_1 ).getStr() ); 2608 break; 2609 case MotionNotify: 2610 // fprintf( stderr, "handleDragEvent: MotionNotify\n" ); 2611 break; 2612 case EnterNotify: 2613 fprintf( stderr, "handleDragEvent: EnterNotify\n" ); 2614 break; 2615 case LeaveNotify: 2616 fprintf( stderr, "handleDragEvent: LeaveNotify\n" ); 2617 break; 2618 case ButtonPress: 2619 fprintf( stderr, "handleDragEvent: ButtonPress %d (m_nDragButton = %d)\n", rMessage.xbutton.button, m_nDragButton ); 2620 break; 2621 case ButtonRelease: 2622 fprintf( stderr, "handleDragEvent: ButtonRelease %d (m_nDragButton = %d)\n", rMessage.xbutton.button, m_nDragButton ); 2623 break; 2624 case XLIB_KeyPress: 2625 fprintf( stderr, "handleDragEvent: KeyPress\n" ); 2626 break; 2627 case KeyRelease: 2628 fprintf( stderr, "handleDragEvent: KeyRelease\n" ); 2629 break; 2630 default: 2631 fprintf( stderr, "handleDragEvent: <unknown type %d>\n", rMessage.type ); 2632 break; 2633 } 2634 #endif 2635 2636 // handle drag related events 2637 if( rMessage.type == ClientMessage ) 2638 { 2639 if( Atom(rMessage.xclient.message_type) == m_nXdndStatus && Atom(rMessage.xclient.data.l[0]) == m_aDropWindow ) 2640 { 2641 bHandled = true; 2642 DragSourceDragEvent dsde; 2643 dsde.Source = static_cast< OWeakObject* >(this); 2644 dsde.DragSourceContext = new DragSourceContext( m_aDropWindow, m_nDragTimestamp, *this ); 2645 dsde.DragSource = static_cast< XDragSource* >( this ); 2646 dsde.UserAction = getUserDragAction(); 2647 dsde.DropAction = DNDConstants::ACTION_NONE; 2648 m_bDropSuccess = rMessage.xclient.data.l[1] & 1 ? true : false; 2649 #if OSL_DEBUG_LEVEL > 1 2650 fprintf( stderr, "status drop action: accept = %s, %s\n", 2651 m_bDropSuccess ? "true" : "false", 2652 OUStringToOString( getString( rMessage.xclient.data.l[4] ), RTL_TEXTENCODING_ISO_8859_1 ).getStr() ); 2653 #endif 2654 if( rMessage.xclient.data.l[1] & 1 ) 2655 { 2656 if( m_nCurrentProtocolVersion > 1 ) 2657 { 2658 if( Atom(rMessage.xclient.data.l[4]) == m_nXdndActionCopy ) 2659 dsde.DropAction = DNDConstants::ACTION_COPY; 2660 else if( Atom(rMessage.xclient.data.l[4]) == m_nXdndActionMove ) 2661 dsde.DropAction = DNDConstants::ACTION_MOVE; 2662 else if( Atom(rMessage.xclient.data.l[4]) == m_nXdndActionLink ) 2663 dsde.DropAction = DNDConstants::ACTION_LINK; 2664 } 2665 else 2666 dsde.DropAction = DNDConstants::ACTION_COPY; 2667 } 2668 m_nTargetAcceptAction = dsde.DropAction; 2669 2670 if( ! ( rMessage.xclient.data.l[1] & 2 ) ) 2671 { 2672 m_nNoPosX = rMessage.xclient.data.l[2] >> 16; 2673 m_nNoPosY = rMessage.xclient.data.l[2] & 0xffff; 2674 m_nNoPosWidth = rMessage.xclient.data.l[3] >> 16; 2675 m_nNoPosHeight = rMessage.xclient.data.l[3] & 0xffff; 2676 } 2677 else 2678 m_nNoPosX = m_nNoPosY = m_nNoPosWidth = m_nNoPosHeight = 0; 2679 2680 setCursor( getDefaultCursor( dsde.DropAction ), m_aDropWindow, m_nDragTimestamp ); 2681 aGuard.clear(); 2682 m_xDragSourceListener->dragOver( dsde ); 2683 } 2684 else if( Atom(rMessage.xclient.message_type) == m_nXdndFinished && m_aDropWindow == Atom(rMessage.xclient.data.l[0]) ) 2685 { 2686 bHandled = true; 2687 // notify the listener 2688 DragSourceDropEvent dsde; 2689 dsde.Source = static_cast< OWeakObject* >(this); 2690 dsde.DragSourceContext = new DragSourceContext( m_aDropWindow, m_nDragTimestamp, *this ); 2691 dsde.DragSource = static_cast< XDragSource* >(this); 2692 dsde.DropAction = m_nTargetAcceptAction; 2693 dsde.DropSuccess = m_bDropSuccess; 2694 css::uno::Reference< XDragSourceListener > xListener( m_xDragSourceListener ); 2695 m_xDragSourceListener.clear(); 2696 aGuard.clear(); 2697 xListener->dragDropEnd( dsde ); 2698 } 2699 } 2700 else if( rMessage.type == MotionNotify || 2701 rMessage.type == EnterNotify || rMessage.type == LeaveNotify 2702 ) 2703 { 2704 bHandled = true; 2705 bool bForce = false; 2706 int root_x = rMessage.type == MotionNotify ? rMessage.xmotion.x_root : rMessage.xcrossing.x_root; 2707 int root_y = rMessage.type == MotionNotify ? rMessage.xmotion.y_root : rMessage.xcrossing.y_root; 2708 XLIB_Window root = rMessage.type == MotionNotify ? rMessage.xmotion.root : rMessage.xcrossing.root; 2709 m_nDragTimestamp = rMessage.type == MotionNotify ? rMessage.xmotion.time : rMessage.xcrossing.time; 2710 2711 aGuard.clear(); 2712 if( rMessage.type == MotionNotify ) 2713 { 2714 bForce = updateDragAction( rMessage.xmotion.state ); 2715 } 2716 updateDragWindow( root_x, root_y, root ); 2717 aGuard.reset(); 2718 2719 if( m_nCurrentProtocolVersion >= 0 && m_aDropProxy != None ) 2720 { 2721 aGuard.clear(); 2722 sendDropPosition( bForce, rMessage.type == MotionNotify ? rMessage.xmotion.time : rMessage.xcrossing.time ); 2723 } 2724 } 2725 else if( rMessage.type == XLIB_KeyPress || rMessage.type == KeyRelease ) 2726 { 2727 bHandled = true; 2728 const KeySym aKey = XkbKeycodeToKeysym( m_pDisplay, rMessage.xkey.keycode, 0, 0 ); 2729 if( aKey == XK_Escape ) 2730 { 2731 // abort drag 2732 if( it != m_aDropTargets.end() ) 2733 { 2734 DropTargetEvent dte; 2735 dte.Source = static_cast< OWeakObject* >( it->second.m_pTarget ); 2736 aGuard.clear(); 2737 it->second.m_pTarget->dragExit( dte ); 2738 } 2739 else if( m_aDropProxy != None && m_nCurrentProtocolVersion >= 0 ) 2740 { 2741 // send XdndLeave 2742 XEvent aEvent; 2743 aEvent.type = ClientMessage; 2744 aEvent.xclient.display = m_pDisplay; 2745 aEvent.xclient.format = 32; 2746 aEvent.xclient.message_type = m_nXdndLeave; 2747 aEvent.xclient.window = m_aDropWindow; 2748 aEvent.xclient.data.l[0] = m_aWindow; 2749 memset( aEvent.xclient.data.l+1, 0, sizeof(long)*4); 2750 m_aDropWindow = m_aDropProxy = None; 2751 XSendEvent( m_pDisplay, m_aDropProxy, False, NoEventMask, &aEvent ); 2752 } 2753 // notify the listener 2754 DragSourceDropEvent dsde; 2755 dsde.Source = static_cast< OWeakObject* >(this); 2756 dsde.DragSourceContext = new DragSourceContext( m_aDropWindow, m_nDragTimestamp, *this ); 2757 dsde.DragSource = static_cast< XDragSource* >(this); 2758 dsde.DropAction = DNDConstants::ACTION_NONE; 2759 dsde.DropSuccess = sal_False; 2760 css::uno::Reference< XDragSourceListener > xListener( m_xDragSourceListener ); 2761 m_xDragSourceListener.clear(); 2762 aGuard.clear(); 2763 xListener->dragDropEnd( dsde ); 2764 } 2765 else 2766 { 2767 /* 2768 * man page says: state is state immediate PRIOR to the 2769 * event. It would seem that this is a somewhat arguable 2770 * design decision. 2771 */ 2772 int nState = rMessage.xkey.state; 2773 int nNewState = 0; 2774 switch( aKey ) 2775 { 2776 case XK_Shift_R: 2777 case XK_Shift_L: nNewState = ShiftMask;break; 2778 case XK_Control_R: 2779 case XK_Control_L: nNewState = ControlMask;break; 2780 // just interested in shift and ctrl for dnd 2781 } 2782 if( rMessage.type == XLIB_KeyPress ) 2783 nState |= nNewState; 2784 else 2785 nState &= ~nNewState; 2786 aGuard.clear(); 2787 if( updateDragAction( nState ) ) 2788 sendDropPosition( true, rMessage.xkey.time ); 2789 } 2790 } 2791 else if( 2792 ( rMessage.type == ButtonPress || rMessage.type == ButtonRelease ) && 2793 rMessage.xbutton.button == m_nDragButton ) 2794 { 2795 bool bCancel = true; 2796 if( m_aDropWindow != None ) 2797 { 2798 if( it != m_aDropTargets.end() ) 2799 { 2800 if( it->second.m_pTarget->m_bActive && m_nUserDragAction != DNDConstants::ACTION_NONE && m_bLastDropAccepted ) 2801 { 2802 bHandled = true; 2803 int x, y; 2804 XLIB_Window aChild; 2805 XTranslateCoordinates( m_pDisplay, rMessage.xbutton.root, m_aDropWindow, rMessage.xbutton.x_root, rMessage.xbutton.y_root, &x, &y, &aChild ); 2806 DropTargetDropEvent dtde; 2807 dtde.Source = static_cast< OWeakObject* >(it->second.m_pTarget ); 2808 dtde.Context = new DropTargetDropContext( m_aCurrentDropWindow, m_nDropTimestamp, *this ); 2809 dtde.LocationX = x; 2810 dtde.LocationY = y; 2811 dtde.DropAction = m_nUserDragAction; 2812 dtde.SourceActions = m_nSourceActions; 2813 dtde.Transferable = m_xDragSourceTransferable; 2814 m_bDropSent = true; 2815 m_nDropTimeout = time( NULL ); 2816 m_bDropWaitingForCompletion = true; 2817 aGuard.clear(); 2818 it->second->drop( dtde ); 2819 bCancel = false; 2820 } 2821 else bCancel = true; 2822 } 2823 else if( m_nCurrentProtocolVersion >= 0 ) 2824 { 2825 bHandled = true; 2826 2827 XEvent aEvent; 2828 aEvent.type = ClientMessage; 2829 aEvent.xclient.display = m_pDisplay; 2830 aEvent.xclient.format = 32; 2831 aEvent.xclient.message_type = m_nXdndDrop; 2832 aEvent.xclient.window = m_aDropWindow; 2833 aEvent.xclient.data.l[0] = m_aWindow; 2834 aEvent.xclient.data.l[1] = 0; 2835 aEvent.xclient.data.l[2] = rMessage.xbutton.time; 2836 aEvent.xclient.data.l[3] = 0; 2837 aEvent.xclient.data.l[4] = 0; 2838 2839 m_bDropSent = true; 2840 m_nDropTimeout = time( NULL ); 2841 XSendEvent( m_pDisplay, m_aDropProxy, False, NoEventMask, &aEvent ); 2842 bCancel = false; 2843 } 2844 else 2845 { 2846 // dropping on non XdndWindows: acquire ownership of 2847 // PRIMARY and send a middle mouse button click down/up to 2848 // target window 2849 SelectionAdaptor* pAdaptor = getAdaptor( XA_PRIMARY ); 2850 if( pAdaptor ) 2851 { 2852 bHandled = true; 2853 2854 XLIB_Window aDummy; 2855 XEvent aEvent; 2856 aEvent.type = ButtonPress; 2857 aEvent.xbutton.display = m_pDisplay; 2858 aEvent.xbutton.window = m_aDropWindow; 2859 aEvent.xbutton.root = rMessage.xbutton.root; 2860 aEvent.xbutton.subwindow = m_aDropWindow; 2861 aEvent.xbutton.time = rMessage.xbutton.time+1; 2862 aEvent.xbutton.x_root = rMessage.xbutton.x_root; 2863 aEvent.xbutton.y_root = rMessage.xbutton.y_root; 2864 aEvent.xbutton.state = rMessage.xbutton.state; 2865 aEvent.xbutton.button = Button2; 2866 aEvent.xbutton.same_screen = True; 2867 XTranslateCoordinates( m_pDisplay, 2868 rMessage.xbutton.root, m_aDropWindow, 2869 rMessage.xbutton.x_root, rMessage.xbutton.y_root, 2870 &aEvent.xbutton.x, &aEvent.xbutton.y, 2871 &aDummy ); 2872 XSendEvent( m_pDisplay, m_aDropWindow, False, ButtonPressMask, &aEvent ); 2873 aEvent.xbutton.type = ButtonRelease; 2874 aEvent.xbutton.time++; 2875 aEvent.xbutton.state |= Button2Mask; 2876 XSendEvent( m_pDisplay, m_aDropWindow, False, ButtonReleaseMask, &aEvent ); 2877 2878 m_bDropSent = true; 2879 m_nDropTimeout = time( NULL ); 2880 XSendEvent( m_pDisplay, m_aDropProxy, False, NoEventMask, &aEvent ); 2881 m_bWaitingForPrimaryConversion = true; 2882 m_bDropSent = true; 2883 m_nDropTimeout = time( NULL ); 2884 // HACK :-) 2885 aGuard.clear(); 2886 static_cast< X11Clipboard* >( pAdaptor )->setContents( m_xDragSourceTransferable, css::uno::Reference< ::com::sun::star::datatransfer::clipboard::XClipboardOwner >() ); 2887 aGuard.reset(); 2888 bCancel = false; 2889 } 2890 } 2891 } 2892 if( bCancel ) 2893 { 2894 // cancel drag 2895 DragSourceDropEvent dsde; 2896 dsde.Source = static_cast< OWeakObject* >(this); 2897 dsde.DragSourceContext = new DragSourceContext( m_aDropWindow, m_nDragTimestamp, *this ); 2898 dsde.DragSource = static_cast< XDragSource* >(this); 2899 dsde.DropAction = DNDConstants::ACTION_NONE; 2900 dsde.DropSuccess = sal_False; 2901 css::uno::Reference< XDragSourceListener > xListener( m_xDragSourceListener ); 2902 m_xDragSourceListener.clear(); 2903 aGuard.clear(); 2904 xListener->dragDropEnd( dsde ); 2905 bHandled = true; 2906 } 2907 } 2908 return bHandled; 2909 } 2910 2911 // ------------------------------------------------------------------------ 2912 2913 void SelectionManager::accept( sal_Int8 dragOperation, XLIB_Window aDropWindow, XLIB_Time ) 2914 { 2915 if( aDropWindow == m_aCurrentDropWindow ) 2916 { 2917 #if OSL_DEBUG_LEVEL > 1 2918 fprintf( stderr, "accept: %x\n", dragOperation ); 2919 #endif 2920 Atom nAction = None; 2921 dragOperation &= (DNDConstants::ACTION_MOVE | DNDConstants::ACTION_COPY | DNDConstants::ACTION_LINK); 2922 if( dragOperation & DNDConstants::ACTION_MOVE ) 2923 nAction = m_nXdndActionMove; 2924 else if( dragOperation & DNDConstants::ACTION_COPY ) 2925 nAction = m_nXdndActionCopy; 2926 else if( dragOperation & DNDConstants::ACTION_LINK ) 2927 nAction = m_nXdndActionLink; 2928 m_bLastDropAccepted = true; 2929 sendDragStatus( nAction ); 2930 } 2931 } 2932 2933 // ------------------------------------------------------------------------ 2934 2935 void SelectionManager::reject( XLIB_Window aDropWindow, XLIB_Time ) 2936 { 2937 if( aDropWindow == m_aCurrentDropWindow ) 2938 { 2939 #if OSL_DEBUG_LEVEL > 1 2940 fprintf( stderr, "reject\n" ); 2941 #endif 2942 m_bLastDropAccepted = false; 2943 sendDragStatus( None ); 2944 if( m_bDropSent && m_xDragSourceListener.is() ) 2945 { 2946 DragSourceDropEvent dsde; 2947 dsde.Source = static_cast< OWeakObject* >(this); 2948 dsde.DragSourceContext = new DragSourceContext( m_aDropWindow, m_nDragTimestamp, *this ); 2949 dsde.DragSource = static_cast< XDragSource* >(this); 2950 dsde.DropAction = DNDConstants::ACTION_NONE; 2951 dsde.DropSuccess = sal_False; 2952 m_xDragSourceListener->dragDropEnd( dsde ); 2953 m_xDragSourceListener.clear(); 2954 } 2955 } 2956 } 2957 2958 /* 2959 * XDragSource 2960 */ 2961 2962 sal_Bool SelectionManager::isDragImageSupported() throw() 2963 { 2964 return sal_False; 2965 } 2966 2967 // ------------------------------------------------------------------------ 2968 2969 sal_Int32 SelectionManager::getDefaultCursor( sal_Int8 dragAction ) throw() 2970 { 2971 XLIB_Cursor aCursor = m_aNoneCursor; 2972 if( dragAction & DNDConstants::ACTION_MOVE ) 2973 aCursor = m_aMoveCursor; 2974 else if( dragAction & DNDConstants::ACTION_COPY ) 2975 aCursor = m_aCopyCursor; 2976 else if( dragAction & DNDConstants::ACTION_LINK ) 2977 aCursor = m_aLinkCursor; 2978 return aCursor; 2979 } 2980 2981 // ------------------------------------------------------------------------ 2982 2983 int SelectionManager::getXdndVersion( XLIB_Window aWindow, XLIB_Window& rProxy ) 2984 { 2985 Atom* pProperties = NULL; 2986 int nProperties = 0; 2987 Atom nType; 2988 int nFormat; 2989 unsigned long nItems, nBytes; 2990 unsigned char* pBytes = NULL; 2991 2992 int nVersion = -1; 2993 rProxy = None; 2994 2995 /* 2996 * XListProperties is used here to avoid unnecessary XGetWindowProperty calls 2997 * and therefore reducing latency penalty 2998 */ 2999 pProperties = XListProperties( m_pDisplay, aWindow, &nProperties ); 3000 // first look for proxy 3001 int i; 3002 for( i = 0; i < nProperties; i++ ) 3003 { 3004 if( pProperties[i] == m_nXdndProxy ) 3005 { 3006 XGetWindowProperty( m_pDisplay, aWindow, m_nXdndProxy, 0, 1, False, XA_WINDOW, 3007 &nType, &nFormat, &nItems, &nBytes, &pBytes ); 3008 if( pBytes ) 3009 { 3010 if( nType == XA_WINDOW ) 3011 rProxy = *(XLIB_Window*)pBytes; 3012 XFree( pBytes ); 3013 pBytes = NULL; 3014 if( rProxy != None ) 3015 { 3016 // now check proxy wether it points to itself 3017 XGetWindowProperty( m_pDisplay, rProxy, m_nXdndProxy, 0, 1, False, XA_WINDOW, 3018 &nType, &nFormat, &nItems, &nBytes, &pBytes ); 3019 if( pBytes ) 3020 { 3021 if( nType == XA_WINDOW && *(XLIB_Window*)pBytes != rProxy ) 3022 rProxy = None; 3023 XFree( pBytes ); 3024 pBytes = NULL; 3025 } 3026 else 3027 rProxy = None; 3028 } 3029 } 3030 break; 3031 } 3032 } 3033 XLIB_Window aAwareWindow = rProxy != None ? rProxy : aWindow; 3034 3035 XGetWindowProperty( m_pDisplay, aAwareWindow, m_nXdndAware, 0, 1, False, XA_ATOM, 3036 &nType, &nFormat, &nItems, &nBytes, &pBytes ); 3037 if( pBytes ) 3038 { 3039 if( nType == XA_ATOM ) 3040 nVersion = *(Atom*)pBytes; 3041 XFree( pBytes ); 3042 } 3043 3044 nVersion = nVersion > nXdndProtocolRevision ? nXdndProtocolRevision : nVersion; 3045 3046 return nVersion; 3047 } 3048 3049 // ------------------------------------------------------------------------ 3050 3051 void SelectionManager::updateDragWindow( int nX, int nY, XLIB_Window aRoot ) 3052 { 3053 ResettableMutexGuard aGuard( m_aMutex ); 3054 3055 css::uno::Reference< XDragSourceListener > xListener( m_xDragSourceListener ); 3056 3057 m_nLastDragX = nX; 3058 m_nLastDragY = nY; 3059 3060 XLIB_Window aParent = aRoot; 3061 XLIB_Window aChild; 3062 XLIB_Window aNewProxy = None, aNewCurrentWindow = None; 3063 int nNewProtocolVersion = -1; 3064 int nWinX, nWinY; 3065 3066 // find the first XdndAware window or check if root window is 3067 // XdndAware or has XdndProxy 3068 do 3069 { 3070 XTranslateCoordinates( m_pDisplay, aRoot, aParent, nX, nY, &nWinX, &nWinY, &aChild ); 3071 if( aChild != None ) 3072 { 3073 if( aChild == m_aCurrentDropWindow && aChild != aRoot && m_nCurrentProtocolVersion >= 0 ) 3074 { 3075 aParent = aChild; 3076 break; 3077 } 3078 nNewProtocolVersion = getXdndVersion( aChild, aNewProxy ); 3079 aParent = aChild; 3080 } 3081 } while( aChild != None && nNewProtocolVersion < 0 ); 3082 3083 aNewCurrentWindow = aParent; 3084 if( aNewCurrentWindow == aRoot ) 3085 { 3086 // no children, try root drop 3087 nNewProtocolVersion = getXdndVersion( aNewCurrentWindow, aNewProxy ); 3088 if( nNewProtocolVersion < 3 ) 3089 { 3090 aNewCurrentWindow = aNewProxy = None; 3091 nNewProtocolVersion = nXdndProtocolRevision; 3092 } 3093 } 3094 3095 3096 DragSourceDragEvent dsde; 3097 dsde.Source = static_cast< OWeakObject* >(this); 3098 dsde.DragSourceContext = new DragSourceContext( m_aDropWindow, m_nDragTimestamp, *this ); 3099 dsde.DragSource = static_cast< XDragSource* >(this); 3100 dsde.DropAction = nNewProtocolVersion >= 0 ? m_nUserDragAction : DNDConstants::ACTION_COPY; 3101 dsde.UserAction = nNewProtocolVersion >= 0 ? m_nUserDragAction : DNDConstants::ACTION_COPY; 3102 3103 ::std::hash_map< XLIB_Window, DropTargetEntry >::const_iterator it; 3104 if( aNewCurrentWindow != m_aDropWindow ) 3105 { 3106 #if OSL_DEBUG_LEVEL > 1 3107 fprintf( stderr, "drag left window 0x%lx (rev. %d), entered window 0x%lx (rev %d)\n", m_aDropWindow, m_nCurrentProtocolVersion, aNewCurrentWindow, nNewProtocolVersion ); 3108 #endif 3109 3110 if( m_aDropWindow != None ) 3111 { 3112 it = m_aDropTargets.find( m_aDropWindow ); 3113 if( it != m_aDropTargets.end() ) 3114 // shortcut for own drop targets 3115 { 3116 DropTargetEvent dte; 3117 dte.Source = static_cast< OWeakObject* >( it->second.m_pTarget ); 3118 aGuard.clear(); 3119 it->second.m_pTarget->dragExit( dte ); 3120 aGuard.reset(); 3121 } 3122 else 3123 { 3124 // send old drop target a XdndLeave 3125 XEvent aEvent; 3126 aEvent.type = ClientMessage; 3127 aEvent.xclient.display = m_pDisplay; 3128 aEvent.xclient.format = 32; 3129 aEvent.xclient.message_type = m_nXdndLeave; 3130 aEvent.xclient.window = m_aDropWindow; 3131 aEvent.xclient.data.l[0] = m_aWindow; 3132 aEvent.xclient.data.l[1] = 0; 3133 XSendEvent( m_pDisplay, m_aDropProxy, False, NoEventMask, &aEvent ); 3134 } 3135 if( xListener.is() ) 3136 { 3137 aGuard.clear(); 3138 xListener->dragExit( dsde ); 3139 aGuard.reset(); 3140 } 3141 } 3142 3143 m_nCurrentProtocolVersion = nNewProtocolVersion; 3144 m_aDropWindow = aNewCurrentWindow; 3145 m_aDropProxy = aNewProxy != None ? aNewProxy : m_aDropWindow; 3146 3147 it = m_aDropTargets.find( m_aDropWindow ); 3148 if( it != m_aDropTargets.end() && ! it->second.m_pTarget->m_bActive ) 3149 m_aDropProxy = None; 3150 3151 if( m_aDropProxy != None && xListener.is() ) 3152 { 3153 aGuard.clear(); 3154 xListener->dragEnter( dsde ); 3155 aGuard.reset(); 3156 } 3157 // send XdndEnter 3158 if( m_aDropProxy != None && m_nCurrentProtocolVersion >= 0 ) 3159 { 3160 it = m_aDropTargets.find( m_aDropWindow ); 3161 if( it != m_aDropTargets.end() ) 3162 { 3163 XTranslateCoordinates( m_pDisplay, aRoot, m_aDropWindow, nX, nY, &nWinX, &nWinY, &aChild ); 3164 DropTargetDragEnterEvent dtde; 3165 dtde.Source = static_cast< OWeakObject* >( it->second.m_pTarget ); 3166 dtde.Context = new DropTargetDragContext( m_aCurrentDropWindow, m_nDropTimestamp, *this ); 3167 dtde.LocationX = nWinX; 3168 dtde.LocationY = nWinY; 3169 dtde.DropAction = m_nUserDragAction; 3170 dtde.SourceActions = m_nSourceActions; 3171 dtde.SupportedDataFlavors = m_xDragSourceTransferable->getTransferDataFlavors(); 3172 aGuard.clear(); 3173 it->second.m_pTarget->dragEnter( dtde ); 3174 aGuard.reset(); 3175 } 3176 else 3177 { 3178 XEvent aEvent; 3179 aEvent.type = ClientMessage; 3180 aEvent.xclient.display = m_pDisplay; 3181 aEvent.xclient.format = 32; 3182 aEvent.xclient.message_type = m_nXdndEnter; 3183 aEvent.xclient.window = m_aDropWindow; 3184 aEvent.xclient.data.l[0] = m_aWindow; 3185 aEvent.xclient.data.l[1] = m_nCurrentProtocolVersion << 24; 3186 memset( aEvent.xclient.data.l + 2, 0, sizeof( long )*3 ); 3187 // fill in data types 3188 ::std::list< Atom > aConversions; 3189 getNativeTypeList( m_aDragFlavors, aConversions, m_nXdndSelection ); 3190 if( aConversions.size() > 3 ) 3191 aEvent.xclient.data.l[1] |= 1; 3192 ::std::list< Atom >::const_iterator type_it = aConversions.begin(); 3193 for( int i = 0; type_it != aConversions.end() && i < 3; i++, ++type_it ) 3194 aEvent.xclient.data.l[i+2] = *type_it; 3195 XSendEvent( m_pDisplay, m_aDropProxy, False, NoEventMask, &aEvent ); 3196 } 3197 } 3198 m_nNoPosX = m_nNoPosY = m_nNoPosWidth = m_nNoPosHeight = 0; 3199 } 3200 else if( m_aDropProxy != None && xListener.is() ) 3201 { 3202 aGuard.clear(); 3203 // drag over for XdndAware windows comes when receiving XdndStatus 3204 xListener->dragOver( dsde ); 3205 } 3206 } 3207 3208 // ------------------------------------------------------------------------ 3209 3210 void SelectionManager::startDrag( 3211 const DragGestureEvent& trigger, 3212 sal_Int8 sourceActions, 3213 sal_Int32, 3214 sal_Int32, 3215 const css::uno::Reference< XTransferable >& transferable, 3216 const css::uno::Reference< XDragSourceListener >& listener 3217 ) throw() 3218 { 3219 #if OSL_DEBUG_LEVEL > 1 3220 fprintf( stderr, "startDrag( sourceActions = %x )\n", (int)sourceActions ); 3221 #endif 3222 3223 DragSourceDropEvent aDragFailedEvent; 3224 aDragFailedEvent.Source = static_cast< OWeakObject* >(this); 3225 aDragFailedEvent.DragSource = static_cast< XDragSource* >(this); 3226 aDragFailedEvent.DragSourceContext = new DragSourceContext( None, CurrentTime, *this ); 3227 aDragFailedEvent.DropAction = DNDConstants::ACTION_NONE; 3228 aDragFailedEvent.DropSuccess = sal_False; 3229 3230 if( m_aDragRunning.check() ) 3231 { 3232 if( listener.is() ) 3233 listener->dragDropEnd( aDragFailedEvent ); 3234 3235 #if OSL_DEBUG_LEVEL > 1 3236 fprintf( stderr, "*** ERROR *** second drag and drop started.\n" ); 3237 if( m_xDragSourceListener.is() ) 3238 fprintf( stderr, "*** ERROR *** drag source listener already set.\n" ); 3239 else 3240 fprintf( stderr, "*** ERROR *** drag thread already running.\n" ); 3241 #endif 3242 return; 3243 } 3244 3245 SalFrame* pCaptureFrame = NULL; 3246 3247 { 3248 ClearableMutexGuard aGuard(m_aMutex); 3249 3250 // first get the current pointer position and the window that 3251 // the pointer is located in. since said window should be one 3252 // of our DropTargets at the time of executeDrag we can use 3253 // them for a start 3254 XLIB_Window aRoot, aParent, aChild; 3255 int root_x, root_y, win_x, win_y; 3256 unsigned int mask; 3257 3258 ::std::hash_map< XLIB_Window, DropTargetEntry >::const_iterator it; 3259 it = m_aDropTargets.begin(); 3260 while( it != m_aDropTargets.end() ) 3261 { 3262 if( XQueryPointer( m_pDisplay, it->second.m_aRootWindow, 3263 &aRoot, &aParent, 3264 &root_x, &root_y, 3265 &win_x, &win_y, 3266 &mask ) ) 3267 { 3268 aParent = it->second.m_aRootWindow; 3269 break; 3270 } 3271 ++it; 3272 } 3273 3274 // don't start DnD if there is none of our windows on the same screen as 3275 // the pointer or if no mouse button is pressed 3276 if( it == m_aDropTargets.end() || (mask & (Button1Mask|Button2Mask|Button3Mask)) == 0 ) 3277 { 3278 aGuard.clear(); 3279 if( listener.is() ) 3280 listener->dragDropEnd( aDragFailedEvent ); 3281 return; 3282 } 3283 3284 // try to find which of our drop targets is the drag source 3285 // if that drop target is deregistered we should stop executing 3286 // the drag (actually this is a poor substitute for an "endDrag" 3287 // method ). 3288 m_aDragSourceWindow = None; 3289 aParent = aRoot = it->second.m_aRootWindow; 3290 do 3291 { 3292 XTranslateCoordinates( m_pDisplay, aRoot, aParent, root_x, root_y, &win_x, &win_y, &aChild ); 3293 if( aChild != None && m_aDropTargets.find( aChild ) != m_aDropTargets.end() ) 3294 { 3295 m_aDragSourceWindow = aChild; 3296 #if OSL_DEBUG_LEVEL > 1 3297 fprintf( stderr, "found drag source window 0x%lx\n", m_aDragSourceWindow ); 3298 #endif 3299 break; 3300 } 3301 aParent = aChild; 3302 } while( aChild != None ); 3303 3304 3305 #if OSL_DEBUG_LEVEL > 1 3306 fprintf( stderr, "try to grab pointer ... " ); 3307 #endif 3308 int nPointerGrabSuccess = 3309 XGrabPointer( m_pDisplay, it->second.m_aRootWindow, True, 3310 DRAG_EVENT_MASK, 3311 GrabModeAsync, GrabModeAsync, 3312 None, 3313 None, 3314 CurrentTime ); 3315 /* if we could not grab the pointer here, there is a chance 3316 that the pointer is grabbed by the other vcl display (the main loop) 3317 so let's break that grab an reset it later 3318 3319 remark: this whole code should really be molten into normal vcl so only 3320 one display is used .... 3321 */ 3322 if( nPointerGrabSuccess != GrabSuccess ) 3323 { 3324 vos::IMutex& rSolarMutex( Application::GetSolarMutex() ); 3325 if( rSolarMutex.tryToAcquire() ) 3326 { 3327 pCaptureFrame = GetX11SalData()->GetDisplay()->GetCaptureFrame(); 3328 if( pCaptureFrame ) 3329 { 3330 GetX11SalData()->GetDisplay()->CaptureMouse( NULL ); 3331 nPointerGrabSuccess = 3332 XGrabPointer( m_pDisplay, it->second.m_aRootWindow, True, 3333 DRAG_EVENT_MASK, 3334 GrabModeAsync, GrabModeAsync, 3335 None, 3336 None, 3337 CurrentTime ); 3338 } 3339 } 3340 } 3341 #if OSL_DEBUG_LEVEL > 1 3342 fprintf( stderr, "%d\n", nPointerGrabSuccess ); 3343 #endif 3344 #if OSL_DEBUG_LEVEL > 1 3345 fprintf( stderr, "try to grab keyboard ... " ); 3346 #endif 3347 int nKeyboardGrabSuccess = 3348 XGrabKeyboard( m_pDisplay, it->second.m_aRootWindow, True, 3349 GrabModeAsync, GrabModeAsync, CurrentTime ); 3350 #if OSL_DEBUG_LEVEL > 1 3351 fprintf( stderr, "%d\n", nKeyboardGrabSuccess ); 3352 #endif 3353 if( nPointerGrabSuccess != GrabSuccess || nKeyboardGrabSuccess != GrabSuccess ) 3354 { 3355 if( nPointerGrabSuccess == GrabSuccess ) 3356 XUngrabPointer( m_pDisplay, CurrentTime ); 3357 if( nKeyboardGrabSuccess == GrabSuccess ) 3358 XUngrabKeyboard( m_pDisplay, CurrentTime ); 3359 XFlush( m_pDisplay ); 3360 aGuard.clear(); 3361 if( listener.is() ) 3362 listener->dragDropEnd( aDragFailedEvent ); 3363 if( pCaptureFrame ) 3364 { 3365 vos::IMutex& rSolarMutex( Application::GetSolarMutex() ); 3366 if( rSolarMutex.tryToAcquire() ) 3367 GetX11SalData()->GetDisplay()->CaptureMouse( pCaptureFrame ); 3368 #if OSL_DEBUG_LEVEL > 0 3369 else 3370 OSL_ENSURE( 0, "failed to acquire SolarMutex to reset capture frame" ); 3371 #endif 3372 } 3373 return; 3374 } 3375 3376 m_xDragSourceTransferable = transferable; 3377 m_xDragSourceListener = listener; 3378 m_aDragFlavors = transferable->getTransferDataFlavors(); 3379 m_aCurrentCursor = None; 3380 3381 requestOwnership( m_nXdndSelection ); 3382 3383 ::std::list< Atom > aConversions; 3384 ::std::list< Atom >::const_iterator type_it; 3385 getNativeTypeList( m_aDragFlavors, aConversions, m_nXdndSelection ); 3386 3387 int nTypes = aConversions.size(); 3388 Atom* pTypes = (Atom*)alloca( sizeof(Atom)*nTypes ); 3389 type_it = aConversions.begin(); 3390 for( int n = 0; n < nTypes; n++, ++type_it ) 3391 pTypes[n] = *type_it; 3392 3393 XChangeProperty( m_pDisplay, m_aWindow, m_nXdndTypeList, XA_ATOM, 32, PropModeReplace, (unsigned char*)pTypes, nTypes ); 3394 3395 m_nSourceActions = sourceActions | DNDConstants::ACTION_DEFAULT; 3396 m_nUserDragAction = DNDConstants::ACTION_MOVE & m_nSourceActions; 3397 if( ! m_nUserDragAction ) 3398 m_nUserDragAction = DNDConstants::ACTION_COPY & m_nSourceActions; 3399 if( ! m_nUserDragAction ) 3400 m_nUserDragAction = DNDConstants::ACTION_LINK & m_nSourceActions; 3401 m_nTargetAcceptAction = DNDConstants::ACTION_DEFAULT; 3402 m_bDropSent = false; 3403 m_bDropSuccess = false; 3404 m_bWaitingForPrimaryConversion = false; 3405 m_nDragButton = Button1; // default to left button 3406 com::sun::star::awt::MouseEvent aEvent; 3407 if( trigger.Event >>= aEvent ) 3408 { 3409 if( aEvent.Buttons & MouseButton::LEFT ) 3410 m_nDragButton = Button1; 3411 else if( aEvent.Buttons & MouseButton::RIGHT ) 3412 m_nDragButton = Button3; 3413 else if( aEvent.Buttons & MouseButton::MIDDLE ) 3414 m_nDragButton = Button2; 3415 } 3416 #if OSL_DEBUG_LEVEL > 1 3417 fprintf( stderr, "m_nUserDragAction = %x\n", (int)m_nUserDragAction ); 3418 #endif 3419 updateDragWindow( root_x, root_y, aRoot ); 3420 m_nUserDragAction = ~0; 3421 updateDragAction( mask ); 3422 } 3423 3424 m_aDragRunning.set(); 3425 m_aDragExecuteThread = osl_createSuspendedThread( call_SelectionManager_runDragExecute, this ); 3426 if( m_aDragExecuteThread ) 3427 osl_resumeThread( m_aDragExecuteThread ); 3428 else 3429 { 3430 #if OSL_DEBUG_LEVEL > 1 3431 fprintf( stderr, "osl_createSuspendedThread failed for drag execute\n" ); 3432 #endif 3433 m_xDragSourceListener.clear(); 3434 m_xDragSourceTransferable.clear(); 3435 3436 m_bDropSent = false; 3437 m_bDropSuccess = false; 3438 m_bWaitingForPrimaryConversion = false; 3439 m_aDropWindow = None; 3440 m_aDropProxy = None; 3441 m_nCurrentProtocolVersion = nXdndProtocolRevision; 3442 m_nNoPosX = 0; 3443 m_nNoPosY = 0; 3444 m_nNoPosWidth = 0; 3445 m_nNoPosHeight = 0; 3446 m_aCurrentCursor = None; 3447 3448 XUngrabPointer( m_pDisplay, CurrentTime ); 3449 XUngrabKeyboard( m_pDisplay, CurrentTime ); 3450 XFlush( m_pDisplay ); 3451 3452 if( pCaptureFrame ) 3453 { 3454 vos::IMutex& rSolarMutex( Application::GetSolarMutex() ); 3455 if( rSolarMutex.tryToAcquire() ) 3456 GetX11SalData()->GetDisplay()->CaptureMouse( pCaptureFrame ); 3457 #if OSL_DEBUG_LEVEL > 0 3458 else 3459 OSL_ENSURE( 0, "failed to acquire SolarMutex to reset capture frame" ); 3460 #endif 3461 } 3462 3463 m_aDragRunning.reset(); 3464 3465 if( listener.is() ) 3466 listener->dragDropEnd( aDragFailedEvent ); 3467 } 3468 } 3469 3470 void SelectionManager::runDragExecute( void* pThis ) 3471 { 3472 SelectionManager* This = (SelectionManager*)pThis; 3473 This->dragDoDispatch(); 3474 } 3475 3476 void SelectionManager::dragDoDispatch() 3477 { 3478 3479 // do drag 3480 // m_xDragSourceListener will be cleared on finished drop 3481 #if OSL_DEBUG_LEVEL > 1 3482 fprintf( stderr, "begin executeDrag dispatching\n" ); 3483 #endif 3484 TimeValue aTVal; 3485 aTVal.Seconds = 0; 3486 aTVal.Nanosec = 200000000; 3487 oslThread aThread = m_aDragExecuteThread; 3488 while( m_xDragSourceListener.is() && ( ! m_bDropSent || time(NULL)-m_nDropTimeout < 5 ) && osl_scheduleThread( aThread ) ) 3489 { 3490 // let the thread in the run method do the dispatching 3491 // just look occasionally here whether drop timed out or is completed 3492 osl_waitThread( &aTVal ); 3493 } 3494 #if OSL_DEBUG_LEVEL > 1 3495 fprintf( stderr, "end executeDrag dispatching\n" ); 3496 #endif 3497 { 3498 ClearableMutexGuard aGuard(m_aMutex); 3499 3500 css::uno::Reference< XDragSourceListener > xListener( m_xDragSourceListener ); 3501 css::uno::Reference< XTransferable > xTransferable( m_xDragSourceTransferable ); 3502 m_xDragSourceListener.clear(); 3503 m_xDragSourceTransferable.clear(); 3504 3505 DragSourceDropEvent dsde; 3506 dsde.Source = static_cast< OWeakObject* >(this); 3507 dsde.DragSourceContext = new DragSourceContext( m_aDropWindow, m_nDragTimestamp, *this ); 3508 dsde.DragSource = static_cast< XDragSource* >(this); 3509 dsde.DropAction = DNDConstants::ACTION_NONE; 3510 dsde.DropSuccess = sal_False; 3511 3512 // cleanup after drag 3513 if( m_bWaitingForPrimaryConversion ) 3514 getAdaptor( XA_PRIMARY )->clearTransferable(); 3515 3516 m_bDropSent = false; 3517 m_bDropSuccess = false; 3518 m_bWaitingForPrimaryConversion = false; 3519 m_aDropWindow = None; 3520 m_aDropProxy = None; 3521 m_nCurrentProtocolVersion = nXdndProtocolRevision; 3522 m_nNoPosX = 0; 3523 m_nNoPosY = 0; 3524 m_nNoPosWidth = 0; 3525 m_nNoPosHeight = 0; 3526 m_aCurrentCursor = None; 3527 3528 XUngrabPointer( m_pDisplay, CurrentTime ); 3529 XUngrabKeyboard( m_pDisplay, CurrentTime ); 3530 XFlush( m_pDisplay ); 3531 3532 m_aDragExecuteThread = NULL; 3533 m_aDragRunning.reset(); 3534 3535 aGuard.clear(); 3536 if( xListener.is() ) 3537 { 3538 xTransferable.clear(); 3539 xListener->dragDropEnd( dsde ); 3540 } 3541 } 3542 osl_destroyThread( aThread ); 3543 } 3544 3545 /* 3546 * XDragSourceContext 3547 */ 3548 3549 sal_Int32 SelectionManager::getCurrentCursor() 3550 { 3551 return m_aCurrentCursor; 3552 } 3553 3554 // ------------------------------------------------------------------------ 3555 3556 void SelectionManager::setCursor( sal_Int32 cursor, XLIB_Window aDropWindow, XLIB_Time ) 3557 { 3558 MutexGuard aGuard( m_aMutex ); 3559 if( aDropWindow == m_aDropWindow && XLIB_Cursor(cursor) != m_aCurrentCursor ) 3560 { 3561 if( m_xDragSourceListener.is() && ! m_bDropSent ) 3562 { 3563 m_aCurrentCursor = cursor; 3564 XChangeActivePointerGrab( m_pDisplay, DRAG_EVENT_MASK, cursor, CurrentTime ); 3565 XFlush( m_pDisplay ); 3566 } 3567 } 3568 } 3569 3570 // ------------------------------------------------------------------------ 3571 3572 void SelectionManager::setImage( sal_Int32, XLIB_Window, XLIB_Time ) 3573 { 3574 } 3575 3576 // ------------------------------------------------------------------------ 3577 3578 void SelectionManager::transferablesFlavorsChanged() 3579 { 3580 MutexGuard aGuard(m_aMutex); 3581 3582 m_aDragFlavors = m_xDragSourceTransferable->getTransferDataFlavors(); 3583 int i; 3584 3585 std::list< Atom > aConversions; 3586 std::list< Atom >::const_iterator type_it; 3587 3588 getNativeTypeList( m_aDragFlavors, aConversions, m_nXdndSelection ); 3589 3590 int nTypes = aConversions.size(); 3591 Atom* pTypes = (Atom*)alloca( sizeof(Atom)*aConversions.size() ); 3592 for( i = 0, type_it = aConversions.begin(); type_it != aConversions.end(); ++type_it, i++ ) 3593 pTypes[i] = *type_it; 3594 XChangeProperty( m_pDisplay, m_aWindow, m_nXdndTypeList, XA_ATOM, 32, PropModeReplace, (unsigned char*)pTypes, nTypes ); 3595 3596 if( m_aCurrentDropWindow != None && m_nCurrentProtocolVersion >= 0 ) 3597 { 3598 // send synthetic leave and enter events 3599 3600 XEvent aEvent; 3601 3602 aEvent.type = ClientMessage; 3603 aEvent.xclient.display = m_pDisplay; 3604 aEvent.xclient.format = 32; 3605 aEvent.xclient.window = m_aDropWindow; 3606 aEvent.xclient.data.l[0] = m_aWindow; 3607 3608 aEvent.xclient.message_type = m_nXdndLeave; 3609 aEvent.xclient.data.l[1] = 0; 3610 XSendEvent( m_pDisplay, m_aDropProxy, False, NoEventMask, &aEvent ); 3611 3612 aEvent.xclient.message_type = m_nXdndEnter; 3613 aEvent.xclient.data.l[1] = m_nCurrentProtocolVersion << 24; 3614 memset( aEvent.xclient.data.l + 2, 0, sizeof( long )*3 ); 3615 // fill in data types 3616 if( nTypes > 3 ) 3617 aEvent.xclient.data.l[1] |= 1; 3618 for( int j = 0; j < nTypes && j < 3; j++ ) 3619 aEvent.xclient.data.l[j+2] = pTypes[j]; 3620 3621 XSendEvent( m_pDisplay, m_aDropProxy, False, NoEventMask, &aEvent ); 3622 } 3623 } 3624 3625 /* 3626 * dispatch loop 3627 */ 3628 3629 // ------------------------------------------------------------------------ 3630 3631 bool SelectionManager::handleXEvent( XEvent& rEvent ) 3632 { 3633 /* 3634 * since we are XConnectionListener to a second X display 3635 * to get client messages it is essential not to dispatch 3636 * events twice that we get on both connections 3637 * 3638 * #95201# between dispatching ButtonPress and startDrag 3639 * the user can already have released the mouse. The ButtonRelease 3640 * will then be dispatched in VCLs queue and never turn up here. 3641 * Which is not so good, since startDrag will XGrabPointer and 3642 * XGrabKeyboard -> solid lock. 3643 */ 3644 if( rEvent.xany.display != m_pDisplay 3645 && rEvent.type != ClientMessage 3646 && rEvent.type != ButtonPress 3647 && rEvent.type != ButtonRelease 3648 ) 3649 return false; 3650 3651 bool bHandled = false; 3652 switch (rEvent.type) 3653 { 3654 case SelectionClear: 3655 { 3656 ClearableMutexGuard aGuard(m_aMutex); 3657 #if OSL_DEBUG_LEVEL > 1 3658 fprintf( stderr, "SelectionClear for selection %s\n", 3659 OUStringToOString( getString( rEvent.xselectionclear.selection ), RTL_TEXTENCODING_ISO_8859_1 ).getStr() 3660 ); 3661 #endif 3662 SelectionAdaptor* pAdaptor = getAdaptor( rEvent.xselectionclear.selection ); 3663 std::hash_map< Atom, Selection* >::iterator it( m_aSelections.find( rEvent.xselectionclear.selection ) ); 3664 if( it != m_aSelections.end() ) 3665 it->second->m_bOwner = false; 3666 aGuard.clear(); 3667 if ( pAdaptor ) 3668 pAdaptor->clearTransferable(); 3669 } 3670 break; 3671 3672 case SelectionRequest: 3673 bHandled = handleSelectionRequest( rEvent.xselectionrequest ); 3674 break; 3675 case PropertyNotify: 3676 if( rEvent.xproperty.window == m_aWindow || 3677 rEvent.xproperty.window == m_aCurrentDropWindow 3678 ) 3679 bHandled = handleReceivePropertyNotify( rEvent.xproperty ); 3680 else 3681 bHandled = handleSendPropertyNotify( rEvent.xproperty ); 3682 break; 3683 case SelectionNotify: 3684 bHandled = handleSelectionNotify( rEvent.xselection ); 3685 break; 3686 case ClientMessage: 3687 // messages from drag target 3688 if( rEvent.xclient.message_type == m_nXdndStatus || 3689 rEvent.xclient.message_type == m_nXdndFinished ) 3690 bHandled = handleDragEvent( rEvent ); 3691 // messages from drag source 3692 else if( 3693 rEvent.xclient.message_type == m_nXdndEnter || 3694 rEvent.xclient.message_type == m_nXdndLeave || 3695 rEvent.xclient.message_type == m_nXdndPosition || 3696 rEvent.xclient.message_type == m_nXdndDrop 3697 ) 3698 bHandled = handleDropEvent( rEvent.xclient ); 3699 break; 3700 case EnterNotify: 3701 case LeaveNotify: 3702 case MotionNotify: 3703 case ButtonPress: 3704 case ButtonRelease: 3705 case XLIB_KeyPress: 3706 case KeyRelease: 3707 bHandled = handleDragEvent( rEvent ); 3708 break; 3709 default: 3710 ; 3711 } 3712 return bHandled; 3713 } 3714 3715 // ------------------------------------------------------------------------ 3716 3717 void SelectionManager::dispatchEvent( int millisec ) 3718 { 3719 pollfd aPollFD; 3720 XEvent event; 3721 3722 // query socket handle to poll on 3723 aPollFD.fd = ConnectionNumber( m_pDisplay ); 3724 aPollFD.events = POLLIN; 3725 aPollFD.revents = 0; 3726 3727 // wait for activity (outside the xlib) 3728 if( poll( &aPollFD, 1, millisec ) > 0 ) 3729 { 3730 // now acquire the mutex to prevent other threads 3731 // from using the same X connection 3732 ResettableMutexGuard aGuard(m_aMutex); 3733 3734 // prevent that another thread already ate the input 3735 // this can happen if e.g. another thread does 3736 // an X request getting a response. the response 3737 // would be removed from the queue and we would end up 3738 // with an empty socket here 3739 if( poll( &aPollFD, 1, 0 ) > 0 ) 3740 { 3741 int nPending = 1; 3742 while( nPending ) 3743 { 3744 nPending = XPending( m_pDisplay ); 3745 if( nPending ) 3746 { 3747 XNextEvent( m_pDisplay, &event ); 3748 aGuard.clear(); 3749 handleXEvent( event ); 3750 aGuard.reset(); 3751 } 3752 } 3753 } 3754 } 3755 } 3756 3757 // ------------------------------------------------------------------------ 3758 3759 void SelectionManager::run( void* pThis ) 3760 { 3761 #if OSL_DEBUG_LEVEL > 1 3762 fprintf(stderr, "SelectionManager::run\n" ); 3763 #endif 3764 // dispatch until the cows come home 3765 3766 SelectionManager* This = (SelectionManager*)pThis; 3767 3768 timeval aLast; 3769 gettimeofday( &aLast, 0 ); 3770 3771 css::uno::Reference< XMultiServiceFactory > xFact( ::comphelper::getProcessServiceFactory() ); 3772 if( xFact.is() ) 3773 { 3774 css::uno::Reference< XDesktop > xDesktop( xFact->createInstance( ::rtl::OUString::createFromAscii( "com.sun.star.frame.Desktop" ) ), UNO_QUERY ); 3775 if( xDesktop.is() ) 3776 xDesktop->addTerminateListener(This); 3777 } 3778 3779 while( osl_scheduleThread(This->m_aThread) ) 3780 { 3781 This->dispatchEvent( 1000 ); 3782 3783 timeval aNow; 3784 gettimeofday( &aNow, 0 ); 3785 3786 if( (aNow.tv_sec - aLast.tv_sec) > 0 ) 3787 { 3788 ClearableMutexGuard aGuard(This->m_aMutex); 3789 std::list< std::pair< SelectionAdaptor*, css::uno::Reference< XInterface > > > aChangeList; 3790 3791 for( std::hash_map< Atom, Selection* >::iterator it = This->m_aSelections.begin(); it != This->m_aSelections.end(); ++it ) 3792 { 3793 if( it->first != This->m_nXdndSelection && ! it->second->m_bOwner ) 3794 { 3795 XLIB_Window aOwner = XGetSelectionOwner( This->m_pDisplay, it->first ); 3796 if( aOwner != it->second->m_aLastOwner ) 3797 { 3798 it->second->m_aLastOwner = aOwner; 3799 std::pair< SelectionAdaptor*, css::uno::Reference< XInterface > > 3800 aKeep( it->second->m_pAdaptor, it->second->m_pAdaptor->getReference() ); 3801 aChangeList.push_back( aKeep ); 3802 } 3803 } 3804 } 3805 aGuard.clear(); 3806 while( aChangeList.begin() != aChangeList.end() ) 3807 { 3808 aChangeList.front().first->fireContentsChanged(); 3809 aChangeList.pop_front(); 3810 } 3811 aLast = aNow; 3812 } 3813 } 3814 #if OSL_DEBUG_LEVEL > 1 3815 fprintf(stderr, "SelectionManager::run end\n" ); 3816 #endif 3817 } 3818 3819 void SelectionManager::shutdown() throw() 3820 { 3821 ResettableMutexGuard aGuard(m_aMutex); 3822 if( m_bShutDown ) 3823 { 3824 return; 3825 } 3826 m_bShutDown = true; 3827 // stop dispatching 3828 if( m_aThread ) 3829 { 3830 osl_terminateThread( m_aThread ); 3831 /* 3832 * Allow thread to finish before app exits to avoid pulling the carpet 3833 * out from under it if pasting is occuring during shutdown 3834 * 3835 * a) allow it to have the Mutex and 3836 * b) reschedule to allow it to complete callbacks to any 3837 * Application::GetSolarMutex protected regions, etc. e.g. 3838 * TransferableHelper::getTransferDataFlavors (via 3839 * SelectionManager::handleSelectionRequest) which it might 3840 * currently be trying to enter. 3841 * 3842 * Otherwise the thread may be left still waiting on a GlobalMutex 3843 * when that gets destroyed, letting the thread blow up and die 3844 * when enters the section in a now dead OOo instance. 3845 */ 3846 aGuard.clear(); 3847 while (osl_isThreadRunning(m_aThread)) 3848 { 3849 vos::OGuard guard2(Application::GetSolarMutex()); 3850 Application::Reschedule(); 3851 } 3852 osl_joinWithThread( m_aThread ); 3853 osl_destroyThread( m_aThread ); 3854 m_aThread = NULL; 3855 aGuard.reset(); 3856 } 3857 m_xDisplayConnection->removeEventHandler( Any(), this ); 3858 m_xDisplayConnection.clear(); 3859 } 3860 3861 // ------------------------------------------------------------------------ 3862 3863 sal_Bool SelectionManager::handleEvent( const Any& event ) throw() 3864 { 3865 Sequence< sal_Int8 > aSeq; 3866 if( (event >>= aSeq) ) 3867 { 3868 XEvent* pEvent = (XEvent*)aSeq.getArray(); 3869 XLIB_Time nTimestamp = CurrentTime; 3870 if( pEvent->type == ButtonPress || pEvent->type == ButtonRelease ) 3871 nTimestamp = pEvent->xbutton.time; 3872 else if( pEvent->type == XLIB_KeyPress || pEvent->type == KeyRelease ) 3873 nTimestamp = pEvent->xkey.time; 3874 else if( pEvent->type == MotionNotify ) 3875 nTimestamp = pEvent->xmotion.time; 3876 else if( pEvent->type == PropertyNotify ) 3877 nTimestamp = pEvent->xproperty.time; 3878 3879 if( nTimestamp != CurrentTime ) 3880 { 3881 MutexGuard aGuard(m_aMutex); 3882 3883 m_nSelectionTimestamp = nTimestamp; 3884 } 3885 3886 return sal_Bool( handleXEvent( *pEvent ) ); 3887 } 3888 else 3889 { 3890 #if OSL_DEBUG_LEVEL > 1 3891 fprintf( stderr, "SelectionManager got downing event\n" ); 3892 #endif 3893 shutdown(); 3894 } 3895 return sal_True; 3896 } 3897 3898 void SAL_CALL SelectionManager::disposing( const ::com::sun::star::lang::EventObject& ) 3899 throw( ::com::sun::star::uno::RuntimeException ) 3900 { 3901 } 3902 3903 void SAL_CALL SelectionManager::queryTermination( const ::com::sun::star::lang::EventObject& ) 3904 throw( ::com::sun::star::frame::TerminationVetoException, ::com::sun::star::uno::RuntimeException ) 3905 { 3906 } 3907 3908 /* 3909 * To be safe, shutdown needs to be called before the ~SfxApplication is called, waiting until 3910 * the downing event can be too late if paste are requested during shutdown and ~SfxApplication 3911 * has been called before vcl is shutdown 3912 */ 3913 void SAL_CALL SelectionManager::notifyTermination( const ::com::sun::star::lang::EventObject& rEvent ) 3914 throw( ::com::sun::star::uno::RuntimeException ) 3915 { 3916 css::uno::Reference< XDesktop > xDesktop( rEvent.Source, UNO_QUERY ); 3917 if( xDesktop.is() == sal_True ) 3918 xDesktop->removeTerminateListener( this ); 3919 #if OSL_DEBUG_LEVEL > 1 3920 fprintf( stderr, "SelectionManager got app termination event\n" ); 3921 #endif 3922 shutdown(); 3923 } 3924 3925 // ------------------------------------------------------------------------ 3926 3927 void SelectionManager::registerHandler( Atom selection, SelectionAdaptor& rAdaptor ) 3928 { 3929 MutexGuard aGuard(m_aMutex); 3930 3931 Selection* pNewSelection = new Selection(); 3932 pNewSelection->m_pAdaptor = &rAdaptor; 3933 pNewSelection->m_aAtom = selection; 3934 m_aSelections[ selection ] = pNewSelection; 3935 } 3936 3937 // ------------------------------------------------------------------------ 3938 3939 void SelectionManager::deregisterHandler( Atom selection ) 3940 { 3941 MutexGuard aGuard(m_aMutex); 3942 3943 ::std::hash_map< Atom, Selection* >::iterator it = 3944 m_aSelections.find( selection ); 3945 if( it != m_aSelections.end() ) 3946 { 3947 delete it->second->m_pPixmap; 3948 delete it->second; 3949 m_aSelections.erase( it ); 3950 } 3951 } 3952 3953 // ------------------------------------------------------------------------ 3954 3955 static bool bWasError = false; 3956 3957 extern "C" 3958 { 3959 int local_xerror_handler(Display* , XErrorEvent*) 3960 { 3961 bWasError = true; 3962 return 0; 3963 } 3964 typedef int(*xerror_hdl_t)(Display*,XErrorEvent*); 3965 } 3966 3967 void SelectionManager::registerDropTarget( XLIB_Window aWindow, DropTarget* pTarget ) 3968 { 3969 MutexGuard aGuard(m_aMutex); 3970 3971 // sanity check 3972 ::std::hash_map< XLIB_Window, DropTargetEntry >::const_iterator it = 3973 m_aDropTargets.find( aWindow ); 3974 if( it != m_aDropTargets.end() ) 3975 OSL_ASSERT( "attempt to register window as drop target twice" ); 3976 else if( aWindow && m_pDisplay ) 3977 { 3978 DropTargetEntry aEntry( pTarget ); 3979 bWasError=false; 3980 /* #i100000# ugly workaround: gtk sets its own XErrorHandler which is not suitable for us 3981 unfortunately XErrorHandler is not per display, so this is just and ugly hack 3982 Need to remove separate display and integrate clipboard/dnd into vcl's unx code ASAP 3983 */ 3984 xerror_hdl_t pOldHandler = XSetErrorHandler( local_xerror_handler ); 3985 XSelectInput( m_pDisplay, aWindow, PropertyChangeMask ); 3986 if( ! bWasError ) 3987 { 3988 // set XdndAware 3989 XChangeProperty( m_pDisplay, aWindow, m_nXdndAware, XA_ATOM, 32, PropModeReplace, (unsigned char*)&nXdndProtocolRevision, 1 ); 3990 if( ! bWasError ) 3991 { 3992 // get root window of window (in 99.999% of all cases this will be 3993 // DefaultRootWindow( m_pDisplay ) 3994 int x, y; 3995 unsigned int w, h, bw, d; 3996 XGetGeometry( m_pDisplay, aWindow, &aEntry.m_aRootWindow, 3997 &x, &y, &w, &h, &bw, &d ); 3998 } 3999 } 4000 XSetErrorHandler( pOldHandler ); 4001 if(bWasError) 4002 return; 4003 m_aDropTargets[ aWindow ] = aEntry; 4004 } 4005 else 4006 OSL_ASSERT( "attempt to register None as drop target" ); 4007 } 4008 4009 // ------------------------------------------------------------------------ 4010 4011 void SelectionManager::deregisterDropTarget( XLIB_Window aWindow ) 4012 { 4013 ClearableMutexGuard aGuard(m_aMutex); 4014 4015 m_aDropTargets.erase( aWindow ); 4016 if( aWindow == m_aDragSourceWindow && m_aDragRunning.check() ) 4017 { 4018 // abort drag 4019 std::hash_map< XLIB_Window, DropTargetEntry >::const_iterator it = 4020 m_aDropTargets.find( m_aDropWindow ); 4021 if( it != m_aDropTargets.end() ) 4022 { 4023 DropTargetEvent dte; 4024 dte.Source = static_cast< OWeakObject* >( it->second.m_pTarget ); 4025 aGuard.clear(); 4026 it->second.m_pTarget->dragExit( dte ); 4027 } 4028 else if( m_aDropProxy != None && m_nCurrentProtocolVersion >= 0 ) 4029 { 4030 // send XdndLeave 4031 XEvent aEvent; 4032 aEvent.type = ClientMessage; 4033 aEvent.xclient.display = m_pDisplay; 4034 aEvent.xclient.format = 32; 4035 aEvent.xclient.message_type = m_nXdndLeave; 4036 aEvent.xclient.window = m_aDropWindow; 4037 aEvent.xclient.data.l[0] = m_aWindow; 4038 memset( aEvent.xclient.data.l+1, 0, sizeof(long)*4); 4039 m_aDropWindow = m_aDropProxy = None; 4040 XSendEvent( m_pDisplay, m_aDropProxy, False, NoEventMask, &aEvent ); 4041 } 4042 // notify the listener 4043 DragSourceDropEvent dsde; 4044 dsde.Source = static_cast< OWeakObject* >(this); 4045 dsde.DragSourceContext = new DragSourceContext( m_aDropWindow, m_nDragTimestamp, *this ); 4046 dsde.DragSource = static_cast< XDragSource* >(this); 4047 dsde.DropAction = DNDConstants::ACTION_NONE; 4048 dsde.DropSuccess = sal_False; 4049 css::uno::Reference< XDragSourceListener > xListener( m_xDragSourceListener ); 4050 m_xDragSourceListener.clear(); 4051 aGuard.clear(); 4052 xListener->dragDropEnd( dsde ); 4053 } 4054 } 4055 4056 /* 4057 * SelectionAdaptor 4058 */ 4059 4060 css::uno::Reference< XTransferable > SelectionManager::getTransferable() throw() 4061 { 4062 return m_xDragSourceTransferable; 4063 } 4064 4065 // ------------------------------------------------------------------------ 4066 4067 void SelectionManager::clearTransferable() throw() 4068 { 4069 m_xDragSourceTransferable.clear(); 4070 } 4071 4072 // ------------------------------------------------------------------------ 4073 4074 void SelectionManager::fireContentsChanged() throw() 4075 { 4076 } 4077 4078 // ------------------------------------------------------------------------ 4079 4080 css::uno::Reference< XInterface > SelectionManager::getReference() throw() 4081 { 4082 return css::uno::Reference< XInterface >( static_cast<OWeakObject*>(this) ); 4083 } 4084 4085 // ------------------------------------------------------------------------ 4086 4087 /* 4088 * SelectionManagerHolder 4089 */ 4090 4091 SelectionManagerHolder::SelectionManagerHolder() : 4092 ::cppu::WeakComponentImplHelper3< 4093 XDragSource, 4094 XInitialization, 4095 XServiceInfo > (m_aMutex) 4096 { 4097 } 4098 4099 // ------------------------------------------------------------------------ 4100 4101 SelectionManagerHolder::~SelectionManagerHolder() 4102 { 4103 } 4104 4105 // ------------------------------------------------------------------------ 4106 4107 void SelectionManagerHolder::initialize( const Sequence< Any >& arguments ) throw( ::com::sun::star::uno::Exception ) 4108 { 4109 OUString aDisplayName; 4110 4111 if( arguments.getLength() > 0 ) 4112 { 4113 css::uno::Reference< XDisplayConnection > xConn; 4114 arguments.getConstArray()[0] >>= xConn; 4115 if( xConn.is() ) 4116 { 4117 Any aIdentifier; 4118 aIdentifier >>= aDisplayName; 4119 } 4120 } 4121 4122 SelectionManager& rManager = SelectionManager::get( aDisplayName ); 4123 rManager.initialize( arguments ); 4124 m_xRealDragSource = static_cast< XDragSource* >(&rManager); 4125 } 4126 4127 /* 4128 * XDragSource 4129 */ 4130 4131 sal_Bool SelectionManagerHolder::isDragImageSupported() throw() 4132 { 4133 return m_xRealDragSource.is() ? m_xRealDragSource->isDragImageSupported() : sal_False; 4134 } 4135 4136 // ------------------------------------------------------------------------ 4137 4138 sal_Int32 SelectionManagerHolder::getDefaultCursor( sal_Int8 dragAction ) throw() 4139 { 4140 return m_xRealDragSource.is() ? m_xRealDragSource->getDefaultCursor( dragAction ) : 0; 4141 } 4142 4143 // ------------------------------------------------------------------------ 4144 4145 void SelectionManagerHolder::startDrag( 4146 const ::com::sun::star::datatransfer::dnd::DragGestureEvent& trigger, 4147 sal_Int8 sourceActions, sal_Int32 cursor, sal_Int32 image, 4148 const css::uno::Reference< ::com::sun::star::datatransfer::XTransferable >& transferable, 4149 const css::uno::Reference< ::com::sun::star::datatransfer::dnd::XDragSourceListener >& listener 4150 ) throw() 4151 { 4152 if( m_xRealDragSource.is() ) 4153 m_xRealDragSource->startDrag( trigger, sourceActions, cursor, image, transferable, listener ); 4154 } 4155 4156 // ------------------------------------------------------------------------ 4157 4158 /* 4159 * XServiceInfo 4160 */ 4161 4162 // ------------------------------------------------------------------------ 4163 4164 OUString SelectionManagerHolder::getImplementationName() throw() 4165 { 4166 return OUString::createFromAscii(XDND_IMPLEMENTATION_NAME); 4167 } 4168 4169 // ------------------------------------------------------------------------ 4170 4171 sal_Bool SelectionManagerHolder::supportsService( const OUString& ServiceName ) throw() 4172 { 4173 Sequence < OUString > SupportedServicesNames = Xdnd_getSupportedServiceNames(); 4174 4175 for ( sal_Int32 n = SupportedServicesNames.getLength(); n--; ) 4176 if (SupportedServicesNames[n].compareTo(ServiceName) == 0) 4177 return sal_True; 4178 4179 return sal_False; 4180 } 4181 4182 // ------------------------------------------------------------------------ 4183 4184 Sequence< OUString > SelectionManagerHolder::getSupportedServiceNames() throw() 4185 { 4186 return Xdnd_getSupportedServiceNames(); 4187 } 4188 4189 4190 // ------------------------------------------------------------------------ 4191 4192