/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ /************************************************************************* * * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * Copyright 2000, 2010 Oracle and/or its affiliates. * * OpenOffice.org - a multi-platform office productivity suite * * This file is part of OpenOffice.org. * * OpenOffice.org is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License version 3 * only, as published by the Free Software Foundation. * * OpenOffice.org is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Lesser General Public License version 3 for more details * (a copy is included in the LICENSE file that accompanied this code). * * You should have received a copy of the GNU Lesser General Public License * version 3 along with OpenOffice.org. If not, see * * for a copy of the LGPLv3 License. * ************************************************************************/ // MARKER(update_precomp.py): autogen include statement, do not remove #include "precompiled_vcl.hxx" #define _SV_SALDATA_CXX // -=-= #includes =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= #include #include #include #include #include #include #include #include #if defined(FREEBSD) || defined(NETBSD) #include #include #include #endif #include #include #include #include #include #include #include #include "unx/i18n_im.hxx" #include "unx/i18n_xkb.hxx" #include #include "unx/x11_cursors/salcursors.h" #include using namespace vcl_sal; using ::rtl::OUString; /*************************************************************************** * class GtkSalDisplay * ***************************************************************************/ extern "C" { GdkFilterReturn call_filterGdkEvent( GdkXEvent* sys_event, GdkEvent* event, gpointer data ) { GtkSalDisplay *pDisplay = (GtkSalDisplay *)data; return pDisplay->filterGdkEvent( sys_event, event ); } } GtkSalDisplay::GtkSalDisplay( GdkDisplay* pDisplay ) : #if !GTK_CHECK_VERSION(3,0,0) SalDisplay( gdk_x11_display_get_xdisplay( pDisplay ) ), #endif m_pSys( GtkSalSystem::GetSingleton() ), m_pGdkDisplay( pDisplay ), m_bStartupCompleted( false ) { for(int i = 0; i < POINTER_COUNT; i++) m_aCursors[ i ] = NULL; #if GTK_CHECK_VERSION(3,0,0) m_pCapture = NULL; hEventGuard_ = osl_createMutex(); #else m_bUseRandRWrapper = false; // use gdk signal instead Init (); hEventGuard_ = NULL; #endif gdk_window_add_filter( NULL, call_filterGdkEvent, this ); if ( getenv( "SAL_IGNOREXERRORS" ) ) errorTrapPush(); // and leak the trap } GtkSalDisplay::~GtkSalDisplay() { gdk_window_remove_filter( NULL, call_filterGdkEvent, this ); if( !m_bStartupCompleted ) gdk_notify_startup_complete(); #if !GTK_CHECK_VERSION(3,0,0) doDestruct(); pDisp_ = NULL; #endif for(int i = 0; i < POINTER_COUNT; i++) if( m_aCursors[ i ] ) gdk_cursor_unref( m_aCursors[ i ] ); if (hEventGuard_) osl_destroyMutex( hEventGuard_ ); hEventGuard_ = NULL; } void GtkSalDisplay::errorTrapPush() { gdk_error_trap_push (); } void GtkSalDisplay::errorTrapPop() { #if !GTK_CHECK_VERSION(3,0,0) gdk_error_trap_pop (); #else gdk_error_trap_pop_ignored (); // faster #endif } void GtkSalDisplay::registerFrame( SalFrame* pFrame ) { #if !GTK_CHECK_VERSION(3,0,0) SalDisplay::registerFrame( pFrame ); #endif } void GtkSalDisplay::deregisterFrame( SalFrame* pFrame ) { if( m_pCapture == pFrame ) { static_cast(m_pCapture)->grabPointer( FALSE ); m_pCapture = NULL; } #if !GTK_CHECK_VERSION(3,0,0) SalDisplay::deregisterFrame( pFrame ); #endif } extern "C" { void signalKeysChanged( GdkKeymap*, gpointer data ) { GtkSalDisplay* pDisp = (GtkSalDisplay*)data; #if !GTK_CHECK_VERSION(3,0,0) pDisp->GetKeyboardName(true); #endif } void signalScreenSizeChanged( GdkScreen* pScreen, gpointer data ) { GtkSalDisplay* pDisp = (GtkSalDisplay*)data; pDisp->screenSizeChanged( pScreen ); } void signalMonitorsChanged( GdkScreen* pScreen, gpointer data ) { GtkSalDisplay* pDisp = (GtkSalDisplay*)data; pDisp->monitorsChanged( pScreen ); } } GdkFilterReturn GtkSalDisplay::filterGdkEvent( GdkXEvent* sys_event, GdkEvent* ) { #if !GTK_CHECK_VERSION(3,0,0) GdkFilterReturn aFilterReturn = GDK_FILTER_CONTINUE; XEvent *pEvent = (XEvent *)sys_event; // dispatch all XEvents to event callback if( GetSalData()->m_pInstance-> CallEventCallback( pEvent, sizeof( XEvent ) ) ) aFilterReturn = GDK_FILTER_REMOVE; GTK_YIELD_GRAB(); if (GetDisplay() == pEvent->xany.display ) { // #i53471# gtk has no callback mechanism that lets us be notified // when settings (as in XSETTING and opposed to styles) are changed. // so we need to listen for corresponding property notifications here // these should be rare enough so that we can assume that the settings // actually change when a corresponding PropertyNotify occurs if( pEvent->type == PropertyNotify && pEvent->xproperty.atom == getWMAdaptor()->getAtom( WMAdaptor::XSETTINGS ) && ! m_aFrames.empty() ) { SendInternalEvent( m_aFrames.front(), NULL, SALEVENT_SETTINGSCHANGED ); } // let's see if one of our frames wants to swallow these events // get the frame for( std::list< SalFrame* >::const_iterator it = m_aFrames.begin(); it != m_aFrames.end(); ++it ) { GtkSalFrame* pFrame = static_cast(*it); if( (GdkNativeWindow)pFrame->GetSystemData()->aWindow == pEvent->xany.window || ( pFrame->getForeignParent() && pFrame->getForeignParentWindow() == pEvent->xany.window ) || ( pFrame->getForeignTopLevel() && pFrame->getForeignTopLevelWindow() == pEvent->xany.window ) ) { if( ! pFrame->Dispatch( pEvent ) ) aFilterReturn = GDK_FILTER_REMOVE; break; } } X11SalObject::Dispatch( pEvent ); } return aFilterReturn; #else return GDK_FILTER_CONTINUE; #endif } void GtkSalDisplay::screenSizeChanged( GdkScreen* pScreen ) { #if !GTK_CHECK_VERSION(3,0,0) if (pScreen) m_aFrames.front()->CallCallback( SALEVENT_DISPLAYCHANGED, 0 ); #else #warning get this right #endif } void GtkSalDisplay::monitorsChanged( GdkScreen* pScreen ) { #if !GTK_CHECK_VERSION(3,0,0) if (pScreen) m_aFrames.front()->CallCallback( SALEVENT_DISPLAYCHANGED, 0 ); #else #warning get this right #endif } extern "C" { typedef gint(* screen_get_primary_monitor)(GdkScreen *screen); } void GtkSalDisplay::initScreen( int nScreen ) const { #if GTK_CHECK_VERSION(3,0,0) // no colormaps handling in gtk 3 or need to init screens ... #else if( nScreen < 0 || nScreen >= static_cast(m_aScreens.size()) ) nScreen = m_nDefaultScreen; ScreenData& rSD = const_cast(m_aScreens[nScreen]); if( rSD.m_bInit ) return; // choose visual for screen SalDisplay::initScreen( nScreen ); // now set a gdk default colormap matching the chosen visual to the screen GdkScreen* pScreen = gdk_display_get_screen( m_pGdkDisplay, nScreen ); // should really use this: // GdkVisual* pVis = gdk_x11_screen_lookup_visual_get( screen, rSD.m_aVisual.visualid ); // and not this: GdkVisual* pVis = gdkx_visual_get( rSD.m_aVisual.visualid ); if( pVis ) { GdkColormap* pDefCol = gdk_screen_get_default_colormap( pScreen ); GdkVisual* pDefVis = gdk_colormap_get_visual( pDefCol ); if( pDefVis != pVis ) { pDefCol = gdk_x11_colormap_foreign_new( pVis, rSD.m_aColormap.GetXColormap() ); gdk_screen_set_default_colormap( pScreen, pDefCol ); #if OSL_DEBUG_LEVEL > 1 fprintf( stderr, "set new gdk color map for screen %d\n", nScreen ); #endif } } #if OSL_DEBUG_LEVEL > 1 else fprintf( stderr, "not GdkVisual for visual id %d\n", (int)rSD.m_aVisual.visualid ); #endif #endif } #if !GTK_CHECK_VERSION(3,0,0) long GtkSalDisplay::Dispatch( XEvent* pEvent ) { if( GetDisplay() == pEvent->xany.display ) { // let's see if one of our frames wants to swallow these events // get the child frame for( std::list< SalFrame* >::const_iterator it = m_aFrames.begin(); it != m_aFrames.end(); ++it ) { if( (GdkNativeWindow)(*it)->GetSystemData()->aWindow == pEvent->xany.window ) return static_cast(*it)->Dispatch( pEvent ); } } return GDK_FILTER_CONTINUE; } #endif #if GTK_CHECK_VERSION(3,0,0) namespace { //cairo annoyingly won't take raw xbm data unless it fits //the required cairo stride unsigned char* ensurePaddedForCairo(const unsigned char *pXBM, int nWidth, int nHeight, int nStride) { unsigned char *pPaddedXBM = const_cast(pXBM); int bytes_per_row = (nWidth + 7) / 8; if (nStride != bytes_per_row) { pPaddedXBM = new unsigned char[nStride * nHeight]; for (int row = 0; row < nHeight; ++row) { memcpy(pPaddedXBM + (nStride * row), pXBM + (bytes_per_row * row), bytes_per_row); memset(pPaddedXBM + (nStride * row) + bytes_per_row, 0, nStride - bytes_per_row); } } return pPaddedXBM; } } #endif GdkCursor* GtkSalDisplay::getFromXBM( const unsigned char *pBitmap, const unsigned char *pMask, int nWidth, int nHeight, int nXHot, int nYHot ) { #if GTK_CHECK_VERSION(3,0,0) int cairo_stride = cairo_format_stride_for_width(CAIRO_FORMAT_A1, nWidth); unsigned char *pPaddedXBM = ensurePaddedForCairo(pBitmap, nWidth, nHeight, cairo_stride); cairo_surface_t *s = cairo_image_surface_create_for_data( pPaddedXBM, CAIRO_FORMAT_A1, nWidth, nHeight, cairo_stride); cairo_t *cr = cairo_create(s); unsigned char *pPaddedMaskXBM = ensurePaddedForCairo(pMask, nWidth, nHeight, cairo_stride); cairo_surface_t *mask = cairo_image_surface_create_for_data( pPaddedMaskXBM, CAIRO_FORMAT_A1, nWidth, nHeight, cairo_stride); cairo_mask_surface(cr, mask, 0, 0); cairo_destroy(cr); cairo_surface_destroy(mask); if (pPaddedMaskXBM != pMask) delete [] pPaddedMaskXBM; GdkPixbuf *pixbuf = gdk_pixbuf_get_from_surface(s, 0, 0, nWidth, nHeight); cairo_surface_destroy(s); if (pPaddedXBM != pBitmap) delete [] pPaddedXBM; GdkCursor *cursor = gdk_cursor_new_from_pixbuf(m_pGdkDisplay, pixbuf, nXHot, nYHot); g_object_unref(pixbuf); return cursor; #else GdkScreen *pScreen = gdk_display_get_default_screen( m_pGdkDisplay ); GdkDrawable *pDrawable = GDK_DRAWABLE( gdk_screen_get_root_window (pScreen) ); GdkBitmap *pBitmapPix = gdk_bitmap_create_from_data ( pDrawable, reinterpret_cast(pBitmap), nWidth, nHeight ); GdkBitmap *pMaskPix = gdk_bitmap_create_from_data ( pDrawable, reinterpret_cast(pMask), nWidth, nHeight ); GdkColormap *pColormap = gdk_drawable_get_colormap( pDrawable ); GdkColor aWhite = { 0, 0xffff, 0xffff, 0xffff }; GdkColor aBlack = { 0, 0, 0, 0 }; gdk_colormap_alloc_color( pColormap, &aBlack, FALSE, TRUE); gdk_colormap_alloc_color( pColormap, &aWhite, FALSE, TRUE); return gdk_cursor_new_from_pixmap ( pBitmapPix, pMaskPix, &aBlack, &aWhite, nXHot, nYHot); #endif } #define MAKE_CURSOR( vcl_name, name ) \ case vcl_name: \ pCursor = getFromXBM( name##curs##_bits, name##mask##_bits, \ name##curs_width, name##curs_height, \ name##curs_x_hot, name##curs_y_hot ); \ break #define MAP_BUILTIN( vcl_name, gdk_name ) \ case vcl_name: \ pCursor = gdk_cursor_new_for_display( m_pGdkDisplay, gdk_name ); \ break GdkCursor *GtkSalDisplay::getCursor( PointerStyle ePointerStyle ) { if( ePointerStyle >= POINTER_COUNT ) return NULL; if ( !m_aCursors[ ePointerStyle ] ) { GdkCursor *pCursor = NULL; switch( ePointerStyle ) { MAP_BUILTIN( POINTER_ARROW, GDK_LEFT_PTR ); MAP_BUILTIN( POINTER_TEXT, GDK_XTERM ); MAP_BUILTIN( POINTER_HELP, GDK_QUESTION_ARROW ); MAP_BUILTIN( POINTER_CROSS, GDK_CROSSHAIR ); MAP_BUILTIN( POINTER_WAIT, GDK_WATCH ); MAP_BUILTIN( POINTER_NSIZE, GDK_SB_V_DOUBLE_ARROW ); MAP_BUILTIN( POINTER_SSIZE, GDK_SB_V_DOUBLE_ARROW ); MAP_BUILTIN( POINTER_WSIZE, GDK_SB_H_DOUBLE_ARROW ); MAP_BUILTIN( POINTER_ESIZE, GDK_SB_H_DOUBLE_ARROW ); MAP_BUILTIN( POINTER_NWSIZE, GDK_TOP_LEFT_CORNER ); MAP_BUILTIN( POINTER_NESIZE, GDK_TOP_RIGHT_CORNER ); MAP_BUILTIN( POINTER_SWSIZE, GDK_BOTTOM_LEFT_CORNER ); MAP_BUILTIN( POINTER_SESIZE, GDK_BOTTOM_RIGHT_CORNER ); MAP_BUILTIN( POINTER_WINDOW_NSIZE, GDK_TOP_SIDE ); MAP_BUILTIN( POINTER_WINDOW_SSIZE, GDK_BOTTOM_SIDE ); MAP_BUILTIN( POINTER_WINDOW_WSIZE, GDK_LEFT_SIDE ); MAP_BUILTIN( POINTER_WINDOW_ESIZE, GDK_RIGHT_SIDE ); MAP_BUILTIN( POINTER_WINDOW_NWSIZE, GDK_TOP_LEFT_CORNER ); MAP_BUILTIN( POINTER_WINDOW_NESIZE, GDK_TOP_RIGHT_CORNER ); MAP_BUILTIN( POINTER_WINDOW_SWSIZE, GDK_BOTTOM_LEFT_CORNER ); MAP_BUILTIN( POINTER_WINDOW_SESIZE, GDK_BOTTOM_RIGHT_CORNER ); MAP_BUILTIN( POINTER_HSIZEBAR, GDK_SB_H_DOUBLE_ARROW ); MAP_BUILTIN( POINTER_VSIZEBAR, GDK_SB_V_DOUBLE_ARROW ); MAP_BUILTIN( POINTER_REFHAND, GDK_HAND2 ); MAP_BUILTIN( POINTER_HAND, GDK_HAND2 ); MAP_BUILTIN( POINTER_PEN, GDK_PENCIL ); MAP_BUILTIN( POINTER_HSPLIT, GDK_SB_H_DOUBLE_ARROW ); MAP_BUILTIN( POINTER_VSPLIT, GDK_SB_V_DOUBLE_ARROW ); MAP_BUILTIN( POINTER_MOVE, GDK_FLEUR ); MAKE_CURSOR( POINTER_NULL, null ); MAKE_CURSOR( POINTER_MAGNIFY, magnify_ ); MAKE_CURSOR( POINTER_FILL, fill_ ); MAKE_CURSOR( POINTER_MOVEDATA, movedata_ ); MAKE_CURSOR( POINTER_COPYDATA, copydata_ ); MAKE_CURSOR( POINTER_MOVEFILE, movefile_ ); MAKE_CURSOR( POINTER_COPYFILE, copyfile_ ); MAKE_CURSOR( POINTER_MOVEFILES, movefiles_ ); MAKE_CURSOR( POINTER_COPYFILES, copyfiles_ ); MAKE_CURSOR( POINTER_NOTALLOWED, nodrop_ ); MAKE_CURSOR( POINTER_ROTATE, rotate_ ); MAKE_CURSOR( POINTER_HSHEAR, hshear_ ); MAKE_CURSOR( POINTER_VSHEAR, vshear_ ); MAKE_CURSOR( POINTER_DRAW_LINE, drawline_ ); MAKE_CURSOR( POINTER_DRAW_RECT, drawrect_ ); MAKE_CURSOR( POINTER_DRAW_POLYGON, drawpolygon_ ); MAKE_CURSOR( POINTER_DRAW_BEZIER, drawbezier_ ); MAKE_CURSOR( POINTER_DRAW_ARC, drawarc_ ); MAKE_CURSOR( POINTER_DRAW_PIE, drawpie_ ); MAKE_CURSOR( POINTER_DRAW_CIRCLECUT, drawcirclecut_ ); MAKE_CURSOR( POINTER_DRAW_ELLIPSE, drawellipse_ ); MAKE_CURSOR( POINTER_DRAW_CONNECT, drawconnect_ ); MAKE_CURSOR( POINTER_DRAW_TEXT, drawtext_ ); MAKE_CURSOR( POINTER_MIRROR, mirror_ ); MAKE_CURSOR( POINTER_CROOK, crook_ ); MAKE_CURSOR( POINTER_CROP, crop_ ); MAKE_CURSOR( POINTER_MOVEPOINT, movepoint_ ); MAKE_CURSOR( POINTER_MOVEBEZIERWEIGHT, movebezierweight_ ); MAKE_CURSOR( POINTER_DRAW_FREEHAND, drawfreehand_ ); MAKE_CURSOR( POINTER_DRAW_CAPTION, drawcaption_ ); MAKE_CURSOR( POINTER_LINKDATA, linkdata_ ); MAKE_CURSOR( POINTER_MOVEDATALINK, movedlnk_ ); MAKE_CURSOR( POINTER_COPYDATALINK, copydlnk_ ); MAKE_CURSOR( POINTER_LINKFILE, linkfile_ ); MAKE_CURSOR( POINTER_MOVEFILELINK, moveflnk_ ); MAKE_CURSOR( POINTER_COPYFILELINK, copyflnk_ ); MAKE_CURSOR( POINTER_CHART, chart_ ); MAKE_CURSOR( POINTER_DETECTIVE, detective_ ); MAKE_CURSOR( POINTER_PIVOT_COL, pivotcol_ ); MAKE_CURSOR( POINTER_PIVOT_ROW, pivotrow_ ); MAKE_CURSOR( POINTER_PIVOT_FIELD, pivotfld_ ); MAKE_CURSOR( POINTER_PIVOT_DELETE, pivotdel_ ); MAKE_CURSOR( POINTER_CHAIN, chain_ ); MAKE_CURSOR( POINTER_CHAIN_NOTALLOWED, chainnot_ ); MAKE_CURSOR( POINTER_TIMEEVENT_MOVE, timemove_ ); MAKE_CURSOR( POINTER_TIMEEVENT_SIZE, timesize_ ); MAKE_CURSOR( POINTER_AUTOSCROLL_N, asn_ ); MAKE_CURSOR( POINTER_AUTOSCROLL_S, ass_ ); MAKE_CURSOR( POINTER_AUTOSCROLL_W, asw_ ); MAKE_CURSOR( POINTER_AUTOSCROLL_E, ase_ ); MAKE_CURSOR( POINTER_AUTOSCROLL_NW, asnw_ ); MAKE_CURSOR( POINTER_AUTOSCROLL_NE, asne_ ); MAKE_CURSOR( POINTER_AUTOSCROLL_SW, assw_ ); MAKE_CURSOR( POINTER_AUTOSCROLL_SE, asse_ ); MAKE_CURSOR( POINTER_AUTOSCROLL_NS, asns_ ); MAKE_CURSOR( POINTER_AUTOSCROLL_WE, aswe_ ); MAKE_CURSOR( POINTER_AUTOSCROLL_NSWE, asnswe_ ); MAKE_CURSOR( POINTER_AIRBRUSH, airbrush_ ); MAKE_CURSOR( POINTER_TEXT_VERTICAL, vertcurs_ ); // #i32329# MAKE_CURSOR( POINTER_TAB_SELECT_S, tblsels_ ); MAKE_CURSOR( POINTER_TAB_SELECT_E, tblsele_ ); MAKE_CURSOR( POINTER_TAB_SELECT_SE, tblselse_ ); MAKE_CURSOR( POINTER_TAB_SELECT_W, tblselw_ ); MAKE_CURSOR( POINTER_TAB_SELECT_SW, tblselsw_ ); // #i20119# MAKE_CURSOR( POINTER_PAINTBRUSH, paintbrush_ ); default: fprintf( stderr, "pointer %d not implemented", ePointerStyle ); break; } if( !pCursor ) pCursor = gdk_cursor_new_for_display( m_pGdkDisplay, GDK_LEFT_PTR ); m_aCursors[ ePointerStyle ] = pCursor; } return m_aCursors[ ePointerStyle ]; } int GtkSalDisplay::CaptureMouse( SalFrame* pSFrame ) { GtkSalFrame* pFrame = static_cast(pSFrame); if( !pFrame ) { if( m_pCapture ) static_cast(m_pCapture)->grabPointer( FALSE ); m_pCapture = NULL; return 0; } if( m_pCapture ) { if( pFrame == m_pCapture ) return 1; static_cast(m_pCapture)->grabPointer( FALSE ); } m_pCapture = pFrame; static_cast(pFrame)->grabPointer( TRUE ); return 1; } /********************************************************************** * class GtkData * **********************************************************************/ GtkData::GtkData() { m_pUserEvent = NULL; m_aDispatchMutex = osl_createMutex(); m_aDispatchCondition = osl_createCondition(); } GtkData::~GtkData() { Yield( true, true ); g_warning ("TESTME: We used to have a stop-timer here, but the central code should do this"); if (m_pUserEvent) { g_source_destroy (m_pUserEvent); g_source_unref (m_pUserEvent); } // sanity check: at this point nobody should be yielding, but wake them // up anyway before the condition they're waiting on gets destroyed. osl_setCondition( m_aDispatchCondition ); osl_destroyCondition( m_aDispatchCondition ); osl_destroyMutex( m_aDispatchMutex ); } void GtkData::Yield( bool bWait, bool bHandleAllCurrentEvents ) { /* #i33212# only enter g_main_context_iteration in one thread at any one * time, else one of them potentially will never end as long as there is * another thread in in there. Having only one yieldin thread actually dispatch * fits the vcl event model (see e.g. the generic plugin). */ bool bDispatchThread = false; gboolean wasEvent = FALSE; { // release YieldMutex (and re-acquire at block end) YieldMutexReleaser aReleaser; if( osl_tryToAcquireMutex( m_aDispatchMutex ) ) bDispatchThread = true; else if( ! bWait ) return; // someone else is waiting already, return if( bDispatchThread ) { int nMaxEvents = bHandleAllCurrentEvents ? 100 : 1; gboolean wasOneEvent = TRUE; while( nMaxEvents-- && wasOneEvent ) { wasOneEvent = g_main_context_iteration( NULL, FALSE ); if( wasOneEvent ) wasEvent = TRUE; } if( bWait && ! wasEvent ) wasEvent = g_main_context_iteration( NULL, TRUE ); } else if( bWait ) { /* #i41693# in case the dispatch thread hangs in join * for this thread the condition will never be set * workaround: timeout of 1 second a emergency exit */ // we are the dispatch thread osl_resetCondition( m_aDispatchCondition ); TimeValue aValue = { 1, 0 }; osl_waitCondition( m_aDispatchCondition, &aValue ); } } if( bDispatchThread ) { osl_releaseMutex( m_aDispatchMutex ); if( wasEvent ) osl_setCondition( m_aDispatchCondition ); // trigger non dispatch thread yields } } void GtkData::Init() { int i; #if OSL_DEBUG_LEVEL > 1 fprintf( stderr, "GtkMainloop::Init()\n" ); #endif XrmInitialize(); #if !GTK_CHECK_VERSION(3,0,0) gtk_set_locale(); #endif /* * open connection to X11 Display * try in this order: * o -display command line parameter, * o $DISPLAY environment variable * o default display */ GdkDisplay *pGdkDisp = NULL; // is there a -display command line parameter? rtl_TextEncoding aEnc = osl_getThreadTextEncoding(); int nParams = osl_getCommandArgCount(); rtl::OString aDisplay; rtl::OUString aParam, aBin; char** pCmdLineAry = new char*[ nParams+1 ]; osl_getExecutableFile( &aParam.pData ); osl_getSystemPathFromFileURL( aParam.pData, &aBin.pData ); pCmdLineAry[0] = g_strdup( OUStringToOString( aBin, aEnc ).getStr() ); for (i=0; i 0 ) { rtl::OString aPrgName = rtl::OUStringToOString(aAppName, aEnc); g_set_prgname(aPrgName.getStr()); } // init gtk/gdk gtk_init_check( &nParams, &pCmdLineAry ); for (i = 0; i < nParams; i++ ) g_free( pCmdLineAry[i] ); delete [] pCmdLineAry; #if OSL_DEBUG_LEVEL > 1 if (g_getenv ("SAL_DEBUG_UPDATES")) gdk_window_set_debug_updates (TRUE); #endif pGdkDisp = gdk_display_get_default(); if ( !pGdkDisp ) { rtl::OUString aProgramFileURL; osl_getExecutableFile( &aProgramFileURL.pData ); rtl::OUString aProgramSystemPath; osl_getSystemPathFromFileURL (aProgramFileURL.pData, &aProgramSystemPath.pData); rtl::OString aProgramName = rtl::OUStringToOString( aProgramSystemPath, osl_getThreadTextEncoding() ); fprintf( stderr, "%s X11 error: Can't open display: %s\n", aProgramName.getStr(), aDisplay.getStr()); fprintf( stderr, " Set DISPLAY environment variable, use -display option\n"); fprintf( stderr, " or check permissions of your X-Server\n"); fprintf( stderr, " (See \"man X\" resp. \"man xhost\" for details)\n"); fflush( stderr ); exit(0); } /* * if a -display switch was used, we need * to set the environment accoringly since * the clipboard build another connection * to the xserver using $DISPLAY */ rtl::OUString envVar(RTL_CONSTASCII_USTRINGPARAM("DISPLAY")); const gchar *name = gdk_display_get_name( pGdkDisp ); rtl::OUString envValue(name, strlen(name), aEnc); osl_setEnvironment(envVar.pData, envValue.pData); m_pGtkSalDisplay = new GtkSalDisplay( pGdkDisp ); #if !GTK_CHECK_VERSION(3,0,0) Display *pDisp = gdk_x11_display_get_xdisplay( pGdkDisp ); gdk_error_trap_push(); SalI18N_KeyboardExtension *pKbdExtension = new SalI18N_KeyboardExtension( pDisp ); bool bErrorOccured = gdk_error_trap_pop() != 0; gdk_error_trap_push(); pKbdExtension->UseExtension( bErrorOccured ); gdk_error_trap_pop(); m_pGtkSalDisplay->SetKbdExtension( pKbdExtension ); #else # warning unwind keyboard extension bits #endif g_signal_connect( G_OBJECT(gdk_keymap_get_default()), "keys_changed", G_CALLBACK(signalKeysChanged), m_pGtkSalDisplay ); // add signal handler to notify screen size changes int nScreens = gdk_display_get_n_screens( pGdkDisp ); for( int n = 0; n < nScreens; n++ ) { GdkScreen *pScreen = gdk_display_get_screen( pGdkDisp, n ); if( pScreen ) { m_pGtkSalDisplay->screenSizeChanged(pScreen); m_pGtkSalDisplay->monitorsChanged(pScreen); g_signal_connect( G_OBJECT(pScreen), "size-changed", G_CALLBACK(signalScreenSizeChanged), m_pGtkSalDisplay ); if( ! gtk_check_version( 2, 14, 0 ) ) // monitors-changed came in with 2.14, avoid an assertion g_signal_connect( G_OBJECT(pScreen), "monitors-changed", G_CALLBACK(signalMonitorsChanged), m_pGtkSalDisplay ); } } } GtkSalTimer::GtkSalTimer() : m_pTimeout( 0 ) { } GtkSalTimer::~GtkSalTimer() { Stop(); } extern "C" { gboolean call_timeoutFn( gpointer pData ) { GtkSalTimer *pTimer = (GtkSalTimer *)pData; SalData *pSalData = GetSalData(); osl::SolarGuard aGuard( pSalData->m_pInstance->GetYieldMutex() ); pTimer->Start( pTimer->m_nTimeoutMS ); ImplSVData* pSVData = ImplGetSVData(); if( pSVData->mpSalTimer ) pSVData->mpSalTimer->CallCallback(); return FALSE; } } void GtkSalTimer::Start( sal_uLong nMS ) { m_nTimeoutMS = nMS; // for restarting Stop(); m_pTimeout = g_timeout_source_new (m_nTimeoutMS); // #i36226# timers should be executed with lower priority // than XEvents like in generic plugin g_source_set_priority( m_pTimeout, G_PRIORITY_LOW ); g_source_set_can_recurse (m_pTimeout, TRUE); g_source_set_callback (m_pTimeout, call_timeoutFn, (gpointer) this, NULL); g_source_attach (m_pTimeout, g_main_context_default ()); } void GtkSalTimer::Stop() { if( m_pTimeout ) { g_source_destroy( m_pTimeout ); g_source_unref( m_pTimeout ); } } gboolean GtkData::userEventFn( gpointer data ) { gboolean bContinue = FALSE; GtkData *pThis = (GtkData *) data; X11SalData *pSalData = GetX11SalData(); osl::SolarGuard aGuard( pSalData->m_pInstance->GetYieldMutex() ); const SalDisplay *pDisplay = pSalData->GetDisplay(); //GtkSalDisplay inherits from SalDisplay, SalDisplay's dtor deregisters //itself from SalData, so use presence of pDisplay here to detect that //m_pGtkSalDisplay was destroyed by X11SalData::DeleteDisplay if (pDisplay) { #if !GTK_CHECK_VERSION(3,0,0) OSL_ASSERT(static_cast(pThis->m_pGtkSalDisplay) == pDisplay); #endif pThis->m_pGtkSalDisplay->EventGuardAcquire(); if( !pThis->m_pGtkSalDisplay->HasMoreEvents() ) { if( pThis->m_pUserEvent ) { g_source_unref (pThis->m_pUserEvent); pThis->m_pUserEvent = NULL; } bContinue = FALSE; } else bContinue = TRUE; pThis->m_pGtkSalDisplay->EventGuardRelease(); pThis->m_pGtkSalDisplay->DispatchInternalEvent(); } return bContinue; } #if GTK_CHECK_VERSION(3,0,0) // FIXME: cut/paste from saldisp.cxx - needs some re-factoring love bool GtkSalDisplay::DispatchInternalEvent() { SalFrame* pFrame = NULL; void* pData = NULL; sal_uInt16 nEvent = 0; if( osl_acquireMutex( hEventGuard_ ) ) { if( m_aUserEvents.begin() != m_aUserEvents.end() ) { pFrame = m_aUserEvents.front().m_pFrame; pData = m_aUserEvents.front().m_pData; nEvent = m_aUserEvents.front().m_nEvent; m_aUserEvents.pop_front(); } osl_releaseMutex( hEventGuard_ ); } else { DBG_ASSERT( 1, "SalDisplay::Yield !acquireMutex\n" ); } if( pFrame ) pFrame->CallCallback( nEvent, pData ); return pFrame != NULL; } void GtkSalDisplay::SendInternalEvent( SalFrame* pFrame, void* pData, sal_uInt16 nEvent ) { if( osl_acquireMutex( hEventGuard_ ) ) { m_aUserEvents.push_back( SalUserEvent( pFrame, pData, nEvent ) ); // Notify GtkData::Yield() of a pending event. GetGtkSalData()->PostUserEvent(); osl_releaseMutex( hEventGuard_ ); } else { DBG_ASSERT( 1, "SalDisplay::SendInternalEvent !acquireMutex\n" ); } } void GtkSalDisplay::CancelInternalEvent( SalFrame* pFrame, void* pData, sal_uInt16 nEvent ) { if( osl_acquireMutex( hEventGuard_ ) ) { if( ! m_aUserEvents.empty() ) { std::list< SalUserEvent >::iterator it, next; next = m_aUserEvents.begin(); do { it = next++; if( it->m_pFrame == pFrame && it->m_pData == pData && it->m_nEvent == nEvent ) { m_aUserEvents.erase( it ); } } while( next != m_aUserEvents.end() ); } osl_releaseMutex( hEventGuard_ ); } else DBG_ASSERT( 1, "SalDisplay::CancelInternalEvent !acquireMutex\n" ); } #endif extern "C" { static gboolean call_userEventFn( void *data ) { return GtkData::userEventFn( data ); } } // hEventGuard_ held during this invocation void GtkData::PostUserEvent() { if (m_pUserEvent) g_main_context_wakeup (NULL); // really needed ? else // nothing pending anyway { m_pUserEvent = g_idle_source_new(); g_source_set_priority (m_pUserEvent, G_PRIORITY_HIGH); g_source_set_can_recurse (m_pUserEvent, TRUE); g_source_set_callback (m_pUserEvent, call_userEventFn, (gpointer) this, NULL); g_source_attach (m_pUserEvent, g_main_context_default ()); } } /* vim:set shiftwidth=4 softtabstop=4 expandtab: */