xref: /aoo41x/main/vcl/unx/gtk/app/gtkdata.cxx (revision 24c56ab9)
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 #define _SV_SALDATA_CXX
28 
29 // -=-= #includes =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
30 
31 #include <unistd.h>
32 #include <fcntl.h>
33 
34 #include <stdio.h>
35 #include <string.h>
36 #include <stdlib.h>
37 #include <limits.h>
38 #include <errno.h>
39 #include <poll.h>
40 #ifdef FREEBSD
41 #include <sys/types.h>
42 #include <sys/time.h>
43 #include <unistd.h>
44 #endif
45 #include <unx/gtk/gtkdata.hxx>
46 #include <unx/gtk/gtkinst.hxx>
47 #include <unx/gtk/gtkframe.hxx>
48 #include <unx/salobj.h>
49 #include <osl/thread.h>
50 #include <osl/process.h>
51 
52 #include <tools/debug.hxx>
53 #include "unx/i18n_im.hxx"
54 #include "unx/i18n_xkb.hxx"
55 #include <unx/wmadaptor.hxx>
56 
57 #include "unx/x11_cursors/salcursors.h"
58 
59 #include <vcl/svapp.hxx>
60 
61 using namespace rtl;
62 using namespace vcl_sal;
63 
64 /***************************************************************************
65  * class GtkDisplay                                                        *
66  ***************************************************************************/
67 
GtkSalDisplay(GdkDisplay * pDisplay)68 GtkSalDisplay::GtkSalDisplay( GdkDisplay* pDisplay )
69             : SalDisplay( gdk_x11_display_get_xdisplay( pDisplay ) ),
70               m_pGdkDisplay( pDisplay ),
71               m_bStartupCompleted( false )
72 {
73     m_bUseRandRWrapper = false; // use gdk signal instead
74 	for(int i = 0; i < POINTER_COUNT; i++)
75 		m_aCursors[ i ] = NULL;
76 	Init ();
77 }
78 
~GtkSalDisplay()79 GtkSalDisplay::~GtkSalDisplay()
80 {
81     if( !m_bStartupCompleted )
82         gdk_notify_startup_complete();
83     doDestruct();
84 
85 	for(int i = 0; i < POINTER_COUNT; i++)
86 		if( m_aCursors[ i ] )
87 			gdk_cursor_unref( m_aCursors[ i ] );
88 
89     pDisp_ = NULL;
90 }
91 
deregisterFrame(SalFrame * pFrame)92 void GtkSalDisplay::deregisterFrame( SalFrame* pFrame )
93 {
94 	if( m_pCapture == pFrame )
95 	{
96 		static_cast<GtkSalFrame*>(m_pCapture)->grabPointer( FALSE );
97 		m_pCapture = NULL;
98 	}
99     SalDisplay::deregisterFrame( pFrame );
100 }
101 
102 extern "C" {
call_filterGdkEvent(GdkXEvent * sys_event,GdkEvent * event,gpointer data)103 GdkFilterReturn call_filterGdkEvent( GdkXEvent* sys_event,
104                                      GdkEvent* event,
105                                      gpointer data )
106 {
107     return GtkSalDisplay::filterGdkEvent( sys_event, event, data );
108 }
109 
signalKeysChanged(GdkKeymap *,gpointer data)110 void signalKeysChanged( GdkKeymap*, gpointer data )
111 {
112     GtkSalDisplay* pDisp = (GtkSalDisplay*)data;
113     pDisp->GetKeyboardName(TRUE);
114 }
115 
signalScreenSizeChanged(GdkScreen * pScreen,gpointer data)116 void signalScreenSizeChanged( GdkScreen* pScreen, gpointer data )
117 {
118     GtkSalDisplay* pDisp = (GtkSalDisplay*)data;
119     pDisp->screenSizeChanged( pScreen );
120 }
121 
signalMonitorsChanged(GdkScreen * pScreen,gpointer data)122 void signalMonitorsChanged( GdkScreen* pScreen, gpointer data )
123 {
124     GtkSalDisplay* pDisp = (GtkSalDisplay*)data;
125     pDisp->monitorsChanged( pScreen );
126 }
127 
128 }
129 
filterGdkEvent(GdkXEvent * sys_event,GdkEvent *,gpointer data)130 GdkFilterReturn GtkSalDisplay::filterGdkEvent( GdkXEvent* sys_event,
131                                                GdkEvent*,
132                                                gpointer data )
133 {
134     GdkFilterReturn aFilterReturn = GDK_FILTER_CONTINUE;
135 
136 	XEvent *pEvent = (XEvent *)sys_event;
137 	GtkSalDisplay *pDisplay = (GtkSalDisplay *)data;
138 
139     // dispatch all XEvents to event callback
140     if( GetSalData()->m_pInstance->
141         CallEventCallback( pEvent, sizeof( XEvent ) ) )
142         aFilterReturn = GDK_FILTER_REMOVE;
143 
144     GTK_YIELD_GRAB();
145 
146     if (pDisplay->GetDisplay() == pEvent->xany.display )
147     {
148         // #i53471# gtk has no callback mechanism that lets us be notified
149         // when settings (as in XSETTING and opposed to styles) are changed.
150         // so we need to listen for corresponding property notifications here
151         // these should be rare enough so that we can assume that the settings
152         // actually change when a corresponding PropertyNotify occurs
153         if( pEvent->type == PropertyNotify &&
154             pEvent->xproperty.atom == pDisplay->getWMAdaptor()->getAtom( WMAdaptor::XSETTINGS ) &&
155             ! pDisplay->m_aFrames.empty()
156            )
157         {
158             pDisplay->SendInternalEvent( pDisplay->m_aFrames.front(), NULL, SALEVENT_SETTINGSCHANGED );
159         }
160         // let's see if one of our frames wants to swallow these events
161         // get the frame
162         for( std::list< SalFrame* >::const_iterator it = pDisplay->m_aFrames.begin();
163                  it != pDisplay->m_aFrames.end(); ++it )
164         {
165             GtkSalFrame* pFrame = static_cast<GtkSalFrame*>(*it);
166             if( (GdkNativeWindow)pFrame->GetSystemData()->aWindow == pEvent->xany.window ||
167                 ( pFrame->getForeignParent() && pFrame->getForeignParentWindow() == pEvent->xany.window ) ||
168                 ( pFrame->getForeignTopLevel() && pFrame->getForeignTopLevelWindow() == pEvent->xany.window )
169                 )
170             {
171                 if( ! pFrame->Dispatch( pEvent ) )
172                     aFilterReturn = GDK_FILTER_REMOVE;
173                 break;
174             }
175         }
176         X11SalObject::Dispatch( pEvent );
177     }
178 
179     return aFilterReturn;
180 }
181 
screenSizeChanged(GdkScreen * pScreen)182 void GtkSalDisplay::screenSizeChanged( GdkScreen* pScreen )
183 {
184     if( pScreen )
185     {
186         int nScreen = gdk_screen_get_number( pScreen );
187         if( nScreen < static_cast<int>(m_aScreens.size()) )
188         {
189             ScreenData& rSD = const_cast<ScreenData&>(m_aScreens[nScreen]);
190             if( rSD.m_bInit )
191             {
192                 rSD.m_aSize = Size( gdk_screen_get_width( pScreen ),
193                                     gdk_screen_get_height( pScreen ) );
194                 if( ! m_aFrames.empty() )
195                     m_aFrames.front()->CallCallback( SALEVENT_DISPLAYCHANGED, 0 );
196             }
197         }
198         else
199         {
200             DBG_ERROR( "unknown screen changed size" );
201         }
202     }
203 }
204 
monitorsChanged(GdkScreen * pScreen)205 void GtkSalDisplay::monitorsChanged( GdkScreen* pScreen )
206 {
207     /* Caution: since we support the _NET_WM_FULLSCREEN_MONITORS property now and
208        the EWMH spec says, the index used for that needs to be that of the
209        Xinerama extension, we need to ensure that the order of m_aXineramaScreens is actually intact.
210 
211        gdk_screen_get_monitor_geometry however has a different sort order that has a default monitor number
212        Xinerama returns the default monitor as 0.
213        That means if we fill in the multiple montors vector from gdk, we'll get the wrong order unless
214        the default monitor is incidentally the same (number 0).
215 
216        Given that XRandR (which is what gdk_screen_get_monitor_geometry is based on) is
217        supposed to replace Xinerama, this is bound to get a problem at some time again,
218        unfortunately there does not currently seem to be a way to map the returns of xinerama to
219        that of randr. Currently getting Xinerama values again works with updated values, given
220        a new enough Xserver.
221     */
222     InitXinerama();
223     (void)pScreen;
224 
225     #if 0
226     if( pScreen )
227     {
228         if( gdk_display_get_n_screens(m_pGdkDisplay) == 1 )
229         {
230             int nScreen = gdk_screen_get_number( pScreen );
231             if( nScreen == m_nDefaultScreen ) //To-Do, make m_aXineramaScreens a per-screen thing ?
232             {
233                 gint nMonitors = gdk_screen_get_n_monitors(pScreen);
234                 m_aXineramaScreens = std::vector<Rectangle>();
235                 m_aXineramaScreenIndexMap = std::vector<int>(nMonitors);
236                 for (gint i = 0; i < nMonitors; ++i)
237                 {
238                     GdkRectangle dest;
239                     gdk_screen_get_monitor_geometry(pScreen, i, &dest);
240                     m_aXineramaScreenIndexMap[i] = addXineramaScreenUnique( dest.x, dest.y, dest.width, dest.height );
241                 }
242                 m_bXinerama = m_aXineramaScreens.size() > 1;
243                 if( ! m_aFrames.empty() )
244                     m_aFrames.front()->CallCallback( SALEVENT_DISPLAYCHANGED, 0 );
245             }
246             else
247             {
248                 DBG_ERROR( "monitors for non-default screen changed, extend-me" );
249             }
250         }
251     }
252     #endif
253 }
254 
255 extern "C"
256 {
257     typedef gint(* screen_get_primary_monitor)(GdkScreen *screen);
258 }
259 
GetDefaultMonitorNumber() const260 int GtkSalDisplay::GetDefaultMonitorNumber() const
261 {
262     int n = 0;
263 
264     // currently disabled, see remarks in monitorsChanged
265 #if 0
266     GdkScreen* pScreen = gdk_display_get_screen( m_pGdkDisplay, m_nDefaultScreen );
267 #if GTK_CHECK_VERSION(2,20,0)
268     n = gdk_screen_get_primary_monitor(pScreen);
269 #else
270     static screen_get_primary_monitor sym_gdk_screen_get_primary_monitor =
271         (screen_get_primary_monitor)osl_getAsciiFunctionSymbol( GetSalData()->m_pPlugin, "gdk_screen_get_primary_monitor" );
272     if (sym_gdk_screen_get_primary_monitor)
273         n = sym_gdk_screen_get_primary_monitor( pScreen );
274 #endif
275     if( n >= 0 && size_t(n) < m_aXineramaScreenIndexMap.size() )
276         n = m_aXineramaScreenIndexMap[n];
277 #endif
278     return n;
279 }
280 
initScreen(int nScreen) const281 void GtkSalDisplay::initScreen( int nScreen ) const
282 {
283     if( nScreen < 0 || nScreen >= static_cast<int>(m_aScreens.size()) )
284         nScreen = m_nDefaultScreen;
285     ScreenData& rSD = const_cast<ScreenData&>(m_aScreens[nScreen]);
286     if( rSD.m_bInit )
287         return;
288 
289     // choose visual for screen
290     SalDisplay::initScreen( nScreen );
291     // now set a gdk default colormap matching the chosen visual to the screen
292     GdkVisual* pVis = gdkx_visual_get( rSD.m_aVisual.visualid );
293     GdkScreen* pScreen = gdk_display_get_screen( m_pGdkDisplay, nScreen );
294     if( pVis )
295     {
296         GdkColormap* pDefCol = gdk_screen_get_default_colormap( pScreen );
297         GdkVisual* pDefVis = gdk_colormap_get_visual( pDefCol );
298         if( pDefVis != pVis )
299         {
300            pDefCol = gdk_x11_colormap_foreign_new( pVis, rSD.m_aColormap.GetXColormap() );
301            gdk_screen_set_default_colormap( pScreen, pDefCol );
302            #if OSL_DEBUG_LEVEL > 1
303            fprintf( stderr, "set new gdk color map for screen %d\n", nScreen );
304            #endif
305         }
306     }
307     #if OSL_DEBUG_LEVEL > 1
308     else
309         fprintf( stderr, "not GdkVisual for visual id %d\n", (int)rSD.m_aVisual.visualid );
310     #endif
311 }
312 
Dispatch(XEvent * pEvent)313 long GtkSalDisplay::Dispatch( XEvent* pEvent )
314 {
315     if( GetDisplay() == pEvent->xany.display )
316     {
317         // let's see if one of our frames wants to swallow these events
318         // get the child frame
319         for( std::list< SalFrame* >::const_iterator it = m_aFrames.begin();
320              it != m_aFrames.end(); ++it )
321         {
322             if( (GdkNativeWindow)(*it)->GetSystemData()->aWindow == pEvent->xany.window )
323                 return static_cast<GtkSalFrame*>(*it)->Dispatch( pEvent );
324         }
325     }
326 
327     return GDK_FILTER_CONTINUE;
328 }
329 
getFromXPM(const char * pBitmap,const char * pMask,int nWidth,int nHeight,int nXHot,int nYHot)330 GdkCursor* GtkSalDisplay::getFromXPM( const char *pBitmap,
331 									  const char *pMask,
332 									  int nWidth, int nHeight,
333 									  int nXHot, int nYHot )
334 {
335 	GdkScreen *pScreen = gdk_display_get_default_screen( m_pGdkDisplay );
336 	GdkDrawable *pDrawable = GDK_DRAWABLE( gdk_screen_get_root_window (pScreen) );
337 	GdkBitmap *pBitmapPix = gdk_bitmap_create_from_data
338 			( pDrawable, pBitmap, nWidth, nHeight );
339 	GdkBitmap *pMaskPix = gdk_bitmap_create_from_data
340 			( pDrawable, pMask, nWidth, nHeight );
341 	GdkColormap *pColormap = gdk_drawable_get_colormap( pDrawable );
342 
343 	GdkColor aWhite = { 0, 0xffff, 0xffff, 0xffff };
344 	GdkColor aBlack = { 0, 0, 0, 0 };
345 
346 	gdk_colormap_alloc_color( pColormap, &aBlack, FALSE, TRUE);
347 	gdk_colormap_alloc_color( pColormap, &aWhite, FALSE, TRUE);
348 
349 	return gdk_cursor_new_from_pixmap
350 			( pBitmapPix, pMaskPix,
351 			  &aBlack, &aWhite, nXHot, nYHot);
352 }
353 
354 #define MAKE_CURSOR( vcl_name, name ) \
355 	case vcl_name: \
356 		pCursor = getFromXPM( (const char*)name##curs##_bits, (const char*)name##mask##_bits, \
357 							  name##curs_width, name##curs_height, \
358 							  name##curs_x_hot, name##curs_y_hot ); \
359 		break
360 #define MAP_BUILTIN( vcl_name, gdk_name ) \
361 		case vcl_name: \
362 			pCursor = gdk_cursor_new_for_display( m_pGdkDisplay, gdk_name ); \
363 			break
364 
getCursor(PointerStyle ePointerStyle)365 GdkCursor *GtkSalDisplay::getCursor( PointerStyle ePointerStyle )
366 {
367     if (ePointerStyle >= POINTER_COUNT)
368         return NULL;
369 
370 	if ( !m_aCursors[ ePointerStyle ] )
371 	{
372 		GdkCursor *pCursor = NULL;
373 
374 	    switch( ePointerStyle )
375 	    {
376 			MAP_BUILTIN( POINTER_ARROW, GDK_LEFT_PTR );
377 			MAP_BUILTIN( POINTER_TEXT, GDK_XTERM );
378 			MAP_BUILTIN( POINTER_HELP, GDK_QUESTION_ARROW );
379 			MAP_BUILTIN( POINTER_CROSS, GDK_CROSSHAIR );
380             MAP_BUILTIN( POINTER_WAIT, GDK_WATCH );
381 
382 			MAP_BUILTIN( POINTER_NSIZE, GDK_SB_V_DOUBLE_ARROW );
383 			MAP_BUILTIN( POINTER_SSIZE, GDK_SB_V_DOUBLE_ARROW );
384 			MAP_BUILTIN( POINTER_WSIZE, GDK_SB_H_DOUBLE_ARROW );
385 			MAP_BUILTIN( POINTER_ESIZE, GDK_SB_H_DOUBLE_ARROW );
386 
387 			MAP_BUILTIN( POINTER_NWSIZE, GDK_TOP_LEFT_CORNER );
388 			MAP_BUILTIN( POINTER_NESIZE, GDK_TOP_RIGHT_CORNER );
389 			MAP_BUILTIN( POINTER_SWSIZE, GDK_BOTTOM_LEFT_CORNER );
390 			MAP_BUILTIN( POINTER_SESIZE, GDK_BOTTOM_RIGHT_CORNER );
391 
392 			MAP_BUILTIN( POINTER_WINDOW_NSIZE, GDK_TOP_SIDE );
393 			MAP_BUILTIN( POINTER_WINDOW_SSIZE, GDK_BOTTOM_SIDE );
394 			MAP_BUILTIN( POINTER_WINDOW_WSIZE, GDK_LEFT_SIDE );
395 			MAP_BUILTIN( POINTER_WINDOW_ESIZE, GDK_RIGHT_SIDE );
396 
397 			MAP_BUILTIN( POINTER_WINDOW_NWSIZE, GDK_TOP_LEFT_CORNER );
398 			MAP_BUILTIN( POINTER_WINDOW_NESIZE, GDK_TOP_RIGHT_CORNER );
399 			MAP_BUILTIN( POINTER_WINDOW_SWSIZE, GDK_BOTTOM_LEFT_CORNER );
400 			MAP_BUILTIN( POINTER_WINDOW_SESIZE, GDK_BOTTOM_RIGHT_CORNER );
401 
402 			MAP_BUILTIN( POINTER_HSIZEBAR, GDK_SB_H_DOUBLE_ARROW );
403 			MAP_BUILTIN( POINTER_VSIZEBAR, GDK_SB_V_DOUBLE_ARROW );
404 
405 			MAP_BUILTIN( POINTER_REFHAND, GDK_HAND1 );
406 			MAP_BUILTIN( POINTER_HAND, GDK_HAND2 );
407 			MAP_BUILTIN( POINTER_PEN, GDK_PENCIL );
408 
409 			MAP_BUILTIN( POINTER_HSPLIT, GDK_SB_H_DOUBLE_ARROW );
410 			MAP_BUILTIN( POINTER_VSPLIT, GDK_SB_V_DOUBLE_ARROW );
411 
412 			MAP_BUILTIN( POINTER_MOVE, GDK_FLEUR );
413 
414 			MAKE_CURSOR( POINTER_NULL, null );
415 			MAKE_CURSOR( POINTER_MAGNIFY, magnify_ );
416 			MAKE_CURSOR( POINTER_FILL, fill_ );
417 			MAKE_CURSOR( POINTER_MOVEDATA, movedata_ );
418 			MAKE_CURSOR( POINTER_COPYDATA, copydata_ );
419 			MAKE_CURSOR( POINTER_MOVEFILE, movefile_ );
420 			MAKE_CURSOR( POINTER_COPYFILE, copyfile_ );
421 			MAKE_CURSOR( POINTER_MOVEFILES, movefiles_ );
422 			MAKE_CURSOR( POINTER_COPYFILES, copyfiles_ );
423 			MAKE_CURSOR( POINTER_NOTALLOWED, nodrop_ );
424 			MAKE_CURSOR( POINTER_ROTATE, rotate_ );
425 			MAKE_CURSOR( POINTER_HSHEAR, hshear_ );
426 			MAKE_CURSOR( POINTER_VSHEAR, vshear_ );
427 			MAKE_CURSOR( POINTER_DRAW_LINE, drawline_ );
428 			MAKE_CURSOR( POINTER_DRAW_RECT, drawrect_ );
429 			MAKE_CURSOR( POINTER_DRAW_POLYGON, drawpolygon_ );
430 			MAKE_CURSOR( POINTER_DRAW_BEZIER, drawbezier_ );
431 			MAKE_CURSOR( POINTER_DRAW_ARC, drawarc_ );
432 			MAKE_CURSOR( POINTER_DRAW_PIE, drawpie_ );
433 			MAKE_CURSOR( POINTER_DRAW_CIRCLECUT, drawcirclecut_ );
434 			MAKE_CURSOR( POINTER_DRAW_ELLIPSE, drawellipse_ );
435 			MAKE_CURSOR( POINTER_DRAW_CONNECT, drawconnect_ );
436 			MAKE_CURSOR( POINTER_DRAW_TEXT, drawtext_ );
437 			MAKE_CURSOR( POINTER_MIRROR, mirror_ );
438 			MAKE_CURSOR( POINTER_CROOK, crook_ );
439 			MAKE_CURSOR( POINTER_CROP, crop_ );
440 			MAKE_CURSOR( POINTER_MOVEPOINT, movepoint_ );
441 			MAKE_CURSOR( POINTER_MOVEBEZIERWEIGHT, movebezierweight_ );
442 			MAKE_CURSOR( POINTER_DRAW_FREEHAND, drawfreehand_ );
443 			MAKE_CURSOR( POINTER_DRAW_CAPTION, drawcaption_ );
444 			MAKE_CURSOR( POINTER_LINKDATA, linkdata_ );
445 			MAKE_CURSOR( POINTER_MOVEDATALINK, movedlnk_ );
446 			MAKE_CURSOR( POINTER_COPYDATALINK, copydlnk_ );
447 			MAKE_CURSOR( POINTER_LINKFILE, linkfile_ );
448 			MAKE_CURSOR( POINTER_MOVEFILELINK, moveflnk_ );
449 			MAKE_CURSOR( POINTER_COPYFILELINK, copyflnk_ );
450 			MAKE_CURSOR( POINTER_CHART, chart_ );
451 			MAKE_CURSOR( POINTER_DETECTIVE, detective_ );
452 			MAKE_CURSOR( POINTER_PIVOT_COL, pivotcol_ );
453 			MAKE_CURSOR( POINTER_PIVOT_ROW, pivotrow_ );
454 			MAKE_CURSOR( POINTER_PIVOT_FIELD, pivotfld_ );
455 			MAKE_CURSOR( POINTER_PIVOT_DELETE, pivotdel_ );
456 			MAKE_CURSOR( POINTER_CHAIN, chain_ );
457 			MAKE_CURSOR( POINTER_CHAIN_NOTALLOWED, chainnot_ );
458 			MAKE_CURSOR( POINTER_TIMEEVENT_MOVE, timemove_ );
459 			MAKE_CURSOR( POINTER_TIMEEVENT_SIZE, timesize_ );
460 			MAKE_CURSOR( POINTER_AUTOSCROLL_N, asn_ );
461 			MAKE_CURSOR( POINTER_AUTOSCROLL_S, ass_ );
462 			MAKE_CURSOR( POINTER_AUTOSCROLL_W, asw_ );
463 			MAKE_CURSOR( POINTER_AUTOSCROLL_E, ase_ );
464 			MAKE_CURSOR( POINTER_AUTOSCROLL_NW, asnw_ );
465 			MAKE_CURSOR( POINTER_AUTOSCROLL_NE, asne_ );
466 			MAKE_CURSOR( POINTER_AUTOSCROLL_SW, assw_ );
467 			MAKE_CURSOR( POINTER_AUTOSCROLL_SE, asse_ );
468 			MAKE_CURSOR( POINTER_AUTOSCROLL_NS, asns_ );
469 			MAKE_CURSOR( POINTER_AUTOSCROLL_WE, aswe_ );
470 			MAKE_CURSOR( POINTER_AUTOSCROLL_NSWE, asnswe_ );
471 			MAKE_CURSOR( POINTER_AIRBRUSH, airbrush_ );
472 			MAKE_CURSOR( POINTER_TEXT_VERTICAL, vertcurs_ );
473 
474             // --> FME 2004-07-30 #i32329# Enhanced table selection
475             MAKE_CURSOR( POINTER_TAB_SELECT_S, tblsels_ );
476             MAKE_CURSOR( POINTER_TAB_SELECT_E, tblsele_ );
477             MAKE_CURSOR( POINTER_TAB_SELECT_SE, tblselse_ );
478             MAKE_CURSOR( POINTER_TAB_SELECT_W, tblselw_ );
479             MAKE_CURSOR( POINTER_TAB_SELECT_SW, tblselsw_ );
480             // <--
481 
482             // --> FME 2004-08-16 #i20119# Paintbrush tool
483             MAKE_CURSOR( POINTER_PAINTBRUSH, paintbrush_ );
484             // <--
485 
486 		default:
487 			fprintf( stderr, "pointer %d not implemented", ePointerStyle );
488 			break;
489 		}
490 		if( !pCursor )
491 			pCursor = gdk_cursor_new_for_display( m_pGdkDisplay, GDK_LEFT_PTR );
492 
493 		m_aCursors[ ePointerStyle ] = pCursor;
494 	}
495 
496 	return m_aCursors[ ePointerStyle ];
497 }
498 
CaptureMouse(SalFrame * pSFrame)499 int GtkSalDisplay::CaptureMouse( SalFrame* pSFrame )
500 {
501     GtkSalFrame* pFrame = static_cast<GtkSalFrame*>(pSFrame);
502 
503 	if( !pFrame )
504 	{
505 		if( m_pCapture )
506 			static_cast<GtkSalFrame*>(m_pCapture)->grabPointer( FALSE );
507 		m_pCapture = NULL;
508 		return 0;
509 	}
510 
511 	if( m_pCapture )
512 	{
513 		if( pFrame == m_pCapture )
514 			return 1;
515 		static_cast<GtkSalFrame*>(m_pCapture)->grabPointer( FALSE );
516 	}
517 
518 	m_pCapture = pFrame;
519 	static_cast<GtkSalFrame*>(pFrame)->grabPointer( TRUE );
520     return 1;
521 }
522 
523 /***************************************************************************
524  * class GtkXLib                                                           *
525  ***************************************************************************/
526 
527 class GtkXLib : public SalXLib
528 {
529     GtkSalDisplay       *m_pGtkSalDisplay;
530     std::list<GSource *> m_aSources;
531     GSource             *m_pTimeout;
532 	GSource				*m_pUserEvent;
533     oslMutex             m_aDispatchMutex;
534     oslCondition         m_aDispatchCondition;
535     XIOErrorHandler      m_aOrigGTKXIOErrorHandler;
536 
537 public:
538 	static gboolean      timeoutFn(gpointer data);
539 	static gboolean      userEventFn(gpointer data);
540 
541     GtkXLib();
542     virtual ~GtkXLib();
543 
544     virtual void    Init();
545     virtual void    Yield( bool bWait, bool bHandleAllCurrentEvents );
546     virtual void    Insert( int fd, void* data,
547                             YieldFunc	pending,
548                             YieldFunc	queued,
549                             YieldFunc	handle );
550     virtual void    Remove( int fd );
551 
552 	virtual void    StartTimer( sal_uLong nMS );
553 	virtual void    StopTimer();
554     virtual void    Wakeup();
555     virtual void    PostUserEvent();
556 };
557 
GtkXLib()558 GtkXLib::GtkXLib()
559 {
560 #if OSL_DEBUG_LEVEL > 1
561     fprintf( stderr, "GtkXLib::GtkXLib()\n" );
562 #endif
563     m_pGtkSalDisplay = NULL;
564 	m_pTimeout = NULL;
565 	m_nTimeoutMS = 0;
566     m_pUserEvent = NULL;
567     m_aDispatchCondition = osl_createCondition();
568     m_aDispatchMutex = osl_createMutex();
569     m_aOrigGTKXIOErrorHandler = NULL;
570 }
571 
~GtkXLib()572 GtkXLib::~GtkXLib()
573 {
574 #if OSL_DEBUG_LEVEL > 1
575     fprintf( stderr, "GtkXLib::~GtkXLib()\n" );
576 #endif
577 	StopTimer();
578      // sanity check: at this point nobody should be yielding, but wake them
579      // up anyway before the condition they're waiting on gets destroyed.
580     osl_setCondition( m_aDispatchCondition );
581     osl_destroyCondition( m_aDispatchCondition );
582     osl_destroyMutex( m_aDispatchMutex );
583 
584     PopXErrorLevel();
585     XSetIOErrorHandler (m_aOrigGTKXIOErrorHandler);
586 }
587 
Init()588 void GtkXLib::Init()
589 {
590     int i;
591 #if OSL_DEBUG_LEVEL > 1
592     fprintf( stderr, "GtkXLib::Init()\n" );
593 #endif
594 	XrmInitialize();
595 
596     gtk_set_locale();
597 
598 	/*
599 	 * open connection to X11 Display
600 	 * try in this order:
601 	 *  o  -display command line parameter,
602 	 *  o  $DISPLAY environment variable
603 	 *  o  default display
604 	 */
605 
606     GdkDisplay *pGdkDisp = NULL;
607 
608 	// is there a -display command line parameter?
609     rtl_TextEncoding aEnc = osl_getThreadTextEncoding();
610 	int nParams = osl_getCommandArgCount();
611 	rtl::OString aDisplay;
612 	rtl::OUString aParam, aBin;
613     char** pCmdLineAry = new char*[ nParams+1 ];
614     osl_getExecutableFile( &aParam.pData );
615     osl_getSystemPathFromFileURL( aParam.pData, &aBin.pData );
616     pCmdLineAry[0] = g_strdup( OUStringToOString( aBin, aEnc ).getStr() );
617 	for (i=0; i<nParams; i++)
618 	{
619 		osl_getCommandArg(i, &aParam.pData );
620         OString aBParam( OUStringToOString( aParam, aEnc ) );
621 
622 		if( aParam.equalsAscii( "-display" ) || aParam.equalsAscii( "--display" ) )
623 		{
624 			pCmdLineAry[i+1] = g_strdup( "--display" );
625 			osl_getCommandArg(i+1, &aParam.pData );
626 			aDisplay = rtl::OUStringToOString( aParam, aEnc );
627 		}
628 		else
629 	        pCmdLineAry[i+1] = g_strdup( aBParam.getStr() );
630 	}
631     // add executable
632     nParams++;
633 
634     g_set_application_name(X11SalData::getFrameClassName());
635 
636     // Set consistant name of the root accessible
637     rtl::OUString aAppName = Application::GetAppName();
638     if( aAppName.getLength() > 0 )
639     {
640         rtl::OString aPrgName = rtl::OUStringToOString(aAppName, aEnc);
641         g_set_prgname( aPrgName.getStr());
642     }
643 
644     // init gtk/gdk
645     gtk_init_check( &nParams, &pCmdLineAry );
646 
647     //gtk_init_check sets XError/XIOError handlers, we want our own one
648     m_aOrigGTKXIOErrorHandler = XSetIOErrorHandler ( (XIOErrorHandler)X11SalData::XIOErrorHdl );
649     PushXErrorLevel( !!getenv( "SAL_IGNOREXERRORS" ) );
650 
651 	for (i = 0; i < nParams; i++ )
652 		g_free( pCmdLineAry[i] );
653 	delete [] pCmdLineAry;
654 
655 #if OSL_DEBUG_LEVEL > 1
656 	if (g_getenv ("SAL_DEBUG_UPDATES"))
657 		gdk_window_set_debug_updates (TRUE);
658 #endif
659 
660     pGdkDisp = gdk_display_get_default();
661 	if ( !pGdkDisp )
662 	{
663 	    rtl::OUString aProgramFileURL;
664         osl_getExecutableFile( &aProgramFileURL.pData );
665 	    rtl::OUString aProgramSystemPath;
666         osl_getSystemPathFromFileURL (aProgramFileURL.pData, &aProgramSystemPath.pData);
667         rtl::OString  aProgramName = rtl::OUStringToOString(
668                                             aProgramSystemPath,
669                                             osl_getThreadTextEncoding() );
670 		fprintf( stderr, "%s X11 error: Can't open display: %s\n",
671 				aProgramName.getStr(), aDisplay.getStr());
672 		fprintf( stderr, "   Set DISPLAY environment variable, use -display option\n");
673 		fprintf( stderr, "   or check permissions of your X-Server\n");
674 		fprintf( stderr, "   (See \"man X\" resp. \"man xhost\" for details)\n");
675 		fflush( stderr );
676 		exit(0);
677 	}
678 
679 	/*
680 	 * if a -display switch was used, we need
681 	 * to set the environment accoringly since
682 	 * the clipboard build another connection
683 	 * to the xserver using $DISPLAY
684 	 */
685 	rtl::OUString envVar(RTL_CONSTASCII_USTRINGPARAM("DISPLAY"));
686 	const gchar *name = gdk_display_get_name( pGdkDisp );
687 	rtl::OUString envValue(name, strlen(name), aEnc);
688 	osl_setEnvironment(envVar.pData, envValue.pData);
689 
690 	Display *pDisp = gdk_x11_display_get_xdisplay( pGdkDisp );
691 
692 	m_pGtkSalDisplay = new GtkSalDisplay( pGdkDisp );
693 
694     gdk_window_add_filter( NULL, call_filterGdkEvent, m_pGtkSalDisplay );
695 
696     PushXErrorLevel( true );
697 	SalI18N_KeyboardExtension *pKbdExtension = new SalI18N_KeyboardExtension( pDisp );
698 	XSync( pDisp, False );
699 
700 	pKbdExtension->UseExtension( ! HasXErrorOccured() );
701     PopXErrorLevel();
702 
703 	m_pGtkSalDisplay->SetKbdExtension( pKbdExtension );
704 
705     g_signal_connect( G_OBJECT(gdk_keymap_get_default()), "keys_changed", G_CALLBACK(signalKeysChanged), m_pGtkSalDisplay );
706 
707     // add signal handler to notify screen size changes
708     int nScreens = gdk_display_get_n_screens( pGdkDisp );
709     for( int n = 0; n < nScreens; n++ )
710     {
711         GdkScreen *pScreen = gdk_display_get_screen( pGdkDisp, n );
712         if( pScreen )
713         {
714             g_signal_connect( G_OBJECT(pScreen), "size-changed", G_CALLBACK(signalScreenSizeChanged), m_pGtkSalDisplay );
715             if( ! gtk_check_version( 2, 14, 0 ) ) // monitors-changed came in with 2.14, avoid an assertion
716                 g_signal_connect( G_OBJECT(pScreen), "monitors-changed", G_CALLBACK(signalMonitorsChanged), m_pGtkSalDisplay );
717         }
718     }
719 }
720 
721 extern "C"
722 {
call_timeoutFn(gpointer data)723     gboolean call_timeoutFn(gpointer data)
724     {
725         return GtkXLib::timeoutFn(data);
726     }
727 }
728 
timeoutFn(gpointer data)729 gboolean GtkXLib::timeoutFn(gpointer data)
730 {
731 	SalData *pSalData = GetSalData();
732 	GtkXLib *pThis = (GtkXLib *) data;
733 
734 	pSalData->m_pInstance->GetYieldMutex()->acquire();
735 
736 	if( pThis->m_pTimeout )
737 	{
738 		g_source_unref (pThis->m_pTimeout);
739 		pThis->m_pTimeout = NULL;
740 	}
741 
742 	// Auto-restart immediately
743 	pThis->StartTimer( pThis->m_nTimeoutMS );
744 
745 	GetX11SalData()->Timeout();
746 
747 	pSalData->m_pInstance->GetYieldMutex()->release();
748 
749 	return FALSE;
750 }
751 
StartTimer(sal_uLong nMS)752 void GtkXLib::StartTimer( sal_uLong nMS )
753 {
754 	m_nTimeoutMS = nMS; // for restarting
755 
756 	if (m_pTimeout)
757 	{
758 		g_source_destroy (m_pTimeout);
759 		g_source_unref (m_pTimeout);
760 	}
761 
762 	m_pTimeout = g_timeout_source_new (m_nTimeoutMS);
763     // #i36226# timers should be executed with lower priority
764     // than XEvents like in generic plugin
765     g_source_set_priority( m_pTimeout, G_PRIORITY_LOW );
766 	g_source_set_can_recurse (m_pTimeout, TRUE);
767 	g_source_set_callback (m_pTimeout, call_timeoutFn,
768 						   (gpointer) this, NULL);
769 	g_source_attach (m_pTimeout, g_main_context_default ());
770 
771     SalXLib::StartTimer( nMS );
772 }
773 
StopTimer()774 void GtkXLib::StopTimer()
775 {
776     SalXLib::StopTimer();
777 
778 	if (m_pTimeout)
779 	{
780 		g_source_destroy (m_pTimeout);
781 		g_source_unref (m_pTimeout);
782 		m_pTimeout = NULL;
783 	}
784 }
785 
786 extern "C"
787 {
call_userEventFn(gpointer data)788     gboolean call_userEventFn( gpointer data )
789     {
790         return GtkXLib::userEventFn( data );
791     }
792 }
793 
userEventFn(gpointer data)794 gboolean GtkXLib::userEventFn(gpointer data)
795 {
796 	gboolean bContinue;
797 	GtkXLib *pThis = (GtkXLib *) data;
798 	SalData *pSalData = GetSalData();
799 
800 	pSalData->m_pInstance->GetYieldMutex()->acquire();
801 	pThis->m_pGtkSalDisplay->EventGuardAcquire();
802 
803 	if( !pThis->m_pGtkSalDisplay->HasMoreEvents() )
804 	{
805 		if( pThis->m_pUserEvent )
806 		{
807 			g_source_unref (pThis->m_pUserEvent);
808 			pThis->m_pUserEvent = NULL;
809 		}
810 		bContinue = FALSE;
811 	}
812 	else
813 		bContinue = TRUE;
814 
815 	pThis->m_pGtkSalDisplay->EventGuardRelease();
816 
817 	pThis->m_pGtkSalDisplay->DispatchInternalEvent();
818 
819 	pSalData->m_pInstance->GetYieldMutex()->release();
820 
821 	return bContinue;
822 }
823 
824 // hEventGuard_ held during this invocation
PostUserEvent()825 void GtkXLib::PostUserEvent()
826 {
827 	if( !m_pUserEvent ) // not pending anyway
828 	{
829 		m_pUserEvent = g_idle_source_new();
830 		g_source_set_priority( m_pUserEvent, G_PRIORITY_HIGH );
831 		g_source_set_can_recurse (m_pUserEvent, TRUE);
832 		g_source_set_callback (m_pUserEvent, call_userEventFn,
833 							   (gpointer) this, NULL);
834 		g_source_attach (m_pUserEvent, g_main_context_default ());
835 	}
836     Wakeup();
837 }
838 
Wakeup()839 void GtkXLib::Wakeup()
840 {
841 	g_main_context_wakeup( g_main_context_default () );
842 }
843 
Yield(bool bWait,bool bHandleAllCurrentEvents)844 void GtkXLib::Yield( bool bWait, bool bHandleAllCurrentEvents )
845 {
846     /* #i33212# only enter g_main_context_iteration in one thread at any one
847      * time, else one of them potentially will never end as long as there is
848      * another thread in in there. Having only one yieldin thread actually dispatch
849      * fits the vcl event model (see e.g. the generic plugin).
850      */
851 
852     bool bDispatchThread = false;
853     gboolean wasEvent = FALSE;
854     {
855         // release YieldMutex (and re-acquire at block end)
856         YieldMutexReleaser aReleaser;
857         if( osl_tryToAcquireMutex( m_aDispatchMutex ) )
858             bDispatchThread = true;
859         else if( ! bWait )
860             return; // someone else is waiting already, return
861 
862 
863         if( bDispatchThread )
864         {
865             int nMaxEvents = bHandleAllCurrentEvents ? 100 : 1;
866             gboolean wasOneEvent = TRUE;
867             while( nMaxEvents-- && wasOneEvent )
868             {
869                 wasOneEvent = g_main_context_iteration( NULL, FALSE );
870                 if( wasOneEvent )
871                     wasEvent = TRUE;
872             }
873             if( bWait && ! wasEvent )
874                 wasEvent = g_main_context_iteration( NULL, TRUE );
875         }
876         else if( bWait )
877        	{
878             /* #i41693# in case the dispatch thread hangs in join
879              * for this thread the condition will never be set
880              * workaround: timeout of 1 second a emergency exit
881              */
882             // we are the dispatch thread
883             osl_resetCondition( m_aDispatchCondition );
884             TimeValue aValue = { 1, 0 };
885             osl_waitCondition( m_aDispatchCondition, &aValue );
886         }
887     }
888 
889     if( bDispatchThread )
890     {
891         osl_releaseMutex( m_aDispatchMutex );
892         if( wasEvent )
893             osl_setCondition( m_aDispatchCondition ); // trigger non dispatch thread yields
894     }
895 }
896 
897 extern "C" {
898 
899 typedef struct {
900 	GSource       source;
901 
902 	GPollFD       pollfd;
903 	GIOCondition  condition;
904 
905 	YieldFunc     pending;
906 	YieldFunc     handle;
907 	gpointer      user_data;
908 } SalWatch;
909 
910 static gboolean
sal_source_prepare(GSource * source,gint * timeout)911 sal_source_prepare (GSource *source,
912 					gint    *timeout)
913 {
914 	SalWatch *watch = (SalWatch *)source;
915 
916 	*timeout = -1;
917 
918 	if (watch->pending &&
919 	    watch->pending (watch->pollfd.fd, watch->user_data)) {
920 		watch->pollfd.revents |= watch->condition;
921 		return TRUE;
922 	}
923 
924 	return FALSE;
925 }
926 
927 static gboolean
sal_source_check(GSource * source)928 sal_source_check (GSource *source)
929 {
930 	SalWatch *watch = (SalWatch *)source;
931 
932 	return watch->pollfd.revents & watch->condition;
933 }
934 
935 static gboolean
sal_source_dispatch(GSource * source,GSourceFunc,gpointer)936 sal_source_dispatch (GSource    *source,
937 					 GSourceFunc,
938 					 gpointer)
939 {
940 	SalData *pSalData = GetSalData();
941 	SalWatch *watch = (SalWatch *) source;
942 
943 	pSalData->m_pInstance->GetYieldMutex()->acquire();
944 
945 	watch->handle (watch->pollfd.fd, watch->user_data);
946 
947 	pSalData->m_pInstance->GetYieldMutex()->release();
948 
949 	return TRUE;
950 }
951 
952 static void
sal_source_finalize(GSource *)953 sal_source_finalize (GSource*)
954 {
955 }
956 
957 static GSourceFuncs sal_source_watch_funcs = {
958 	sal_source_prepare,
959 	sal_source_check,
960 	sal_source_dispatch,
961 	sal_source_finalize,
962     NULL,
963     NULL
964 };
965 
966 static GSource *
sal_source_create_watch(int fd,GIOCondition condition,YieldFunc pending,YieldFunc handle,gpointer user_data)967 sal_source_create_watch (int           fd,
968                          GIOCondition  condition,
969                          YieldFunc     pending,
970                          YieldFunc     handle,
971                          gpointer      user_data)
972 {
973 	GSource      *source;
974 	SalWatch     *watch;
975 	GMainContext *context = g_main_context_default ();
976 
977 	source = g_source_new (&sal_source_watch_funcs,
978 			       sizeof (SalWatch));
979 	watch = (SalWatch *) source;
980 
981 	watch->pollfd.fd     = fd;
982 	watch->pollfd.events = condition;
983 	watch->condition = condition;
984 	watch->pending   = pending;
985 	watch->handle    = handle;
986 	watch->user_data = user_data;
987 
988 	g_source_set_can_recurse (source, TRUE);
989 	g_source_add_poll (source, &watch->pollfd);
990 	g_source_attach (source, context);
991 
992 	return source;
993 }
994 
995 } // extern "C"
996 
Insert(int nFD,void * data,YieldFunc pending,YieldFunc,YieldFunc handle)997 void GtkXLib::Insert( int       nFD,
998 		      void     *data,
999 		      YieldFunc pending,
1000 		      YieldFunc,
1001 		      YieldFunc handle )
1002 {
1003 	GSource *source = sal_source_create_watch
1004 		( nFD, (GIOCondition) ((G_IO_IN|G_IO_PRI) |
1005 				       (G_IO_ERR|G_IO_HUP|G_IO_NVAL)),
1006 		  pending, handle, data );
1007 	m_aSources.push_back( source );
1008 }
1009 
Remove(int nFD)1010 void GtkXLib::Remove( int nFD )
1011 {
1012     ::std::list< GSource * >::iterator it;
1013 
1014 	for (it = m_aSources.begin(); it != m_aSources.end(); ++it)
1015 	{
1016 		SalWatch *watch = (SalWatch *) *it;
1017 
1018 		if (watch->pollfd.fd == nFD)
1019 		{
1020             m_aSources.erase( it );
1021 
1022 			g_source_destroy ((GSource *)watch);
1023 			g_source_unref   ((GSource *)watch);
1024 			return;
1025 		}
1026 	}
1027 }
1028 
1029 /**********************************************************************
1030  * class GtkData                                                      *
1031  **********************************************************************/
1032 
~GtkData()1033 GtkData::~GtkData()
1034 {
1035 }
1036 
Init()1037 void GtkData::Init()
1038 {
1039     pXLib_ = new GtkXLib();
1040     pXLib_->Init();
1041 }
1042