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 "vcl/svapp.hxx"
28 
29 #include "unx/gtk/gtkframe.hxx"
30 #include "unx/gtk/gtkdata.hxx"
31 #include "unx/gtk/gtkinst.hxx"
32 #include "unx/gtk/gtkgdi.hxx"
33 
34 #include "unx/pspgraphics.h"
35 #include "unx/saldata.hxx"
36 #include "unx/saldisp.hxx"
37 
38 #include <cstdio>
39 #include <cmath>
40 #include <vector>
41 #include <algorithm>
42 #include <hash_map>
43 
44 typedef struct _cairo_font_options cairo_font_options_t;
45 
46 // initialize statics
47 sal_Bool GtkSalGraphics::bThemeChanged = sal_True;
48 sal_Bool GtkSalGraphics::bNeedPixmapPaint = sal_False;
49 sal_Bool GtkSalGraphics::bGlobalNeedPixmapPaint = sal_False;
50 sal_Bool GtkSalGraphics::bToolbarGripWorkaround = sal_False;
51 sal_Bool GtkSalGraphics::bNeedButtonStyleAsEditBackgroundWorkaround = sal_False;
52 
53 GtkSalGraphics::~GtkSalGraphics()
54 {
55 }
56 
57 
58 using namespace rtl;
59 
60 /*************************************
61  * Cached native widget objects
62  *************************************/
63 class NWPixmapCacheList;
64 class NWPixmapCache;
65 struct NWFWidgetData
66 {
67     GtkWidget *	gCacheWindow;
68     GtkWidget *	gDumbContainer;
69 
70     GtkWidget *	gBtnWidget;
71     GtkWidget *	gRadioWidget;
72     GtkWidget *	gRadioWidgetSibling;
73     GtkWidget *	gCheckWidget;
74     GtkWidget *	gScrollHorizWidget;
75     GtkWidget *	gScrollVertWidget;
76     GtkWidget *	gArrowWidget;
77     GtkWidget *	gDropdownWidget;
78     GtkWidget *	gEditBoxWidget;
79     GtkWidget *	gSpinButtonWidget;
80     GtkWidget *	gNotebookWidget;
81     GtkWidget *	gOptionMenuWidget;
82     GtkWidget *	gComboWidget;
83     GtkWidget *	gScrolledWindowWidget;
84     GtkWidget *  gToolbarWidget;
85     GtkWidget *  gToolbarButtonWidget;
86     GtkWidget *  gToolbarToggleWidget;
87     GtkWidget *  gHandleBoxWidget;
88     GtkWidget *  gMenubarWidget;
89     GtkWidget *  gMenuItemMenubarWidget;
90     GtkWidget *  gMenuWidget;
91     GtkWidget *  gMenuItemMenuWidget;
92     GtkWidget *  gMenuItemCheckMenuWidget;
93     GtkWidget *  gMenuItemRadioMenuWidget;
94     GtkWidget *  gImageMenuItem;
95     GtkWidget *  gTooltipPopup;
96     GtkWidget *  gProgressBar;
97     GtkWidget *  gTreeView;
98     GtkWidget *  gHScale;
99     GtkWidget *  gVScale;
100 
101     NWPixmapCacheList* gNWPixmapCacheList;
102     NWPixmapCache* gCacheTabItems;
103     NWPixmapCache* gCacheTabPages;
104 
105     NWFWidgetData() :
106         gCacheWindow( NULL ),
107         gDumbContainer( NULL ),
108         gBtnWidget( NULL ),
109         gRadioWidget( NULL ),
110         gRadioWidgetSibling( NULL ),
111         gCheckWidget( NULL ),
112         gScrollHorizWidget( NULL ),
113         gScrollVertWidget( NULL ),
114         gArrowWidget( NULL ),
115         gDropdownWidget( NULL ),
116         gEditBoxWidget( NULL ),
117         gSpinButtonWidget( NULL ),
118         gNotebookWidget( NULL ),
119         gOptionMenuWidget( NULL ),
120         gComboWidget( NULL ),
121         gScrolledWindowWidget( NULL ),
122         gToolbarWidget( NULL ),
123         gToolbarButtonWidget( NULL ),
124         gToolbarToggleWidget( NULL ),
125         gHandleBoxWidget( NULL ),
126         gMenubarWidget( NULL ),
127         gMenuItemMenubarWidget( NULL ),
128         gMenuWidget( NULL ),
129         gMenuItemMenuWidget( NULL ),
130         gMenuItemCheckMenuWidget( NULL ),
131         gMenuItemRadioMenuWidget( NULL ),
132         gImageMenuItem( NULL ),
133         gTooltipPopup( NULL ),
134         gProgressBar( NULL ),
135         gTreeView( NULL ),
136         gHScale( NULL ),
137         gVScale( NULL ),
138         gNWPixmapCacheList( NULL ),
139         gCacheTabItems( NULL ),
140         gCacheTabPages( NULL )
141     {}
142 };
143 
144 // Keep a hash table of Widgets->default flags so that we can
145 // easily and quickly reset each to a default state before using
146 // them
147 static std::hash_map<long, guint>	gWidgetDefaultFlags;
148 static std::vector<NWFWidgetData>   gWidgetData;
149 
150 static const GtkBorder aDefDefBorder		= { 1, 1, 1, 1 };
151 
152 // Some GTK defaults
153 #define MIN_ARROW_SIZE					11
154 #define BTN_CHILD_SPACING				1
155 #define MIN_SPIN_ARROW_WIDTH				6
156 
157 
158 static void NWEnsureGTKRadio			( int nScreen );
159 static void NWEnsureGTKButton			( int nScreen );
160 static void NWEnsureGTKCheck			( int nScreen );
161 static void NWEnsureGTKScrollbars		( int nScreen );
162 static void NWEnsureGTKArrow			( int nScreen );
163 static void NWEnsureGTKEditBox			( int nScreen );
164 static void NWEnsureGTKSpinButton		( int nScreen );
165 static void NWEnsureGTKNotebook			( int nScreen );
166 static void NWEnsureGTKOptionMenu		( int nScreen );
167 static void NWEnsureGTKCombo			( int nScreen );
168 static void NWEnsureGTKScrolledWindow	( int nScreen );
169 static void NWEnsureGTKToolbar			( int nScreen );
170 static void NWEnsureGTKMenubar          ( int nScreen );
171 static void NWEnsureGTKMenu             ( int nScreen );
172 static void NWEnsureGTKTooltip          ( int nScreen );
173 static void NWEnsureGTKProgressBar      ( int nScreen );
174 static void NWEnsureGTKTreeView         ( int nScreen );
175 static void NWEnsureGTKSlider           ( int nScreen );
176 
177 static void NWConvertVCLStateToGTKState( ControlState nVCLState, GtkStateType* nGTKState, GtkShadowType* nGTKShadow );
178 static void NWAddWidgetToCacheWindow( GtkWidget* widget, int nScreen );
179 static void NWSetWidgetState( GtkWidget* widget, ControlState nState, GtkStateType nGtkState );
180 
181 static void NWCalcArrowRect( const Rectangle& rButton, Rectangle& rArrow );
182 
183 /*
184  * Individual helper functions
185  *
186  */
187 
188 //---
189 static Rectangle NWGetButtonArea( int nScreen, ControlType nType, ControlPart nPart, Rectangle aAreaRect, ControlState nState,
190 								const ImplControlValue& aValue, const OUString& rCaption );
191 
192 //---
193 static Rectangle NWGetEditBoxPixmapRect( int nScreen, ControlType nType, ControlPart nPart, Rectangle aAreaRect, ControlState nState,
194 							const ImplControlValue& aValue, const OUString& rCaption );
195 
196 static void NWPaintOneEditBox( int nScreen, GdkDrawable * gdkDrawable, GdkRectangle *gdkRect,
197                                ControlType nType, ControlPart nPart, Rectangle aEditBoxRect,
198                                ControlState nState, const ImplControlValue& aValue,
199                                const OUString& rCaption );
200 
201 //---
202 static Rectangle NWGetSpinButtonRect( int nScreen, ControlType nType, ControlPart nPart, Rectangle aAreaRect, ControlState nState,
203 							const ImplControlValue& aValue, const OUString& rCaption );
204 
205 static void NWPaintOneSpinButton( int nScreen, GdkPixmap * pixmap, ControlType nType, ControlPart nPart, Rectangle aAreaRect,
206 							ControlState nState, const ImplControlValue& aValue,
207 							const OUString& rCaption );
208 //---
209 static Rectangle NWGetComboBoxButtonRect( int nScreen, ControlType nType, ControlPart nPart, Rectangle aAreaRect, ControlState nState,
210 							const ImplControlValue& aValue, const OUString& rCaption );
211 
212 //---
213 static Rectangle NWGetListBoxButtonRect( int nScreen, ControlType nType, ControlPart nPart, Rectangle aAreaRect, ControlState nState,
214 							const ImplControlValue& aValue, const OUString& rCaption );
215 
216 static Rectangle NWGetListBoxIndicatorRect( int nScreen, ControlType nType, ControlPart nPart, Rectangle aAreaRect, ControlState nState,
217 							const ImplControlValue& aValue, const OUString& rCaption );
218 
219 static Rectangle NWGetToolbarRect( int nScreen,
220                                    ControlType nType,
221                                    ControlPart nPart,
222                                    Rectangle aAreaRect,
223                                    ControlState nState,
224                                    const ImplControlValue& aValue,
225                                    const OUString& rCaption );
226 //---
227 
228 static Rectangle NWGetScrollButtonRect(	int nScreen, ControlPart nPart, Rectangle aAreaRect );
229 //---
230 
231 /*********************************************************
232  * PixmapCache
233  *********************************************************/
234 
235 // as some native widget drawing operations are pretty slow
236 // with certain themes (eg tabpages)
237 // this cache can be used to cache the corresponding pixmap
238 // see NWPaintGTKTabItem
239 
240 class NWPixmapCacheData
241 {
242 public:
243     ControlType m_nType;
244     ControlState m_nState;
245     Rectangle   m_pixmapRect;
246     GdkPixmap*  m_pixmap;
247 
248     NWPixmapCacheData() : m_nType(0), m_nState(0), m_pixmap(0) {}
249     ~NWPixmapCacheData()
250         { SetPixmap( NULL ); };
251     void SetPixmap( GdkPixmap* pPixmap );
252 };
253 
254 class NWPixmapCache
255 {
256     int m_size;
257     int m_idx;
258     int m_screen;
259     NWPixmapCacheData* pData;
260 public:
261     NWPixmapCache( int nScreen );
262     ~NWPixmapCache();
263 
264     void SetSize( int n)
265         { delete [] pData; m_idx = 0; m_size = n; pData = new NWPixmapCacheData[m_size]; }
266     int GetSize() { return m_size; }
267 
268     sal_Bool Find( ControlType aType, ControlState aState, const Rectangle& r_pixmapRect, GdkPixmap** pPixmap );
269     void Fill( ControlType aType, ControlState aState, const Rectangle& r_pixmapRect, GdkPixmap* pPixmap );
270 
271     void ThemeChanged();
272 };
273 
274 class NWPixmapCacheList
275 {
276 public:
277     ::std::vector< NWPixmapCache* > mCaches;
278 
279     void AddCache( NWPixmapCache *pCache );
280     void RemoveCache( NWPixmapCache *pCache );
281     void ThemeChanged();
282 };
283 
284 // --- implementation ---
285 
286 void NWPixmapCacheData::SetPixmap( GdkPixmap* pPixmap )
287 {
288     if( m_pixmap )
289         g_object_unref( m_pixmap );
290 
291     m_pixmap = pPixmap;
292 
293     if( m_pixmap )
294         g_object_ref( m_pixmap );
295 }
296 
297 
298 NWPixmapCache::NWPixmapCache( int nScreen )
299 {
300     m_idx = 0;
301     m_size = 0;
302     m_screen = nScreen;
303     pData = NULL;
304     if( gWidgetData[m_screen].gNWPixmapCacheList )
305         gWidgetData[m_screen].gNWPixmapCacheList->AddCache(this);
306 }
307 NWPixmapCache::~NWPixmapCache()
308 {
309     if( gWidgetData[m_screen].gNWPixmapCacheList )
310         gWidgetData[m_screen].gNWPixmapCacheList->RemoveCache(this);
311     delete[] pData;
312 }
313 void NWPixmapCache::ThemeChanged()
314 {
315     // throw away cached pixmaps
316     int i;
317     for(i=0; i<m_size; i++)
318         pData[i].SetPixmap( NULL );
319 }
320 
321 sal_Bool  NWPixmapCache::Find( ControlType aType, ControlState aState, const Rectangle& r_pixmapRect, GdkPixmap** pPixmap )
322 {
323     aState &= ~CTRL_CACHING_ALLOWED; // mask clipping flag
324     int i;
325     for(i=0; i<m_size; i++)
326     {
327         if( pData[i].m_nType == aType &&
328             pData[i].m_nState == aState &&
329             pData[i].m_pixmapRect.GetWidth() == r_pixmapRect.GetWidth() &&
330             pData[i].m_pixmapRect.GetHeight() == r_pixmapRect.GetHeight() &&
331             pData[i].m_pixmap != NULL )
332         {
333             *pPixmap = pData[i].m_pixmap;
334             return sal_True;
335         }
336     }
337     return sal_False;
338 }
339 
340 void NWPixmapCache::Fill( ControlType aType, ControlState aState, const Rectangle& r_pixmapRect, GdkPixmap* pPixmap )
341 {
342     if( !(aState & CTRL_CACHING_ALLOWED) )
343         return;
344 
345     aState &= ~CTRL_CACHING_ALLOWED; // mask clipping flag
346     m_idx = (m_idx+1) % m_size; // just wrap
347     pData[m_idx].m_nType = aType;
348     pData[m_idx].m_nState = aState;
349     pData[m_idx].m_pixmapRect = r_pixmapRect;
350     pData[m_idx].SetPixmap( pPixmap );
351 }
352 
353 
354 void NWPixmapCacheList::AddCache( NWPixmapCache* pCache )
355 {
356     mCaches.push_back( pCache );
357 }
358 void NWPixmapCacheList::RemoveCache( NWPixmapCache* pCache )
359 {
360     ::std::vector< NWPixmapCache* >::iterator p;
361     p = ::std::find( mCaches.begin(), mCaches.end(), pCache );
362     if( p != mCaches.end() )
363         mCaches.erase( p );
364 }
365 void NWPixmapCacheList::ThemeChanged( )
366 {
367     ::std::vector< NWPixmapCache* >::iterator p = mCaches.begin();
368     while( p != mCaches.end() )
369     {
370         (*p)->ThemeChanged();
371         p++;
372     }
373 }
374 
375 
376 /*********************************************************
377  * Make border manipulation easier
378  *********************************************************/
379 inline void NW_gtk_border_set_from_border( GtkBorder& aDst, const GtkBorder * pSrc )
380 {
381 	aDst.left		= pSrc->left;
382 	aDst.top		= pSrc->top;
383 	aDst.right	= pSrc->right;
384 	aDst.bottom	= pSrc->bottom;
385 }
386 
387 
388 /*********************************************************
389  * Initialize GTK and local stuff
390  *********************************************************/
391 void GtkData::initNWF( void )
392 {
393     ImplSVData* pSVData = ImplGetSVData();
394 
395     // draw no border for popup menus (NWF draws its own)
396     pSVData->maNWFData.mbFlatMenu = true;
397 
398     // draw separate buttons for toolbox dropdown items
399     pSVData->maNWFData.mbToolboxDropDownSeparate = true;
400 
401     // small extra border around menu items
402     pSVData->maNWFData.mnMenuFormatExtraBorder = 1;
403 
404     // draw toolbars in separate lines
405     pSVData->maNWFData.mbDockingAreaSeparateTB = true;
406 
407     // open first menu on F10
408     pSVData->maNWFData.mbOpenMenuOnF10 = true;
409 
410     // omit GetNativeControl while painting (see brdwin.cxx)
411     pSVData->maNWFData.mbCanDrawWidgetAnySize = true;
412 
413     int nScreens = GetX11SalData()->GetDisplay()->GetScreenCount();
414     gWidgetData = std::vector<NWFWidgetData>( nScreens );
415     for( int i = 0; i < nScreens; i++ )
416         gWidgetData[i].gNWPixmapCacheList = new NWPixmapCacheList;
417 
418 
419     if( SalGetDesktopEnvironment().equalsAscii( "KDE" ) )
420     {
421         // #i97196# ensure a widget exists and the style engine was loaded
422         NWEnsureGTKButton( 0 );
423         if( g_type_from_name( "QtEngineStyle" ) )
424         {
425             // KDE 3.3 invented a bug in the qt<->gtk theme engine
426             // that makes direct rendering impossible: they totally
427             // ignore the clip rectangle passed to the paint methods
428             GtkSalGraphics::bNeedPixmapPaint = GtkSalGraphics::bGlobalNeedPixmapPaint = true;
429         }
430     }
431     static const char* pEnv = getenv( "SAL_GTK_USE_PIXMAPPAINT" );
432     if( pEnv && *pEnv )
433         GtkSalGraphics::bNeedPixmapPaint = GtkSalGraphics::bGlobalNeedPixmapPaint = true;
434 
435     #if OSL_DEBUG_LEVEL > 1
436     std::fprintf( stderr, "GtkPlugin: using %s NWF\n",
437              GtkSalGraphics::bNeedPixmapPaint ? "offscreen" : "direct" );
438     #endif
439 }
440 
441 
442 /*********************************************************
443  * Release GTK and local stuff
444  *********************************************************/
445 void GtkData::deInitNWF( void )
446 {
447 
448     for( unsigned int i = 0; i < gWidgetData.size(); i++ )
449     {
450         // free up global widgets
451         // gtk_widget_destroy will in turn destroy the child hierarchy
452         // so only destroy disjunct hierachies
453         if( gWidgetData[i].gCacheWindow )
454             gtk_widget_destroy( gWidgetData[i].gCacheWindow );
455         if( gWidgetData[i].gMenuWidget )
456             gtk_widget_destroy( gWidgetData[i].gMenuWidget );
457         if( gWidgetData[i].gTooltipPopup )
458             gtk_widget_destroy( gWidgetData[i].gTooltipPopup );
459         delete gWidgetData[i].gCacheTabPages;
460         gWidgetData[i].gCacheTabPages = NULL;
461         delete gWidgetData[i].gCacheTabItems;
462         gWidgetData[i].gCacheTabItems = NULL;
463         delete gWidgetData[i].gNWPixmapCacheList;
464         gWidgetData[i].gNWPixmapCacheList = NULL;
465     }
466 }
467 
468 
469 /**********************************************************
470  * track clip region
471  **********************************************************/
472 void GtkSalGraphics::ResetClipRegion()
473 {
474     m_aClipRegion.SetNull();
475     X11SalGraphics::ResetClipRegion();
476 }
477 
478 bool GtkSalGraphics::setClipRegion( const Region& i_rClip )
479 {
480     m_aClipRegion = i_rClip;
481     bool bRet = X11SalGraphics::setClipRegion( m_aClipRegion );
482     if( m_aClipRegion.IsEmpty() )
483         m_aClipRegion.SetNull();
484     return bRet;
485 }
486 
487 void GtkSalGraphics::copyBits( const SalTwoRect* pPosAry,
488                                SalGraphics* pSrcGraphics )
489 {
490     GtkSalFrame* pFrame = GetGtkFrame();
491     XLIB_Window aWin = None;
492     if( pFrame && m_pWindow )
493     {
494         /* #i64117# some themes set the background pixmap VERY frequently */
495         GdkWindow* pWin = GTK_WIDGET(m_pWindow)->window;
496         if( pWin )
497         {
498             aWin = GDK_WINDOW_XWINDOW(pWin);
499             if( aWin != None )
500                 XSetWindowBackgroundPixmap( pFrame->getDisplay()->GetDisplay(),
501                                             aWin,
502                                             None );
503         }
504     }
505     X11SalGraphics::copyBits( pPosAry, pSrcGraphics );
506     if( pFrame && pFrame->getBackgroundPixmap() != None )
507         XSetWindowBackgroundPixmap( pFrame->getDisplay()->GetDisplay(),
508                                     aWin,
509                                     pFrame->getBackgroundPixmap() );
510 }
511 
512 /*
513  * IsNativeControlSupported()
514  *
515  *  Returns sal_True if the platform supports native
516  *  drawing of the control defined by nPart
517  */
518 sal_Bool GtkSalGraphics::IsNativeControlSupported( ControlType nType, ControlPart nPart )
519 {
520 	if (
521 		((nType==CTRL_PUSHBUTTON)  && (nPart==PART_ENTIRE_CONTROL)) 	||
522  		((nType==CTRL_RADIOBUTTON) && (nPart==PART_ENTIRE_CONTROL))		||
523 		((nType==CTRL_CHECKBOX)    && (nPart==PART_ENTIRE_CONTROL))		||
524 		((nType==CTRL_SCROLLBAR) &&
525 				(  (nPart==PART_DRAW_BACKGROUND_HORZ)
526 				|| (nPart==PART_DRAW_BACKGROUND_VERT)
527 				|| (nPart==PART_ENTIRE_CONTROL)
528                 || (nPart==HAS_THREE_BUTTONS) )  				)	||
529 		((nType==CTRL_EDITBOX) &&
530 				(  (nPart==PART_ENTIRE_CONTROL)
531 				|| (nPart==HAS_BACKGROUND_TEXTURE) ) 			)	||
532 		((nType==CTRL_MULTILINE_EDITBOX) &&
533 				(  (nPart==PART_ENTIRE_CONTROL)
534 				|| (nPart==HAS_BACKGROUND_TEXTURE) ) 			)	||
535 		((nType==CTRL_SPINBOX) &&
536 				(  (nPart==PART_ENTIRE_CONTROL)
537 				|| (nPart==PART_ALL_BUTTONS)
538 				|| (nPart==HAS_BACKGROUND_TEXTURE) )			)	||
539 		((nType==CTRL_SPINBUTTONS) &&
540 				(  (nPart==PART_ENTIRE_CONTROL)
541 				|| (nPart==PART_ALL_BUTTONS)	)				)	||
542 		((nType==CTRL_COMBOBOX) &&
543 				(  (nPart==PART_ENTIRE_CONTROL)
544 				|| (nPart==HAS_BACKGROUND_TEXTURE)	)			)	||
545 		(((nType==CTRL_TAB_ITEM) || (nType==CTRL_TAB_PANE) ||
546 		  (nType==CTRL_TAB_BODY) || (nType==CTRL_FIXEDBORDER)) &&
547 				(  (nPart==PART_ENTIRE_CONTROL)
548 				|| (nPart==PART_TABS_DRAW_RTL) )				)	||
549 		((nType==CTRL_LISTBOX) &&
550 				(  (nPart==PART_ENTIRE_CONTROL)
551 				|| (nPart==PART_WINDOW)
552 				|| (nPart==HAS_BACKGROUND_TEXTURE) )			)   ||
553         ((nType == CTRL_TOOLBAR) &&
554          		(	(nPart==PART_ENTIRE_CONTROL)
555                 ||  (nPart==PART_DRAW_BACKGROUND_HORZ)
556                 ||  (nPart==PART_DRAW_BACKGROUND_VERT)
557                 ||  (nPart==PART_THUMB_HORZ)
558                 ||  (nPart==PART_THUMB_VERT)
559                 ||  (nPart==PART_BUTTON)
560                 )
561                                                                 )   ||
562         ((nType == CTRL_MENUBAR) &&
563                 (   (nPart==PART_ENTIRE_CONTROL) )              )   ||
564         ((nType == CTRL_TOOLTIP) &&
565                 (   (nPart==PART_ENTIRE_CONTROL) )              )   ||
566         ((nType == CTRL_MENU_POPUP) &&
567                 (   (nPart==PART_ENTIRE_CONTROL)
568                 ||  (nPart==PART_MENU_ITEM)
569                 ||  (nPart==PART_MENU_ITEM_CHECK_MARK)
570                 ||  (nPart==PART_MENU_ITEM_RADIO_MARK)
571                 )
572                                                                 )   ||
573         ((nType == CTRL_PROGRESS) &&
574                 (   (nPart == PART_ENTIRE_CONTROL) )
575                 )                                                   ||
576         ((nType == CTRL_LISTNODE || nType == CTRL_LISTNET) &&
577                 (   (nPart == PART_ENTIRE_CONTROL) )
578                 )                                                   ||
579         ((nType == CTRL_SLIDER) &&
580                 (   (nPart == PART_TRACK_HORZ_AREA)
581                 ||  (nPart == PART_TRACK_VERT_AREA)
582                 )
583         )
584         )
585 		return( sal_True );
586 
587 	return( sal_False );
588 }
589 
590 
591 /*
592  * HitTestNativeControl()
593  *
594  *  bIsInside is set to sal_True if aPos is contained within the
595  *  given part of the control, whose bounding region is
596  *  given by rControlRegion (in VCL frame coordinates).
597  *
598  *  returns whether bIsInside was really set.
599  */
600 sal_Bool GtkSalGraphics::hitTestNativeControl( ControlType		nType,
601 								ControlPart		nPart,
602 								const Rectangle&		rControlRegion,
603 								const Point&		aPos,
604 								sal_Bool&			rIsInside )
605 {
606     if ( ( nType == CTRL_SCROLLBAR ) &&
607          ( ( nPart == PART_BUTTON_UP ) ||
608            ( nPart == PART_BUTTON_DOWN ) ||
609            ( nPart == PART_BUTTON_LEFT ) ||
610            ( nPart == PART_BUTTON_RIGHT ) ) )
611     {
612         NWEnsureGTKScrollbars( m_nScreen );
613 
614         // Grab some button style attributes
615         gboolean has_forward;
616         gboolean has_forward2;
617         gboolean has_backward;
618         gboolean has_backward2;
619 
620 	    gtk_widget_style_get( gWidgetData[m_nScreen].gScrollHorizWidget, "has-forward-stepper", &has_forward,
621 									    "has-secondary-forward-stepper", &has_forward2,
622 									    "has-backward-stepper", &has_backward,
623 	   								    "has-secondary-backward-stepper", &has_backward2, (char *)NULL );
624         Rectangle aForward;
625         Rectangle aBackward;
626 
627         rIsInside = sal_False;
628 
629         ControlPart nCounterPart = 0;
630         if ( nPart == PART_BUTTON_UP )
631             nCounterPart = PART_BUTTON_DOWN;
632         else if ( nPart == PART_BUTTON_DOWN )
633             nCounterPart = PART_BUTTON_UP;
634         else if ( nPart == PART_BUTTON_LEFT )
635             nCounterPart = PART_BUTTON_RIGHT;
636         else if ( nPart == PART_BUTTON_RIGHT )
637             nCounterPart = PART_BUTTON_LEFT;
638 
639         aBackward = NWGetScrollButtonRect( m_nScreen, nPart, rControlRegion );
640         aForward = NWGetScrollButtonRect( m_nScreen, nCounterPart, rControlRegion );
641 
642         if ( has_backward && has_forward2 )
643         {
644             Size aSize( aBackward.GetSize() );
645             if ( ( nPart == PART_BUTTON_UP ) || ( nPart == PART_BUTTON_DOWN ) )
646                 aSize.setHeight( aBackward.GetHeight() / 2 );
647             else
648                 aSize.setWidth( aBackward.GetWidth() / 2 );
649             aBackward.SetSize( aSize );
650 
651             if ( nPart == PART_BUTTON_DOWN )
652                 aBackward.Move( 0, aBackward.GetHeight() / 2 );
653             else if ( nPart == PART_BUTTON_RIGHT )
654                 aBackward.Move( aBackward.GetWidth() / 2, 0 );
655         }
656 
657         if ( has_backward2 && has_forward )
658         {
659             Size aSize( aForward.GetSize() );
660             if ( ( nPart == PART_BUTTON_UP ) || ( nPart == PART_BUTTON_DOWN ) )
661                 aSize.setHeight( aForward.GetHeight() / 2 );
662             else
663                 aSize.setWidth( aForward.GetWidth() / 2 );
664             aForward.SetSize( aSize );
665 
666             if ( nPart == PART_BUTTON_DOWN )
667                 aForward.Move( 0, aForward.GetHeight() / 2 );
668             else if ( nPart == PART_BUTTON_RIGHT )
669                 aForward.Move( aForward.GetWidth() / 2, 0 );
670         }
671 
672         if ( ( nPart == PART_BUTTON_UP ) || ( nPart == PART_BUTTON_LEFT ) )
673         {
674             if ( has_backward )
675                 rIsInside |= aBackward.IsInside( aPos );
676             if ( has_backward2 )
677                 rIsInside |= aForward.IsInside( aPos );
678         }
679         else
680         {
681             if ( has_forward )
682                 rIsInside |= aBackward.IsInside( aPos );
683             if ( has_forward2 )
684                 rIsInside |= aForward.IsInside( aPos );
685         }
686         return ( sal_True );
687     }
688 
689     if( IsNativeControlSupported(nType, nPart) )
690 	{
691 		rIsInside = rControlRegion.IsInside( aPos );
692 		return( sal_True );
693 	}
694 	else
695 	{
696 		return( sal_False );
697 	}
698 }
699 
700 
701 /*
702  * DrawNativeControl()
703  *
704  *  Draws the requested control described by nPart/nState.
705  *
706  *  rControlRegion:	The bounding region of the complete control in VCL frame coordinates.
707  *  aValue:  		An optional value (tristate/numerical/string)
708  *  rCaption:  	A caption or title string (like button text etc)
709  */
710 sal_Bool GtkSalGraphics::drawNativeControl(	ControlType nType,
711 							ControlPart nPart,
712 							const Rectangle& rControlRegion,
713 							ControlState nState,
714 							const ImplControlValue& aValue,
715 							const OUString& rCaption )
716 {
717 	sal_Bool			returnVal = sal_False;
718 	// get a GC with current clipping region set
719     GetFontGC();
720 
721 
722     // theme changed ?
723     if( GtkSalGraphics::bThemeChanged )
724     {
725         // invalidate caches
726         for( unsigned int i = 0; i < gWidgetData.size(); i++ )
727             if( gWidgetData[i].gNWPixmapCacheList )
728                 gWidgetData[i].gNWPixmapCacheList->ThemeChanged();
729         GtkSalGraphics::bThemeChanged = sal_False;
730     }
731 
732     Rectangle aCtrlRect( rControlRegion );
733     Region aClipRegion( m_aClipRegion );
734     if( aClipRegion.IsNull() )
735         aClipRegion = aCtrlRect;
736 
737     clipList aClip;
738     GdkDrawable* gdkDrawable = GDK_DRAWABLE( GetGdkWindow() );
739     GdkPixmap* pixmap = NULL;
740     Rectangle aPixmapRect;
741     if( ( bNeedPixmapPaint )
742         && nType != CTRL_SCROLLBAR
743         && nType != CTRL_SPINBOX
744         && nType != CTRL_TAB_ITEM
745         && nType != CTRL_TAB_PANE
746         && nType != CTRL_PROGRESS
747         && ! (bToolbarGripWorkaround && nType == CTRL_TOOLBAR && (nPart == PART_THUMB_HORZ || nPart == PART_THUMB_VERT) )
748         )
749     {
750         // make pixmap a little larger since some themes draw decoration
751         // outside the rectangle, see e.g. checkbox
752         aPixmapRect = Rectangle( Point( aCtrlRect.Left()-1, aCtrlRect.Top()-1 ),
753                                  Size( aCtrlRect.GetWidth()+2, aCtrlRect.GetHeight()+2) );
754         pixmap = NWGetPixmapFromScreen( aPixmapRect );
755         if( ! pixmap )
756             return sal_False;
757         gdkDrawable = GDK_DRAWABLE( pixmap );
758         aCtrlRect = Rectangle( Point(1,1), aCtrlRect.GetSize() );
759         aClip.push_back( aCtrlRect );
760     }
761     else
762     {
763         RectangleVector aRectangles;
764         aClipRegion.GetRegionRectangles(aRectangles);
765 
766         for(RectangleVector::const_iterator aRectIter(aRectangles.begin()); aRectIter != aRectangles.end(); aRectIter++)
767         {
768             if(aRectIter->IsEmpty())
769             {
770                 continue;
771             }
772 
773             aClip.push_back(*aRectIter);
774         }
775 
776         //RegionHandle aHdl = aClipRegion.BeginEnumRects();
777         //Rectangle aPaintRect;
778         //while( aClipRegion.GetEnumRects( aHdl, aPaintRect ) )
779         //{
780         //    aPaintRect = aCtrlRect.GetIntersection( aPaintRect );
781         //    if( aPaintRect.IsEmpty() )
782         //        continue;
783         //    aClip.push_back( aPaintRect );
784         //}
785         //aClipRegion.EndEnumRects( aHdl );
786     }
787 
788     if ( (nType==CTRL_PUSHBUTTON) && (nPart==PART_ENTIRE_CONTROL) )
789     {
790         returnVal = NWPaintGTKButton( gdkDrawable, nType, nPart, aCtrlRect, aClip, nState, aValue, rCaption );
791     }
792     else if ( (nType==CTRL_RADIOBUTTON) && (nPart==PART_ENTIRE_CONTROL) )
793     {
794         returnVal = NWPaintGTKRadio( gdkDrawable, nType, nPart, aCtrlRect, aClip, nState, aValue, rCaption );
795     }
796     else if ( (nType==CTRL_CHECKBOX) && (nPart==PART_ENTIRE_CONTROL) )
797     {
798         returnVal = NWPaintGTKCheck( gdkDrawable, nType, nPart, aCtrlRect, aClip, nState, aValue, rCaption );
799     }
800     else if ( (nType==CTRL_SCROLLBAR) && ((nPart==PART_DRAW_BACKGROUND_HORZ) || (nPart==PART_DRAW_BACKGROUND_VERT)) )
801     {
802         returnVal = NWPaintGTKScrollbar( nType, nPart, aCtrlRect, aClip, nState, aValue, rCaption );
803     }
804     else if ( ((nType==CTRL_EDITBOX) && ((nPart==PART_ENTIRE_CONTROL) || (nPart==HAS_BACKGROUND_TEXTURE)) )
805         || ((nType==CTRL_SPINBOX) && (nPart==HAS_BACKGROUND_TEXTURE))
806     || ((nType==CTRL_COMBOBOX) && (nPart==HAS_BACKGROUND_TEXTURE))
807     || ((nType==CTRL_LISTBOX) && (nPart==HAS_BACKGROUND_TEXTURE)) )
808     {
809         returnVal = NWPaintGTKEditBox( gdkDrawable, nType, nPart, aCtrlRect, aClip, nState, aValue, rCaption );
810     }
811     else if ( ((nType==CTRL_MULTILINE_EDITBOX) && ((nPart==PART_ENTIRE_CONTROL) || (nPart==HAS_BACKGROUND_TEXTURE)) ) )
812     {
813         returnVal = NWPaintGTKEditBox( gdkDrawable, nType, nPart, aCtrlRect, aClip, nState, aValue, rCaption );
814     }
815     else if ( ((nType==CTRL_SPINBOX) || (nType==CTRL_SPINBUTTONS))
816         && ((nPart==PART_ENTIRE_CONTROL) || (nPart==PART_ALL_BUTTONS)) )
817     {
818         returnVal = NWPaintGTKSpinBox( nType, nPart, aCtrlRect, aClip, nState, aValue, rCaption );
819     }
820     else if ( (nType == CTRL_COMBOBOX) &&
821         ( (nPart==PART_ENTIRE_CONTROL)
822         ||(nPart==PART_BUTTON_DOWN)
823         ) )
824     {
825         returnVal = NWPaintGTKComboBox( gdkDrawable, nType, nPart, aCtrlRect, aClip, nState, aValue, rCaption );
826     }
827     else if ( (nType==CTRL_TAB_ITEM) || (nType==CTRL_TAB_PANE) || (nType==CTRL_TAB_BODY) || (nType==CTRL_FIXEDBORDER) )
828     {
829         if ( nType == CTRL_TAB_BODY )
830             returnVal = sal_True;
831         else
832             returnVal = NWPaintGTKTabItem( nType, nPart, aCtrlRect, aClip, nState, aValue, rCaption);
833     }
834     else if ( (nType==CTRL_LISTBOX) && ((nPart==PART_ENTIRE_CONTROL) || (nPart==PART_WINDOW)) )
835     {
836         returnVal = NWPaintGTKListBox( gdkDrawable, nType, nPart, aCtrlRect, aClip, nState, aValue, rCaption );
837     }
838     else if ( (nType== CTRL_TOOLBAR) )
839     {
840         returnVal = NWPaintGTKToolbar( gdkDrawable, nType, nPart, aCtrlRect, aClip, nState, aValue, rCaption );
841     }
842     else if ( (nType== CTRL_MENUBAR) )
843     {
844         returnVal = NWPaintGTKMenubar( gdkDrawable, nType, nPart, aCtrlRect, aClip, nState, aValue, rCaption );
845     }
846     else if(    (nType == CTRL_MENU_POPUP)
847         && (  (nPart == PART_ENTIRE_CONTROL)
848     || (nPart == PART_MENU_ITEM)
849     || (nPart == PART_MENU_ITEM_CHECK_MARK)
850     || (nPart == PART_MENU_ITEM_RADIO_MARK)
851     )
852     )
853     {
854         returnVal = NWPaintGTKPopupMenu( gdkDrawable, nType, nPart, aCtrlRect, aClip, nState, aValue, rCaption );
855     }
856     else if( (nType == CTRL_TOOLTIP) && (nPart == PART_ENTIRE_CONTROL) )
857     {
858         returnVal = NWPaintGTKTooltip( gdkDrawable, nType, nPart, aCtrlRect, aClip, nState, aValue, rCaption );
859     }
860     else if( (nType == CTRL_PROGRESS) && (nPart == PART_ENTIRE_CONTROL) )
861     {
862         returnVal = NWPaintGTKProgress( gdkDrawable, nType, nPart, aCtrlRect, aClip, nState, aValue, rCaption );
863     }
864     else if( (nType == CTRL_LISTNODE) && (nPart == PART_ENTIRE_CONTROL) )
865     {
866         returnVal = NWPaintGTKListNode( gdkDrawable, nType, nPart, aCtrlRect, aClip, nState, aValue, rCaption );
867     }
868     else if( (nType == CTRL_LISTNET) && (nPart == PART_ENTIRE_CONTROL) )
869     {
870         // don't actually draw anything; gtk treeviews do not draw lines
871         returnVal = true;
872     }
873     else if( (nType == CTRL_SLIDER) )
874     {
875         returnVal = NWPaintGTKSlider( gdkDrawable, nType, nPart, aCtrlRect, aClip, nState, aValue, rCaption );
876     }
877 
878     if( pixmap )
879     {
880         returnVal = NWRenderPixmapToScreen( pixmap, aPixmapRect ) && returnVal;
881         g_object_unref( pixmap );
882     }
883 
884 	return( returnVal );
885 }
886 
887 /*
888  * DrawNativeControlText()
889  *
890  *  OPTIONAL.  Draws the requested text for the control described by nPart/nState.
891  *     Used if text not drawn by DrawNativeControl().
892  *
893  *  rControlRegion:	The bounding region of the complete control in VCL frame coordinates.
894  *  aValue:  		An optional value (tristate/numerical/string)
895  *  rCaption:  	A caption or title string (like button text etc)
896  */
897 sal_Bool GtkSalGraphics::drawNativeControlText(	ControlType,
898 								ControlPart,
899 								const Rectangle&,
900 								ControlState,
901 								const ImplControlValue&,
902 								const OUString& )
903 {
904 	return( sal_False );
905 }
906 
907 
908 /*
909  * GetNativeControlRegion()
910  *
911  *  If the return value is sal_True, rNativeBoundingRegion
912  *  contains the true bounding region covered by the control
913  *  including any adornment, while rNativeContentRegion contains the area
914  *  within the control that can be safely drawn into without drawing over
915  *  the borders of the control.
916  *
917  *  rControlRegion:	The bounding region of the control in VCL frame coordinates.
918  *  aValue:		An optional value (tristate/numerical/string)
919  *  rCaption:		A caption or title string (like button text etc)
920  */
921 sal_Bool GtkSalGraphics::getNativeControlRegion(  ControlType nType,
922 								ControlPart nPart,
923 								const Rectangle& rControlRegion,
924 								ControlState nState,
925 								const ImplControlValue& aValue,
926 								const OUString& rCaption,
927 								Rectangle &rNativeBoundingRegion,
928 								Rectangle &rNativeContentRegion )
929 {
930 	sal_Bool returnVal = sal_False;
931 
932     if ( (nType==CTRL_PUSHBUTTON) && (nPart==PART_ENTIRE_CONTROL)
933         && (rControlRegion.GetWidth() > 16)
934     && (rControlRegion.GetHeight() > 16) )
935     {
936         rNativeBoundingRegion = NWGetButtonArea( m_nScreen, nType, nPart, rControlRegion,
937         nState, aValue, rCaption );
938         rNativeContentRegion = rControlRegion;
939 
940         returnVal = sal_True;
941     }
942     if ( (nType==CTRL_COMBOBOX) && ((nPart==PART_BUTTON_DOWN) || (nPart==PART_SUB_EDIT)) )
943     {
944         rNativeBoundingRegion = NWGetComboBoxButtonRect( m_nScreen, nType, nPart, rControlRegion, nState,
945         aValue, rCaption );
946         rNativeContentRegion = rNativeBoundingRegion;
947 
948         returnVal = sal_True;
949     }
950     if ( (nType==CTRL_SPINBOX) && ((nPart==PART_BUTTON_UP) || (nPart==PART_BUTTON_DOWN) || (nPart==PART_SUB_EDIT)) )
951     {
952 
953         rNativeBoundingRegion = NWGetSpinButtonRect( m_nScreen, nType, nPart, rControlRegion, nState,
954         aValue, rCaption );
955         rNativeContentRegion = rNativeBoundingRegion;
956 
957         returnVal = sal_True;
958     }
959     if ( (nType==CTRL_LISTBOX) && ((nPart==PART_BUTTON_DOWN) || (nPart==PART_SUB_EDIT)) )
960     {
961         rNativeBoundingRegion = NWGetListBoxButtonRect( m_nScreen, nType, nPart, rControlRegion, nState,
962         aValue, rCaption );
963         rNativeContentRegion = rNativeBoundingRegion;
964 
965         returnVal = sal_True;
966     }
967     if ( (nType==CTRL_TOOLBAR) &&
968         ((nPart==PART_DRAW_BACKGROUND_HORZ)	||
969         (nPart==PART_DRAW_BACKGROUND_VERT)	||
970         (nPart==PART_THUMB_HORZ)			||
971         (nPart==PART_THUMB_VERT)            ||
972         (nPart==PART_BUTTON)
973         ))
974     {
975         rNativeBoundingRegion = NWGetToolbarRect( m_nScreen, nType, nPart, rControlRegion, nState, aValue, rCaption );
976         rNativeContentRegion = rNativeBoundingRegion;
977         returnVal = sal_True;
978     }
979     if ( (nType==CTRL_SCROLLBAR) && ((nPart==PART_BUTTON_LEFT) || (nPart==PART_BUTTON_RIGHT) ||
980         (nPart==PART_BUTTON_UP) || (nPart==PART_BUTTON_DOWN)  ) )
981     {
982         rNativeBoundingRegion = NWGetScrollButtonRect( m_nScreen, nPart, rControlRegion );
983         rNativeContentRegion = rNativeBoundingRegion;
984 
985         returnVal = sal_True;
986     }
987     if( (nType == CTRL_MENUBAR) && (nPart == PART_ENTIRE_CONTROL) )
988     {
989         NWEnsureGTKMenubar( m_nScreen );
990         GtkRequisition aReq;
991         gtk_widget_size_request( gWidgetData[m_nScreen].gMenubarWidget, &aReq );
992         Rectangle aMenuBarRect = rControlRegion;
993         aMenuBarRect = Rectangle( aMenuBarRect.TopLeft(),
994                                   Size( aMenuBarRect.GetWidth(), aReq.height+1 ) );
995         rNativeBoundingRegion = aMenuBarRect;
996         rNativeContentRegion = rNativeBoundingRegion;
997         returnVal = sal_True;
998     }
999     if( (nType == CTRL_MENU_POPUP) )
1000     {
1001         if( (nPart == PART_MENU_ITEM_CHECK_MARK) ||
1002             (nPart == PART_MENU_ITEM_RADIO_MARK) )
1003         {
1004             NWEnsureGTKMenu( m_nScreen );
1005 
1006             gint indicator_size = 0;
1007             GtkWidget* pWidget = (nPart == PART_MENU_ITEM_CHECK_MARK) ?
1008                                  gWidgetData[m_nScreen].gMenuItemCheckMenuWidget : gWidgetData[m_nScreen].gMenuItemRadioMenuWidget;
1009             gtk_widget_style_get( pWidget,
1010                                   "indicator_size", &indicator_size,
1011                                   (char *)NULL );
1012             rNativeBoundingRegion = rControlRegion;
1013             Rectangle aIndicatorRect( Point( 0,
1014                                              (rControlRegion.GetHeight()-indicator_size)/2),
1015                                       Size( indicator_size, indicator_size ) );
1016             rNativeContentRegion = aIndicatorRect;
1017             returnVal = sal_True;
1018         }
1019     }
1020     if( (nType == CTRL_RADIOBUTTON || nType == CTRL_CHECKBOX) )
1021     {
1022         NWEnsureGTKRadio( m_nScreen );
1023         NWEnsureGTKCheck( m_nScreen );
1024         GtkWidget* widget = (nType == CTRL_RADIOBUTTON) ? gWidgetData[m_nScreen].gRadioWidget : gWidgetData[m_nScreen].gCheckWidget;
1025         gint indicator_size, indicator_spacing;
1026         gtk_widget_style_get( widget,
1027                               "indicator_size", &indicator_size,
1028                               "indicator_spacing", &indicator_spacing,
1029                               (char *)NULL);
1030         indicator_size += 2*indicator_spacing; // guess overpaint of theme
1031         rNativeBoundingRegion = rControlRegion;
1032         Rectangle aIndicatorRect( Point( 0,
1033                                          (rControlRegion.GetHeight()-indicator_size)/2),
1034                                   Size( indicator_size, indicator_size ) );
1035         rNativeContentRegion = aIndicatorRect;
1036         returnVal = sal_True;
1037     }
1038     if( (nType == CTRL_EDITBOX || nType == CTRL_SPINBOX) && nPart == PART_ENTIRE_CONTROL )
1039     {
1040         NWEnsureGTKEditBox( m_nScreen );
1041         GtkWidget* widget = gWidgetData[m_nScreen].gEditBoxWidget;
1042         GtkRequisition aReq;
1043         gtk_widget_size_request( widget, &aReq );
1044         Rectangle aEditRect = rControlRegion;
1045         long nHeight = (aEditRect.GetHeight() > aReq.height+1) ? aEditRect.GetHeight() : aReq.height+1;
1046         aEditRect = Rectangle( aEditRect.TopLeft(),
1047                                Size( aEditRect.GetWidth(), nHeight ) );
1048         rNativeBoundingRegion = aEditRect;
1049         rNativeContentRegion = rNativeBoundingRegion;
1050         returnVal = sal_True;
1051     }
1052     if( (nType == CTRL_SLIDER) && (nPart == PART_THUMB_HORZ || nPart == PART_THUMB_VERT) )
1053     {
1054         NWEnsureGTKSlider( m_nScreen );
1055         GtkWidget* widget = (nPart == PART_THUMB_HORZ) ? gWidgetData[m_nScreen].gHScale : gWidgetData[m_nScreen].gVScale;
1056         gint slider_length = 10;
1057         gint slider_width = 10;
1058         gtk_widget_style_get( widget,
1059                               "slider-width", &slider_width,
1060                               "slider-length", &slider_length,
1061                               (char *)NULL);
1062         Rectangle aRect( rControlRegion );
1063         if( nPart == PART_THUMB_HORZ )
1064         {
1065             aRect.Right() = aRect.Left() + slider_length - 1;
1066             aRect.Bottom() = aRect.Top() + slider_width - 1;
1067         }
1068         else
1069         {
1070             aRect.Bottom() = aRect.Top() + slider_length - 1;
1071             aRect.Right() = aRect.Left() + slider_width - 1;
1072         }
1073         rNativeBoundingRegion = rNativeContentRegion = aRect;
1074         returnVal = sal_True;
1075     }
1076 
1077 	return( returnVal );
1078 }
1079 
1080 
1081 /************************************************************************
1082  * Individual control drawing functions
1083  ************************************************************************/
1084 sal_Bool GtkSalGraphics::NWPaintGTKButton(
1085             GdkDrawable* gdkDrawable,
1086             ControlType, ControlPart,
1087 			const Rectangle& rControlRectangle,
1088             const clipList& rClipList,
1089             ControlState nState, const ImplControlValue&,
1090 			const OUString& )
1091 {
1092 	GtkStateType	stateType;
1093 	GtkShadowType	shadowType;
1094 	gboolean		interiorFocus;
1095 	gint			focusWidth;
1096 	gint			focusPad;
1097 	sal_Bool			bDrawFocus = sal_True;
1098 	gint			x, y, w, h;
1099 	GtkBorder		aDefBorder;
1100 	GtkBorder*		pBorder;
1101     GdkRectangle	clipRect;
1102 
1103 	NWEnsureGTKButton( m_nScreen );
1104 	NWConvertVCLStateToGTKState( nState, &stateType, &shadowType );
1105 
1106 	x = rControlRectangle.Left();
1107     y = rControlRectangle.Top();
1108 	w = rControlRectangle.GetWidth();
1109 	h = rControlRectangle.GetHeight();
1110 
1111 	// Grab some button style attributes
1112 	gtk_widget_style_get( gWidgetData[m_nScreen].gBtnWidget,	"focus-line-width",	&focusWidth,
1113 								"focus-padding", 	&focusPad,
1114 					 			"interior_focus",	&interiorFocus,
1115 								"default_border",	&pBorder,
1116 								(char *)NULL );
1117 
1118 	// Make sure the border values exist, otherwise use some defaults
1119 	if ( pBorder )
1120 	{
1121 		NW_gtk_border_set_from_border( aDefBorder, pBorder );
1122 		gtk_border_free( pBorder );
1123 	}
1124 	else NW_gtk_border_set_from_border( aDefBorder, &aDefDefBorder );
1125 
1126 	// If the button is too small, don't ever draw focus or grab more space
1127 	if ( (w < 16) || (h < 16) )
1128 		bDrawFocus = sal_False;
1129 
1130 	NWSetWidgetState( gWidgetData[m_nScreen].gBtnWidget, nState, stateType );
1131 
1132     gint xi = x, yi = y, wi = w, hi = h;
1133 	if ( (nState & CTRL_STATE_DEFAULT) && bDrawFocus )
1134 	{
1135 		xi += aDefBorder.left;
1136 		yi += aDefBorder.top;
1137 		wi -= aDefBorder.left + aDefBorder.right;
1138 		hi -= aDefBorder.top + aDefBorder.bottom;
1139 	}
1140 
1141 	if ( !interiorFocus && bDrawFocus )
1142 	{
1143 		xi += focusWidth + focusPad;
1144 		yi += focusWidth + focusPad;
1145 		wi -= 2 * (focusWidth + focusPad);
1146 		hi -= 2 * (focusWidth + focusPad);
1147 	}
1148 
1149     for( clipList::const_iterator it = rClipList.begin(); it != rClipList.end(); ++it)
1150     {
1151         clipRect.x = it->Left();
1152         clipRect.y = it->Top();
1153         clipRect.width = it->GetWidth();
1154         clipRect.height = it->GetHeight();
1155 
1156         // Buttons must paint opaque since some themes have alpha-channel enabled buttons
1157         gtk_paint_flat_box( gWidgetData[m_nScreen].gBtnWidget->style, gdkDrawable, GTK_STATE_NORMAL, GTK_SHADOW_NONE,
1158                             &clipRect, m_pWindow, "base", x, y, w, h );
1159 
1160         if ( (nState & CTRL_STATE_DEFAULT) && (GTK_BUTTON(gWidgetData[m_nScreen].gBtnWidget)->relief == GTK_RELIEF_NORMAL) )
1161         {
1162             gtk_paint_box( gWidgetData[m_nScreen].gBtnWidget->style, gdkDrawable, GTK_STATE_NORMAL, GTK_SHADOW_IN,
1163                            &clipRect, gWidgetData[m_nScreen].gBtnWidget, "buttondefault", x, y, w, h );
1164         }
1165 
1166         if ( (GTK_BUTTON(gWidgetData[m_nScreen].gBtnWidget)->relief != GTK_RELIEF_NONE)
1167             || (nState & CTRL_STATE_PRESSED)
1168 		    || (nState & CTRL_STATE_ROLLOVER) )
1169         {
1170             gtk_paint_box( gWidgetData[m_nScreen].gBtnWidget->style, gdkDrawable, stateType, shadowType,
1171                            &clipRect, gWidgetData[m_nScreen].gBtnWidget, "button", xi, yi, wi, hi );
1172         }
1173     }
1174 #if 0 // VCL draws focus rects
1175 	// Draw focus rect
1176 	if ( (nState & CTRL_STATE_FOCUSED) && (nState & CTRL_STATE_ENABLED) && bDrawFocus )
1177 	{
1178 		if (interiorFocus)
1179 		{
1180 			x += gWidgetData[m_nScreen].gBtnWidget->style->xthickness + focusPad;
1181 			y += gWidgetData[m_nScreen].gBtnWidget->style->ythickness + focusPad;
1182 			w -= 2 * (gWidgetData[m_nScreen].gBtnWidget->style->xthickness + focusPad);
1183 			h -=  2 * (gWidgetData[m_nScreen].gBtnWidget->style->xthickness + focusPad);
1184 		}
1185 		else
1186 		{
1187 			x -= focusWidth + focusPad;
1188 			y -= focusWidth + focusPad;
1189 			w += 2 * (focusWidth + focusPad);
1190 			h += 2 * (focusWidth + focusPad);
1191 		}
1192 		if ( !interiorFocus )
1193 			gtk_paint_focus( gWidgetData[m_nScreen].gBtnWidget->style, gdkDrawable, stateType, &clipRect,
1194                              gWidgetData[m_nScreen].gBtnWidget, "button", x, y, w, h );
1195 	}
1196 #endif
1197 
1198 	return( sal_True );
1199 }
1200 
1201 static Rectangle NWGetButtonArea( int nScreen,
1202                                   ControlType, ControlPart, Rectangle aAreaRect, ControlState nState,
1203 							      const ImplControlValue&, const OUString& )
1204 {
1205 	gboolean		interiorFocus;
1206 	gint			focusWidth;
1207 	gint			focusPad;
1208 	GtkBorder		aDefBorder;
1209 	GtkBorder *	pBorder;
1210 	sal_Bool			bDrawFocus = sal_True;
1211 	Rectangle		aRect;
1212 	gint			x, y, w, h;
1213 
1214 	NWEnsureGTKButton( nScreen );
1215 	gtk_widget_style_get( gWidgetData[nScreen].gBtnWidget,
1216                             	"focus-line-width",	&focusWidth,
1217 								"focus-padding", 	&focusPad,
1218 					 			"interior_focus",	&interiorFocus,
1219 								"default_border",	&pBorder,
1220 								(char *)NULL );
1221 
1222 	// Make sure the border values exist, otherwise use some defaults
1223 	if ( pBorder )
1224 	{
1225 		NW_gtk_border_set_from_border( aDefBorder, pBorder );
1226 		gtk_border_free( pBorder );
1227 	}
1228 	else NW_gtk_border_set_from_border( aDefBorder, &aDefDefBorder );
1229 
1230 	x = aAreaRect.Left();
1231 	y = aAreaRect.Top();
1232 	w = aAreaRect.GetWidth();
1233 	h = aAreaRect.GetHeight();
1234 
1235 	// If the button is too small, don't ever draw focus or grab more space
1236 	if ( (w < 16) || (h < 16) )
1237 		bDrawFocus = sal_False;
1238 
1239 	if ( (nState & CTRL_STATE_DEFAULT) && bDrawFocus )
1240 	{
1241 		x -= aDefBorder.left;
1242 		y -= aDefBorder.top;
1243 		w += aDefBorder.left + aDefBorder.right;
1244 		h += aDefBorder.top + aDefBorder.bottom;
1245 	}
1246 
1247     aRect = Rectangle( Point( x, y ), Size( w, h ) );
1248 
1249 	return( aRect );
1250 }
1251 
1252 //-------------------------------------
1253 
1254 sal_Bool GtkSalGraphics::NWPaintGTKRadio( GdkDrawable* gdkDrawable,
1255                                       ControlType, ControlPart,
1256                                       const Rectangle& rControlRectangle,
1257                                       const clipList& rClipList,
1258                                       ControlState nState,
1259                                       const ImplControlValue& aValue,
1260                                       const OUString& )
1261 {
1262 	GtkStateType	stateType;
1263 	GtkShadowType	shadowType;
1264 	sal_Bool			isChecked = (aValue.getTristateVal()==BUTTONVALUE_ON);
1265     gint            x, y;
1266     GdkRectangle	clipRect;
1267 
1268 	NWEnsureGTKButton( m_nScreen );
1269 	NWEnsureGTKRadio( m_nScreen );
1270 	NWConvertVCLStateToGTKState( nState, &stateType, &shadowType );
1271 
1272     gint indicator_size;
1273     gtk_widget_style_get( gWidgetData[m_nScreen].gRadioWidget, "indicator_size", &indicator_size, (char *)NULL);
1274 
1275     x = rControlRectangle.Left() + (rControlRectangle.GetWidth()-indicator_size)/2;
1276     y = rControlRectangle.Top() + (rControlRectangle.GetHeight()-indicator_size)/2;
1277 
1278 	// Set the shadow based on if checked or not so we get a freakin checkmark.
1279 	shadowType = isChecked ? GTK_SHADOW_IN : GTK_SHADOW_OUT;
1280 	NWSetWidgetState( gWidgetData[m_nScreen].gRadioWidget, nState, stateType );
1281 	NWSetWidgetState( gWidgetData[m_nScreen].gRadioWidgetSibling, nState, stateType );
1282 
1283 	// GTK enforces radio groups, so that if we don't have 2 buttons in the group,
1284 	// the single button will always be active.  So we have to have 2 buttons.
1285 
1286     // #i59666# set the members directly where we should use
1287     // gtk_toggle_button_set_active. reason: there are animated themes
1288     // which are in active state only after a while leading to painting
1289     // intermediate states between active/inactive. Let's hope that
1290     // GtkToggleButtone stays binary compatible.
1291 	if (!isChecked)
1292 		GTK_TOGGLE_BUTTON(gWidgetData[m_nScreen].gRadioWidgetSibling)->active = sal_True;
1293 	GTK_TOGGLE_BUTTON(gWidgetData[m_nScreen].gRadioWidget)->active = isChecked;
1294 
1295     for( clipList::const_iterator it = rClipList.begin(); it != rClipList.end(); ++it )
1296     {
1297         clipRect.x = it->Left();
1298         clipRect.y = it->Top();
1299         clipRect.width = it->GetWidth();
1300         clipRect.height = it->GetHeight();
1301 
1302         gtk_paint_option( gWidgetData[m_nScreen].gRadioWidget->style, gdkDrawable, stateType, shadowType,
1303                           &clipRect, gWidgetData[m_nScreen].gRadioWidget, "radiobutton",
1304                           x, y, indicator_size, indicator_size );
1305     }
1306 
1307 	return( sal_True );
1308 }
1309 
1310 //-------------------------------------
1311 
1312 sal_Bool GtkSalGraphics::NWPaintGTKCheck( GdkDrawable* gdkDrawable,
1313                                       ControlType, ControlPart,
1314                                       const Rectangle& rControlRectangle,
1315                                       const clipList& rClipList,
1316                                       ControlState nState,
1317                                       const ImplControlValue& aValue,
1318                                       const OUString& )
1319 {
1320 	GtkStateType	stateType;
1321 	GtkShadowType	shadowType;
1322 	bool			isChecked = (aValue.getTristateVal() == BUTTONVALUE_ON);
1323 	bool            isInconsistent = (aValue.getTristateVal() == BUTTONVALUE_MIXED);
1324     GdkRectangle	clipRect;
1325     gint			x,y;
1326 
1327 	NWEnsureGTKButton( m_nScreen );
1328 	NWEnsureGTKCheck( m_nScreen );
1329 	NWConvertVCLStateToGTKState( nState, &stateType, &shadowType );
1330 
1331     gint indicator_size;
1332     gtk_widget_style_get( gWidgetData[m_nScreen].gCheckWidget, "indicator_size", &indicator_size, (char *)NULL);
1333 
1334     x = rControlRectangle.Left() + (rControlRectangle.GetWidth()-indicator_size)/2;
1335     y = rControlRectangle.Top() + (rControlRectangle.GetHeight()-indicator_size)/2;
1336 
1337 	// Set the shadow based on if checked or not so we get a checkmark.
1338 	shadowType = isChecked ? GTK_SHADOW_IN : isInconsistent ? GTK_SHADOW_ETCHED_IN : GTK_SHADOW_OUT;
1339 	NWSetWidgetState( gWidgetData[m_nScreen].gCheckWidget, nState, stateType );
1340 	GTK_TOGGLE_BUTTON(gWidgetData[m_nScreen].gCheckWidget)->active = isChecked;
1341 
1342     for( clipList::const_iterator it = rClipList.begin(); it != rClipList.end(); ++it )
1343     {
1344         clipRect.x = it->Left();
1345         clipRect.y = it->Top();
1346         clipRect.width = it->GetWidth();
1347         clipRect.height = it->GetHeight();
1348 
1349         gtk_paint_check( gWidgetData[m_nScreen].gCheckWidget->style, gdkDrawable, stateType, shadowType,
1350                          &clipRect, gWidgetData[m_nScreen].gCheckWidget, "checkbutton",
1351                          x, y, indicator_size, indicator_size );
1352     }
1353 
1354 	return( sal_True );
1355 }
1356 
1357 //-------------------------------------
1358 static void NWCalcArrowRect( const Rectangle& rButton, Rectangle& rArrow )
1359 {
1360 	// Size the arrow appropriately
1361     Size aSize( rButton.GetWidth()/2, rButton.GetHeight()/2 );
1362     rArrow.SetSize( aSize );
1363 
1364 	rArrow.SetPos( Point(
1365         rButton.Left() + ( rButton.GetWidth()  - rArrow.GetWidth()  ) / 2,
1366         rButton.Top() + ( rButton.GetHeight() - rArrow.GetHeight() ) / 2
1367         ) );
1368 }
1369 
1370 sal_Bool GtkSalGraphics::NWPaintGTKScrollbar( ControlType, ControlPart nPart,
1371                                           const Rectangle& rControlRectangle,
1372                                           const clipList&,
1373                                           ControlState nState,
1374                                           const ImplControlValue& aValue,
1375                                           const OUString& )
1376 {
1377     OSL_ASSERT( aValue.getType() == CTRL_SCROLLBAR );
1378 	const ScrollbarValue* pScrollbarVal = static_cast<const ScrollbarValue *>(&aValue);
1379     GdkPixmap*      pixmap = NULL;
1380 	Rectangle		pixmapRect, scrollbarRect;
1381 	GtkStateType	stateType;
1382 	GtkShadowType	shadowType;
1383 	GtkScrollbar *	scrollbarWidget;
1384 	GtkStyle *	style;
1385 	GtkAdjustment* scrollbarValues = NULL;
1386 	GtkOrientation	scrollbarOrientation;
1387 	Rectangle		thumbRect = pScrollbarVal->maThumbRect;
1388 	Rectangle		button11BoundRect = pScrollbarVal->maButton1Rect;   // backward
1389 	Rectangle		button22BoundRect = pScrollbarVal->maButton2Rect;   // forward
1390 	Rectangle		button12BoundRect = pScrollbarVal->maButton1Rect;   // secondary forward
1391 	Rectangle		button21BoundRect = pScrollbarVal->maButton2Rect;   // secondary backward
1392 	GtkArrowType	button1Type;                                        // backward
1393 	GtkArrowType	button2Type;                                        // forward
1394 	gchar *		scrollbarTagH = (gchar *) "hscrollbar";
1395 	gchar *		scrollbarTagV = (gchar *) "vscrollbar";
1396 	gchar *		scrollbarTag = NULL;
1397 	Rectangle		arrowRect;
1398 	gint			slider_width = 0;
1399 	gint			stepper_size = 0;
1400 	gint			stepper_spacing = 0;
1401 	gint			trough_border = 0;
1402 	gint			min_slider_length = 0;
1403 	gint			vShim = 0;
1404 	gint			hShim = 0;
1405 	gint			x,y,w,h;
1406 
1407     // make controlvalue rectangles relative to area
1408     thumbRect.Move( -rControlRectangle.Left(), -rControlRectangle.Top() );
1409     button11BoundRect.Move( -rControlRectangle.Left(), -rControlRectangle.Top() );
1410     button22BoundRect.Move( -rControlRectangle.Left(), -rControlRectangle.Top() );
1411     button12BoundRect.Move( -rControlRectangle.Left(), -rControlRectangle.Top() );
1412     button21BoundRect.Move( -rControlRectangle.Left(), -rControlRectangle.Top() );
1413 
1414 	NWEnsureGTKButton( m_nScreen );
1415 	NWEnsureGTKScrollbars( m_nScreen );
1416 	NWEnsureGTKArrow( m_nScreen );
1417 
1418 	// Find the overall bounding rect of the control
1419 	pixmapRect = rControlRectangle;
1420     pixmapRect.SetSize( Size( pixmapRect.GetWidth() + 1,
1421                               pixmapRect.GetHeight() + 1 ) );
1422 	scrollbarRect = pixmapRect;
1423 
1424 	if ( (scrollbarRect.GetWidth() <= 1) || (scrollbarRect.GetHeight() <= 1) )
1425 		return( sal_True );
1426 
1427 	// Grab some button style attributes
1428 	gtk_widget_style_get( gWidgetData[m_nScreen].gScrollHorizWidget,
1429                                       "slider_width", &slider_width,
1430 									  "stepper_size", &stepper_size,
1431 									  "trough_border", &trough_border,
1432 									  "stepper_spacing", &stepper_spacing,
1433 									  "min_slider_length", &min_slider_length, (char *)NULL );
1434     gboolean has_forward;
1435     gboolean has_forward2;
1436     gboolean has_backward;
1437     gboolean has_backward2;
1438 
1439 	gtk_widget_style_get( gWidgetData[m_nScreen].gScrollHorizWidget, "has-forward-stepper", &has_forward,
1440 									  "has-secondary-forward-stepper", &has_forward2,
1441 									  "has-backward-stepper", &has_backward,
1442 	   								  "has-secondary-backward-stepper", &has_backward2, (char *)NULL );
1443 	gint magic = trough_border ? 1 : 0;
1444     gint nFirst = 0;
1445 
1446     if ( has_backward )  nFirst  += 1;
1447     if ( has_forward2 )  nFirst  += 1;
1448 
1449 	if ( nPart == PART_DRAW_BACKGROUND_HORZ )
1450 	{
1451 		unsigned int sliderHeight = slider_width + (trough_border * 2);
1452 		vShim = (pixmapRect.GetHeight() - sliderHeight) / 2;
1453 
1454 		scrollbarRect.Move( 0, vShim );
1455 		scrollbarRect.SetSize( Size( scrollbarRect.GetWidth(), sliderHeight ) );
1456 
1457 		scrollbarWidget = GTK_SCROLLBAR( gWidgetData[m_nScreen].gScrollHorizWidget );
1458 		scrollbarOrientation = GTK_ORIENTATION_HORIZONTAL;
1459 		scrollbarTag = scrollbarTagH;
1460 		button1Type = GTK_ARROW_LEFT;
1461 		button2Type = GTK_ARROW_RIGHT;
1462 
1463         if ( has_backward )
1464         {
1465             button12BoundRect.Move( stepper_size - trough_border,
1466                                     (scrollbarRect.GetHeight() - slider_width) / 2 );
1467         }
1468 
1469         button11BoundRect.Move( trough_border, (scrollbarRect.GetHeight() - slider_width) / 2 );
1470         button11BoundRect.SetSize( Size( stepper_size, slider_width ) );
1471         button12BoundRect.SetSize( Size( stepper_size, slider_width ) );
1472 
1473         if ( has_backward2 )
1474         {
1475             button22BoundRect.Move( stepper_size+(trough_border+1)/2, (scrollbarRect.GetHeight() - slider_width) / 2 );
1476             button21BoundRect.Move( (trough_border+1)/2, (scrollbarRect.GetHeight() - slider_width) / 2 );
1477         }
1478         else
1479         {
1480             button22BoundRect.Move( (trough_border+1)/2, (scrollbarRect.GetHeight() - slider_width) / 2 );
1481         }
1482 
1483         button21BoundRect.SetSize( Size( stepper_size, slider_width ) );
1484         button22BoundRect.SetSize( Size( stepper_size, slider_width ) );
1485 
1486 		thumbRect.Bottom() = thumbRect.Top() + slider_width - 1;
1487 		// Make sure the thumb is at least the default width (so we don't get tiny thumbs),
1488 		// but if the VCL gives us a size smaller than the theme's default thumb size,
1489 		// honor the VCL size
1490 #if 0
1491 		if ( (thumbRect.GetWidth() < min_slider_length)
1492 			&& ((scrollbarRect.GetWidth()-button1BoundRect.GetWidth()-button2BoundRect.GetWidth()) > min_slider_length) )
1493 			thumbRect.SetSize( Size( min_slider_length, thumbRect.GetHeight() ) );
1494 #endif
1495 
1496         thumbRect.Right() += magic;
1497 		// Center vertically in the track
1498 		thumbRect.Move( 0, (scrollbarRect.GetHeight() - slider_width) / 2 );
1499 	}
1500 	else
1501 	{
1502 		unsigned int sliderWidth = slider_width + (trough_border * 2);
1503 		hShim = (pixmapRect.GetWidth() - sliderWidth) / 2;
1504 
1505 		scrollbarRect.Move( hShim, 0 );
1506 		scrollbarRect.SetSize( Size( sliderWidth, scrollbarRect.GetHeight() ) );
1507 
1508 		scrollbarWidget = GTK_SCROLLBAR( gWidgetData[m_nScreen].gScrollVertWidget );
1509 		scrollbarOrientation = GTK_ORIENTATION_VERTICAL;
1510 		scrollbarTag = scrollbarTagV;
1511 		button1Type = GTK_ARROW_UP;
1512 		button2Type = GTK_ARROW_DOWN;
1513 
1514         if ( has_backward )
1515         {
1516             button12BoundRect.Move( (scrollbarRect.GetWidth() - slider_width) / 2,
1517                                     stepper_size + trough_border );
1518         }
1519         button11BoundRect.Move( (scrollbarRect.GetWidth() - slider_width) / 2, trough_border );
1520         button11BoundRect.SetSize( Size( slider_width, stepper_size ) );
1521 		button12BoundRect.SetSize( Size( slider_width, stepper_size ) );
1522 
1523         if ( has_backward2 )
1524         {
1525             button22BoundRect.Move( (scrollbarRect.GetWidth() - slider_width) / 2, stepper_size+(trough_border+1)/2 );
1526             button21BoundRect.Move( (scrollbarRect.GetWidth() - slider_width) / 2, (trough_border+1)/2 );
1527         }
1528         else
1529         {
1530             button22BoundRect.Move( (scrollbarRect.GetWidth() - slider_width) / 2, (trough_border+1)/2 );
1531         }
1532 
1533         button21BoundRect.SetSize( Size( slider_width, stepper_size ) );
1534         button22BoundRect.SetSize( Size( slider_width, stepper_size ) );
1535 
1536 		thumbRect.Right() = thumbRect.Left() + slider_width - 1;
1537 #if 0
1538 		// Make sure the thumb is at least the default width (so we don't get tiny thumbs),
1539 		// but if the VCL gives us a size smaller than the theme's default thumb size,
1540 		// honor the VCL size
1541 		if ( (thumbRect.GetHeight() < min_slider_length)
1542 			&& ((scrollbarRect.GetHeight()-button1BoundRect.GetHeight()-button2BoundRect.GetHeight()) > min_slider_length) )
1543 			thumbRect.SetSize( Size( thumbRect.GetWidth(), min_slider_length ) );
1544 #endif
1545 
1546         thumbRect.Bottom() += magic;
1547 		// Center horizontally in the track
1548 		thumbRect.Move( (scrollbarRect.GetWidth() - slider_width) / 2, 0 );
1549 	}
1550 
1551     sal_Bool has_slider = ( thumbRect.GetWidth() > 0 && thumbRect.GetHeight() > 0 );
1552 
1553 	scrollbarValues = gtk_range_get_adjustment( GTK_RANGE(scrollbarWidget) );
1554 	if ( scrollbarValues == NULL )
1555 		scrollbarValues = GTK_ADJUSTMENT( gtk_adjustment_new(0, 0, 0, 0, 0, 0) );
1556 	if ( nPart == PART_DRAW_BACKGROUND_HORZ )
1557 	{
1558 		scrollbarValues->lower = pScrollbarVal->mnMin;
1559 		scrollbarValues->upper = pScrollbarVal->mnMax;
1560 		scrollbarValues->value = pScrollbarVal->mnCur;
1561 		scrollbarValues->page_size = scrollbarRect.GetWidth() / 2;
1562 	}
1563 	else
1564 	{
1565 		scrollbarValues->lower = pScrollbarVal->mnMin;
1566 		scrollbarValues->upper = pScrollbarVal->mnMax;
1567 		scrollbarValues->value = pScrollbarVal->mnCur;
1568 		scrollbarValues->page_size = scrollbarRect.GetHeight() / 2;
1569 	}
1570 	gtk_adjustment_changed( scrollbarValues );
1571 
1572     // as multiple paints are required for the scrollbar
1573     // painting them directly to the window flickers
1574     pixmap = NWGetPixmapFromScreen( pixmapRect );
1575     if( ! pixmap )
1576         return sal_False;
1577     x = y = 0;
1578 
1579     w = pixmapRect.GetWidth();
1580     h = pixmapRect.GetHeight();
1581 
1582     GdkDrawable* const &gdkDrawable = GDK_DRAWABLE( pixmap );
1583     GdkRectangle* gdkRect = NULL;
1584 
1585 	NWConvertVCLStateToGTKState( nState, &stateType, &shadowType );
1586 	NWSetWidgetState( GTK_WIDGET(scrollbarWidget), nState, stateType );
1587 	NWSetWidgetState( gWidgetData[m_nScreen].gBtnWidget, nState, stateType );
1588 	style = GTK_WIDGET( scrollbarWidget )->style;
1589 
1590 	// ----------------- TROUGH
1591 	gtk_paint_flat_box( gWidgetData[m_nScreen].gBtnWidget->style, gdkDrawable,
1592                         GTK_STATE_NORMAL, GTK_SHADOW_NONE, gdkRect,
1593                         m_pWindow, "base", x, y,
1594                         w, h );
1595 	gtk_paint_box( style, gdkDrawable, GTK_STATE_ACTIVE, GTK_SHADOW_IN,
1596                    gdkRect, GTK_WIDGET(scrollbarWidget), "trough",
1597                    x, y,
1598                    scrollbarRect.GetWidth(), scrollbarRect.GetHeight() );
1599 
1600 	if ( nState & CTRL_STATE_FOCUSED )
1601 	{
1602 		gtk_paint_focus( style, gdkDrawable, GTK_STATE_ACTIVE,
1603                          gdkRect, GTK_WIDGET(scrollbarWidget), "trough",
1604                          x, y,
1605                          scrollbarRect.GetWidth(), scrollbarRect.GetHeight() );
1606 	}
1607 
1608 	// ----------------- THUMB
1609     if ( has_slider )
1610     {
1611 	    NWConvertVCLStateToGTKState( pScrollbarVal->mnThumbState, &stateType, &shadowType );
1612 	    if ( pScrollbarVal->mnThumbState & CTRL_STATE_PRESSED )  stateType = GTK_STATE_PRELIGHT;
1613 	    gtk_paint_slider( style, gdkDrawable, stateType, GTK_SHADOW_OUT,
1614                         gdkRect, GTK_WIDGET(scrollbarWidget), "slider",
1615                         x+hShim+thumbRect.Left(), y+vShim+thumbRect.Top(),
1616                         thumbRect.GetWidth(), thumbRect.GetHeight(), scrollbarOrientation );
1617     }
1618 	// ----------------- BUTTON 1 //
1619 	if ( has_backward )
1620 	{
1621         NWConvertVCLStateToGTKState( pScrollbarVal->mnButton1State, &stateType, &shadowType );
1622         if ( stateType == GTK_STATE_INSENSITIVE )	stateType = GTK_STATE_NORMAL;
1623         gtk_paint_box( style, gdkDrawable, stateType, shadowType,
1624                        gdkRect, GTK_WIDGET(scrollbarWidget), "stepper",
1625                        x+hShim+button11BoundRect.Left(), y+vShim+button11BoundRect.Top(),
1626                        button11BoundRect.GetWidth(), button11BoundRect.GetHeight() );
1627         // ----------------- ARROW 1
1628     	NWCalcArrowRect( button11BoundRect, arrowRect );
1629     	gtk_paint_arrow( style, gdkDrawable, stateType, shadowType,
1630                          gdkRect, GTK_WIDGET(scrollbarWidget), scrollbarTag, button1Type, sal_True,
1631                          x+hShim+arrowRect.Left(), y+vShim+arrowRect.Top(),
1632                          arrowRect.GetWidth(), arrowRect.GetHeight() );
1633     }
1634 	if ( has_forward2 )
1635 	{
1636         NWConvertVCLStateToGTKState( pScrollbarVal->mnButton2State, &stateType, &shadowType );
1637         if ( stateType == GTK_STATE_INSENSITIVE )	stateType = GTK_STATE_NORMAL;
1638         gtk_paint_box( style, gdkDrawable, stateType, shadowType,
1639                        gdkRect, GTK_WIDGET(scrollbarWidget), "stepper",
1640                        x+hShim+button12BoundRect.Left(), y+vShim+button12BoundRect.Top(),
1641                        button12BoundRect.GetWidth(), button12BoundRect.GetHeight() );
1642         // ----------------- ARROW 1
1643     	NWCalcArrowRect( button12BoundRect, arrowRect );
1644     	gtk_paint_arrow( style, gdkDrawable, stateType, shadowType,
1645                          gdkRect, GTK_WIDGET(scrollbarWidget), scrollbarTag, button2Type, sal_True,
1646                          x+hShim+arrowRect.Left(), y+vShim+arrowRect.Top(),
1647                          arrowRect.GetWidth(), arrowRect.GetHeight() );
1648     }
1649 	// ----------------- BUTTON 2
1650     if ( has_backward2 )
1651     {
1652         NWConvertVCLStateToGTKState( pScrollbarVal->mnButton1State, &stateType, &shadowType );
1653         if ( stateType == GTK_STATE_INSENSITIVE )	stateType = GTK_STATE_NORMAL;
1654         gtk_paint_box( style, gdkDrawable, stateType, shadowType, gdkRect,
1655                        GTK_WIDGET(scrollbarWidget), "stepper",
1656                        x+hShim+button21BoundRect.Left(), y+vShim+button21BoundRect.Top(),
1657                        button21BoundRect.GetWidth(), button21BoundRect.GetHeight() );
1658     	// ----------------- ARROW 2
1659     	NWCalcArrowRect( button21BoundRect, arrowRect );
1660         gtk_paint_arrow( style, gdkDrawable, stateType, shadowType,
1661                          gdkRect, GTK_WIDGET(scrollbarWidget), scrollbarTag, button1Type, sal_True,
1662                          x+hShim+arrowRect.Left(), y+vShim+arrowRect.Top(),
1663                          arrowRect.GetWidth(), arrowRect.GetHeight() );
1664     }
1665     if ( has_forward )
1666     {
1667         NWConvertVCLStateToGTKState( pScrollbarVal->mnButton2State, &stateType, &shadowType );
1668         if ( stateType == GTK_STATE_INSENSITIVE )	stateType = GTK_STATE_NORMAL;
1669         gtk_paint_box( style, gdkDrawable, stateType, shadowType, gdkRect,
1670                        GTK_WIDGET(scrollbarWidget), "stepper",
1671                        x+hShim+button22BoundRect.Left(), y+vShim+button22BoundRect.Top(),
1672                        button22BoundRect.GetWidth(), button22BoundRect.GetHeight() );
1673     	// ----------------- ARROW 2
1674     	NWCalcArrowRect( button22BoundRect, arrowRect );
1675         gtk_paint_arrow( style, gdkDrawable, stateType, shadowType,
1676                          gdkRect, GTK_WIDGET(scrollbarWidget), scrollbarTag, button2Type, sal_True,
1677                          x+hShim+arrowRect.Left(), y+vShim+arrowRect.Top(),
1678                          arrowRect.GetWidth(), arrowRect.GetHeight() );
1679     }
1680 
1681     if( !NWRenderPixmapToScreen(pixmap, pixmapRect) )
1682     {
1683         g_object_unref( pixmap );
1684         return( sal_False );
1685     }
1686     g_object_unref( pixmap );
1687 
1688 	return( sal_True );
1689 }
1690 
1691 //---
1692 
1693 static Rectangle NWGetScrollButtonRect(	int nScreen, ControlPart nPart, Rectangle aAreaRect )
1694 {
1695     gint slider_width;
1696     gint stepper_size;
1697     gint stepper_spacing;
1698     gint trough_border;
1699 
1700     NWEnsureGTKScrollbars( nScreen );
1701 
1702 	// Grab some button style attributes
1703 	gtk_widget_style_get( gWidgetData[nScreen].gScrollHorizWidget,
1704                                       "slider-width", &slider_width,
1705 									  "stepper-size", &stepper_size,
1706 									  "trough-border", &trough_border,
1707 	   								  "stepper-spacing", &stepper_spacing, (char *)NULL );
1708 
1709     gboolean has_forward;
1710     gboolean has_forward2;
1711     gboolean has_backward;
1712     gboolean has_backward2;
1713 
1714 	gtk_widget_style_get( gWidgetData[nScreen].gScrollHorizWidget,
1715                                       "has-forward-stepper", &has_forward,
1716 									  "has-secondary-forward-stepper", &has_forward2,
1717 									  "has-backward-stepper", &has_backward,
1718 	   								  "has-secondary-backward-stepper", &has_backward2, (char *)NULL );
1719 	gint       buttonWidth;
1720 	gint       buttonHeight;
1721 	Rectangle  buttonRect;
1722 
1723     gint nFirst = 0;
1724     gint nSecond = 0;
1725 
1726     if ( has_forward )   nSecond += 1;
1727     if ( has_forward2 )  nFirst  += 1;
1728     if ( has_backward )  nFirst  += 1;
1729     if ( has_backward2 ) nSecond += 1;
1730 
1731     if ( ( nPart == PART_BUTTON_UP ) || ( nPart == PART_BUTTON_DOWN ) )
1732     {
1733         buttonWidth = slider_width + 2 * trough_border;
1734         buttonHeight = stepper_size + trough_border + stepper_spacing;
1735     }
1736     else
1737     {
1738         buttonWidth = stepper_size + trough_border + stepper_spacing;
1739         buttonHeight = slider_width + 2 * trough_border;
1740     }
1741 
1742     if ( nPart == PART_BUTTON_UP )
1743     {
1744         buttonHeight *= nFirst;
1745         buttonHeight -= 1;
1746         buttonRect.setX( aAreaRect.Left() );
1747         buttonRect.setY( aAreaRect.Top() );
1748     }
1749     else if ( nPart == PART_BUTTON_LEFT )
1750     {
1751         buttonWidth *= nFirst;
1752         buttonWidth -= 1;
1753         buttonRect.setX( aAreaRect.Left() );
1754         buttonRect.setY( aAreaRect.Top() );
1755     }
1756     else if ( nPart == PART_BUTTON_DOWN )
1757     {
1758         buttonHeight *= nSecond;
1759         buttonRect.setX( aAreaRect.Left() );
1760         buttonRect.setY( aAreaRect.Top() + aAreaRect.GetHeight() - buttonHeight );
1761     }
1762     else if ( nPart == PART_BUTTON_RIGHT )
1763     {
1764         buttonWidth *= nSecond;
1765         buttonRect.setX( aAreaRect.Left() + aAreaRect.GetWidth() - buttonWidth );
1766         buttonRect.setY( aAreaRect.Top() );
1767     }
1768 
1769     buttonRect.SetSize( Size( buttonWidth, buttonHeight ) );
1770 
1771 	return( buttonRect );
1772 }
1773 
1774 //-------------------------------------
1775 
1776 sal_Bool GtkSalGraphics::NWPaintGTKEditBox( GdkDrawable* gdkDrawable,
1777                                         ControlType nType, ControlPart nPart,
1778                                         const Rectangle& rControlRectangle,
1779                                         const clipList& rClipList,
1780                                         ControlState nState,
1781                                         const ImplControlValue& aValue,
1782                                         const OUString& rCaption )
1783 {
1784 	Rectangle		pixmapRect;
1785     GdkRectangle    clipRect;
1786 
1787 	// Find the overall bounding rect of the buttons's drawing area,
1788 	// plus its actual draw rect excluding adornment
1789 	pixmapRect = NWGetEditBoxPixmapRect( m_nScreen, nType, nPart, rControlRectangle,
1790 					                     nState, aValue, rCaption );
1791     for( clipList::const_iterator it = rClipList.begin(); it != rClipList.end(); ++it )
1792     {
1793         clipRect.x = it->Left();
1794         clipRect.y = it->Top();
1795         clipRect.width = it->GetWidth();
1796         clipRect.height = it->GetHeight();
1797 
1798         NWPaintOneEditBox( m_nScreen, gdkDrawable, &clipRect, nType, nPart, pixmapRect, nState, aValue, rCaption );
1799     }
1800 
1801 	return( sal_True );
1802 }
1803 
1804 
1805 /* Take interior/exterior focus into account and return
1806  * the bounding rectangle of the edit box including
1807  * any focus requirements.
1808  */
1809 static Rectangle NWGetEditBoxPixmapRect(int nScreen,
1810                                         ControlType,
1811 								        ControlPart,
1812                                         Rectangle aAreaRect,
1813                                         ControlState,
1814                                         const ImplControlValue&,
1815                                         const OUString& )
1816 {
1817 	Rectangle		pixmapRect = aAreaRect;
1818 	gboolean		interiorFocus;
1819 	gint			focusWidth;
1820 
1821 	NWEnsureGTKEditBox( nScreen );
1822 
1823 	// Grab some entry style attributes
1824 	gtk_widget_style_get( gWidgetData[nScreen].gEditBoxWidget,
1825                                 	"focus-line-width",	&focusWidth,
1826 					 				"interior-focus",	&interiorFocus, (char *)NULL );
1827 
1828 	if ( !interiorFocus )
1829 	{
1830 		pixmapRect.Move( -(focusWidth), -(focusWidth) );
1831         pixmapRect.SetSize( Size( pixmapRect.GetWidth() + (2*(focusWidth)),
1832                                   pixmapRect.GetHeight() + (2*(focusWidth)) ) );
1833 	}
1834 
1835 	return( pixmapRect );
1836 }
1837 
1838 
1839 /* Paint a GTK Entry widget into the specified GdkPixmap.
1840  * All coordinates should be local to the Pixmap, NOT
1841  * screen/window coordinates.
1842  */
1843 static void NWPaintOneEditBox(	int nScreen,
1844                                 GdkDrawable * gdkDrawable,
1845                                 GdkRectangle *	gdkRect,
1846                                 ControlType			nType,
1847                                 ControlPart,
1848                                 Rectangle				aEditBoxRect,
1849                                 ControlState			nState,
1850                                 const ImplControlValue&,
1851                                 const OUString& )
1852 {
1853 	GtkStateType	stateType;
1854 	GtkShadowType	shadowType;
1855 	GtkWidget      *widget;
1856 
1857 	NWEnsureGTKButton( nScreen );
1858 	NWEnsureGTKEditBox( nScreen );
1859 	NWEnsureGTKSpinButton( nScreen );
1860 	NWEnsureGTKCombo( nScreen );
1861 	NWEnsureGTKScrolledWindow( nScreen );
1862 	NWConvertVCLStateToGTKState( nState, &stateType, &shadowType );
1863 
1864     /* border's shadowType for gtk entries is always GTK_SHADOW_IN (see gtkentry.c)
1865     shadowType = GTK_SHADOW_IN;
1866     */
1867 
1868 	switch ( nType )
1869 	{
1870 		case CTRL_SPINBOX:
1871 			widget = gWidgetData[nScreen].gSpinButtonWidget;
1872 			break;
1873 
1874         case CTRL_MULTILINE_EDITBOX:
1875             widget = gWidgetData[nScreen].gScrolledWindowWidget;
1876             break;
1877 		case CTRL_COMBOBOX:
1878 			widget = GTK_COMBO(gWidgetData[nScreen].gComboWidget)->entry;
1879 			break;
1880 
1881 		default:
1882 			widget = gWidgetData[nScreen].gEditBoxWidget;
1883 			break;
1884 	}
1885 
1886 	if ( stateType == GTK_STATE_PRELIGHT )
1887 		stateType = GTK_STATE_NORMAL;
1888 
1889 	// Blueprint needs to paint entry_bg with a Button widget, not an Entry widget to get
1890 	// a nice white (or whatever default color) background
1891     GtkWidget* pBGWidget = widget;
1892     if( GtkSalGraphics::bNeedButtonStyleAsEditBackgroundWorkaround )
1893     {
1894         NWSetWidgetState( gWidgetData[nScreen].gBtnWidget, nState, stateType );
1895         pBGWidget = gWidgetData[nScreen].gBtnWidget;
1896     }
1897 	NWSetWidgetState( widget, nState, stateType );
1898 
1899 	gtk_paint_flat_box( pBGWidget->style, gdkDrawable, stateType, GTK_SHADOW_NONE,
1900                         gdkRect, pBGWidget, "entry_bg",
1901                         aEditBoxRect.Left(), aEditBoxRect.Top(),
1902                         aEditBoxRect.GetWidth(), aEditBoxRect.GetHeight() );
1903 	gtk_paint_shadow( widget->style, gdkDrawable, GTK_STATE_NORMAL, GTK_SHADOW_IN,
1904                       gdkRect, widget, "entry",
1905                       aEditBoxRect.Left(), aEditBoxRect.Top(),
1906                       aEditBoxRect.GetWidth(), aEditBoxRect.GetHeight() );
1907 
1908 }
1909 
1910 
1911 
1912 //-------------------------------------
1913 
1914 sal_Bool GtkSalGraphics::NWPaintGTKSpinBox( ControlType nType, ControlPart nPart,
1915                                         const Rectangle& rControlRectangle,
1916                                         const clipList&,
1917                                         ControlState nState,
1918                                         const ImplControlValue& aValue,
1919                                         const OUString& rCaption )
1920 {
1921 	GdkPixmap	*		pixmap;
1922 	Rectangle			pixmapRect;
1923 	GtkStateType		stateType;
1924 	GtkShadowType		shadowType;
1925 	const SpinbuttonValue *	pSpinVal = (aValue.getType() == CTRL_SPINBUTTONS) ? static_cast<const SpinbuttonValue *>(&aValue) : NULL;
1926 	Rectangle			upBtnRect;
1927 	ControlPart		upBtnPart = PART_BUTTON_UP;
1928 	ControlState		upBtnState = CTRL_STATE_ENABLED;
1929 	Rectangle			downBtnRect;
1930 	ControlPart		downBtnPart = PART_BUTTON_DOWN;
1931 	ControlState		downBtnState = CTRL_STATE_ENABLED;
1932 
1933 	NWEnsureGTKButton( m_nScreen );
1934 	NWEnsureGTKSpinButton( m_nScreen );
1935 	NWEnsureGTKArrow( m_nScreen );
1936 
1937 	NWConvertVCLStateToGTKState( nState, &stateType, &shadowType );
1938 
1939 	if ( pSpinVal )
1940 	{
1941 		upBtnPart = pSpinVal->mnUpperPart;
1942 		upBtnState = pSpinVal->mnUpperState;
1943 
1944 		downBtnPart = pSpinVal->mnLowerPart;
1945 		downBtnState = pSpinVal->mnLowerState;
1946 	}
1947 
1948 	// CTRL_SPINBUTTONS pass their area in pSpinVal, not in rControlRectangle
1949 	if ( nType == CTRL_SPINBUTTONS )
1950 	{
1951 		if ( !pSpinVal )
1952 		{
1953             std::fprintf( stderr, "Tried to draw CTRL_SPINBUTTONS, but the SpinButtons data structure didn't exist!\n" );
1954 			return( false );
1955 		}
1956 		pixmapRect = pSpinVal->maUpperRect;
1957 		pixmapRect.Union( pSpinVal->maLowerRect );
1958 	}
1959 	else
1960 		pixmapRect = rControlRectangle;
1961 
1962 
1963 	pixmap = NWGetPixmapFromScreen( pixmapRect );
1964 	if ( !pixmap )
1965 		return( sal_False );
1966 
1967 	upBtnRect = NWGetSpinButtonRect( m_nScreen, nType, upBtnPart, pixmapRect, upBtnState, aValue, rCaption );
1968 	downBtnRect = NWGetSpinButtonRect( m_nScreen, nType, downBtnPart, pixmapRect, downBtnState, aValue, rCaption );
1969 
1970 	if ( (nType==CTRL_SPINBOX) && (nPart!=PART_ALL_BUTTONS) )
1971 	{
1972 		// Draw an edit field for SpinBoxes and ComboBoxes
1973 		Rectangle aEditBoxRect( pixmapRect );
1974 		aEditBoxRect.SetSize( Size( upBtnRect.Left() - pixmapRect.Left(), aEditBoxRect.GetHeight() ) );
1975 		aEditBoxRect.setX( 0 );
1976 		aEditBoxRect.setY( 0 );
1977 
1978 		NWPaintOneEditBox( m_nScreen, pixmap, NULL, nType, nPart, aEditBoxRect, nState, aValue, rCaption );
1979 	}
1980 
1981 	NWSetWidgetState( gWidgetData[m_nScreen].gSpinButtonWidget, nState, stateType );
1982 	gtk_widget_style_get( gWidgetData[m_nScreen].gSpinButtonWidget, "shadow_type", &shadowType, (char *)NULL );
1983 
1984 	if ( shadowType != GTK_SHADOW_NONE )
1985 	{
1986 		Rectangle		shadowRect( upBtnRect );
1987 
1988 		shadowRect.Union( downBtnRect );
1989 		gtk_paint_box( gWidgetData[m_nScreen].gSpinButtonWidget->style, pixmap, GTK_STATE_NORMAL, shadowType, NULL,
1990 			gWidgetData[m_nScreen].gSpinButtonWidget, "spinbutton",
1991 			(shadowRect.Left() - pixmapRect.Left()), (shadowRect.Top() - pixmapRect.Top()),
1992 			shadowRect.GetWidth(), shadowRect.GetHeight() );
1993 	}
1994 
1995 	NWPaintOneSpinButton( m_nScreen, pixmap, nType, upBtnPart, pixmapRect, upBtnState, aValue, rCaption );
1996 	NWPaintOneSpinButton( m_nScreen, pixmap, nType, downBtnPart, pixmapRect, downBtnState, aValue, rCaption );
1997 
1998 	if( !NWRenderPixmapToScreen(pixmap, pixmapRect) )
1999 	{
2000 		g_object_unref( pixmap );
2001 		return( sal_False );
2002 	}
2003 
2004 	g_object_unref( pixmap );
2005 	return( sal_True );
2006 }
2007 
2008 //---
2009 
2010 static Rectangle NWGetSpinButtonRect( int nScreen,
2011                                       ControlType,
2012 								      ControlPart			nPart,
2013                                       Rectangle 			aAreaRect,
2014                                       ControlState,
2015                                       const ImplControlValue&,
2016                                       const OUString& )
2017 {
2018 	gint			buttonSize;
2019 	Rectangle		buttonRect;
2020 
2021 	NWEnsureGTKSpinButton( nScreen );
2022 
2023 	buttonSize = MAX( PANGO_PIXELS( pango_font_description_get_size(GTK_WIDGET(gWidgetData[nScreen].gSpinButtonWidget)->style->font_desc) ),
2024 				   MIN_SPIN_ARROW_WIDTH );
2025 	buttonSize -= buttonSize % 2 - 1; /* force odd */
2026 	buttonRect.SetSize( Size( buttonSize + 2 * gWidgetData[nScreen].gSpinButtonWidget->style->xthickness,
2027                               buttonRect.GetHeight() ) );
2028 	buttonRect.setX( aAreaRect.Left() + (aAreaRect.GetWidth() - buttonRect.GetWidth()) );
2029 	if ( nPart == PART_BUTTON_UP )
2030 	{
2031 		buttonRect.setY( aAreaRect.Top() );
2032 		buttonRect.Bottom() = buttonRect.Top() + (aAreaRect.GetHeight() / 2);
2033 	}
2034 	else if( nPart == PART_BUTTON_DOWN )
2035 	{
2036 		buttonRect.setY( aAreaRect.Top() + (aAreaRect.GetHeight() / 2) );
2037 		buttonRect.Bottom() = aAreaRect.Bottom(); // cover area completely
2038 	}
2039     else
2040     {
2041         buttonRect.Right()  = buttonRect.Left()-1;
2042         buttonRect.Left()   = aAreaRect.Left();
2043         buttonRect.Top()    = aAreaRect.Top();
2044         buttonRect.Bottom() = aAreaRect.Bottom();
2045     }
2046 
2047 	return( buttonRect );
2048 }
2049 
2050 //---
2051 
2052 static void NWPaintOneSpinButton( int nScreen,
2053                                   GdkPixmap*			pixmap,
2054                                   ControlType			nType,
2055                                   ControlPart			nPart,
2056                                   Rectangle				aAreaRect,
2057                                   ControlState			nState,
2058                                   const ImplControlValue&	aValue,
2059                                   const OUString&				rCaption )
2060 {
2061 	Rectangle			buttonRect;
2062 	GtkStateType		stateType;
2063 	GtkShadowType		shadowType;
2064 	Rectangle			arrowRect;
2065 	gint				arrowSize;
2066 
2067 	NWEnsureGTKSpinButton( nScreen );
2068 	NWConvertVCLStateToGTKState( nState, &stateType, &shadowType );
2069 
2070 	buttonRect = NWGetSpinButtonRect( nScreen, nType, nPart, aAreaRect, nState, aValue, rCaption );
2071 
2072 	NWSetWidgetState( gWidgetData[nScreen].gSpinButtonWidget, nState, stateType );
2073 	gtk_paint_box( gWidgetData[nScreen].gSpinButtonWidget->style, pixmap, stateType, shadowType, NULL, gWidgetData[nScreen].gSpinButtonWidget,
2074 			(nPart == PART_BUTTON_UP) ? "spinbutton_up" : "spinbutton_down",
2075 			(buttonRect.Left() - aAreaRect.Left()), (buttonRect.Top() - aAreaRect.Top()),
2076 			buttonRect.GetWidth(), buttonRect.GetHeight() );
2077 
2078 	arrowSize = (buttonRect.GetWidth() - (2 * gWidgetData[nScreen].gSpinButtonWidget->style->xthickness)) - 4;
2079 	arrowSize -= arrowSize % 2 - 1; /* force odd */
2080     arrowRect.SetSize( Size( arrowSize, arrowSize ) );
2081 	arrowRect.setX( buttonRect.Left() + (buttonRect.GetWidth() - arrowRect.GetWidth()) / 2 );
2082 	if ( nPart == PART_BUTTON_UP )
2083 		arrowRect.setY( buttonRect.Top() + (buttonRect.GetHeight() - arrowRect.GetHeight()) / 2 + 1);
2084 	else
2085 		arrowRect.setY( buttonRect.Top() + (buttonRect.GetHeight() - arrowRect.GetHeight()) / 2 - 1);
2086 
2087 	gtk_paint_arrow( gWidgetData[nScreen].gSpinButtonWidget->style, pixmap, stateType, GTK_SHADOW_OUT, NULL, gWidgetData[nScreen].gSpinButtonWidget,
2088 			"spinbutton", (nPart == PART_BUTTON_UP) ? GTK_ARROW_UP : GTK_ARROW_DOWN, sal_True,
2089 			(arrowRect.Left() - aAreaRect.Left()), (arrowRect.Top() - aAreaRect.Top()),
2090 			arrowRect.GetWidth(), arrowRect.GetHeight() );
2091 }
2092 
2093 
2094 //-------------------------------------
2095 
2096 sal_Bool GtkSalGraphics::NWPaintGTKComboBox( GdkDrawable* gdkDrawable,
2097                                          ControlType nType, ControlPart nPart,
2098                                          const Rectangle& rControlRectangle,
2099                                          const clipList& rClipList,
2100                                          ControlState nState,
2101                                          const ImplControlValue& aValue,
2102                                          const OUString& rCaption )
2103 {
2104 	Rectangle		pixmapRect;
2105 	Rectangle		buttonRect;
2106 	GtkStateType	stateType;
2107 	GtkShadowType	shadowType;
2108 	Rectangle		arrowRect;
2109     gint			x,y;
2110     GdkRectangle	clipRect;
2111 
2112 	NWEnsureGTKButton( m_nScreen );
2113 	NWEnsureGTKArrow( m_nScreen );
2114 	NWEnsureGTKCombo( m_nScreen );
2115 	NWConvertVCLStateToGTKState( nState, &stateType, &shadowType );
2116 
2117 	// Find the overall bounding rect of the buttons's drawing area,
2118 	// plus its actual draw rect excluding adornment
2119 	pixmapRect = rControlRectangle;
2120     x = rControlRectangle.Left();
2121     y = rControlRectangle.Top();
2122 
2123 	NWSetWidgetState( gWidgetData[m_nScreen].gBtnWidget, nState, stateType );
2124 	NWSetWidgetState( gWidgetData[m_nScreen].gComboWidget, nState, stateType );
2125 	NWSetWidgetState( gWidgetData[m_nScreen].gArrowWidget, nState, stateType );
2126 
2127     buttonRect = NWGetComboBoxButtonRect( m_nScreen, nType, PART_BUTTON_DOWN, pixmapRect, nState, aValue, rCaption );
2128     if( nPart == PART_BUTTON_DOWN )
2129         buttonRect.Left() += 1;
2130 
2131 	Rectangle		aEditBoxRect( pixmapRect );
2132 	aEditBoxRect.SetSize( Size( pixmapRect.GetWidth() - buttonRect.GetWidth(), aEditBoxRect.GetHeight() ) );
2133 
2134     #define ARROW_EXTENT		0.7
2135 	arrowRect.SetSize( Size( (gint)(MIN_ARROW_SIZE * ARROW_EXTENT),
2136 	                         (gint)(MIN_ARROW_SIZE * ARROW_EXTENT) ) );
2137 	arrowRect.SetPos( Point( buttonRect.Left() + (gint)((buttonRect.GetWidth() - arrowRect.GetWidth()) / 2),
2138                              buttonRect.Top() + (gint)((buttonRect.GetHeight() - arrowRect.GetHeight()) / 2) ) );
2139 
2140     for( clipList::const_iterator it = rClipList.begin(); it != rClipList.end(); ++it )
2141     {
2142         clipRect.x = it->Left();
2143         clipRect.y = it->Top();
2144         clipRect.width = it->GetWidth();
2145         clipRect.height = it->GetHeight();
2146 
2147         if( nPart == PART_ENTIRE_CONTROL )
2148             NWPaintOneEditBox( m_nScreen, gdkDrawable, &clipRect, nType, nPart, aEditBoxRect,
2149                                nState, aValue, rCaption );
2150 
2151         // Buttons must paint opaque since some themes have alpha-channel enabled buttons
2152         gtk_paint_flat_box( gWidgetData[m_nScreen].gBtnWidget->style, gdkDrawable, GTK_STATE_NORMAL, GTK_SHADOW_NONE,
2153                             &clipRect, m_pWindow, "base",
2154                             x+(buttonRect.Left() - pixmapRect.Left()),
2155                             y+(buttonRect.Top() - pixmapRect.Top()),
2156                             buttonRect.GetWidth(), buttonRect.GetHeight() );
2157         gtk_paint_box( GTK_COMBO(gWidgetData[m_nScreen].gComboWidget)->button->style, gdkDrawable, stateType, shadowType,
2158                        &clipRect, GTK_COMBO(gWidgetData[m_nScreen].gComboWidget)->button, "button",
2159                        x+(buttonRect.Left() - pixmapRect.Left()),
2160                        y+(buttonRect.Top() - pixmapRect.Top()),
2161                        buttonRect.GetWidth(), buttonRect.GetHeight() );
2162 
2163         gtk_paint_arrow( gWidgetData[m_nScreen].gArrowWidget->style, gdkDrawable, stateType, shadowType,
2164                          &clipRect, gWidgetData[m_nScreen].gArrowWidget, "arrow", GTK_ARROW_DOWN, sal_True,
2165                          x+(arrowRect.Left() - pixmapRect.Left()), y+(arrowRect.Top() - pixmapRect.Top()),
2166                          arrowRect.GetWidth(), arrowRect.GetHeight() );
2167     }
2168 
2169 	return( sal_True );
2170 }
2171 
2172 //----
2173 
2174 static Rectangle NWGetComboBoxButtonRect( int nScreen,
2175                                           ControlType,
2176 									      ControlPart nPart,
2177                                           Rectangle				aAreaRect,
2178                                           ControlState,
2179                                           const ImplControlValue&,
2180                                           const OUString& )
2181 {
2182 	Rectangle	aButtonRect;
2183 	gint		nArrowWidth;
2184     gint        nButtonWidth;
2185 	gint		nFocusWidth;
2186 	gint		nFocusPad;
2187 
2188 	NWEnsureGTKArrow( nScreen );
2189 
2190 	// Grab some button style attributes
2191 	gtk_widget_style_get( gWidgetData[nScreen].gDropdownWidget,
2192                                   	"focus-line-width",	&nFocusWidth,
2193 									"focus-padding", 	&nFocusPad, (char *)NULL );
2194 
2195 	nArrowWidth = MIN_ARROW_SIZE + (GTK_MISC(gWidgetData[nScreen].gArrowWidget)->xpad * 2);
2196     nButtonWidth = nArrowWidth +
2197                    ((BTN_CHILD_SPACING + gWidgetData[nScreen].gDropdownWidget->style->xthickness) * 2)
2198 				   + (2 * (nFocusWidth+nFocusPad));
2199     if( nPart == PART_BUTTON_DOWN )
2200     {
2201         aButtonRect.SetSize( Size( nButtonWidth, aAreaRect.GetHeight() ) );
2202         aButtonRect.SetPos( Point( aAreaRect.Left() + aAreaRect.GetWidth() - nButtonWidth,
2203                                    aAreaRect.Top() ) );
2204     }
2205     else if( nPart == PART_SUB_EDIT )
2206     {
2207         NWEnsureGTKCombo( nScreen );
2208 
2209         gint adjust_x = GTK_CONTAINER(gWidgetData[nScreen].gComboWidget)->border_width +
2210                         nFocusWidth +
2211                         nFocusPad;
2212         gint adjust_y = adjust_x + gWidgetData[nScreen].gComboWidget->style->ythickness;
2213         adjust_x     += gWidgetData[nScreen].gComboWidget->style->xthickness;
2214         aButtonRect.SetSize( Size( aAreaRect.GetWidth() - nButtonWidth - 2 * adjust_x,
2215                                    aAreaRect.GetHeight() - 2 * adjust_y ) );
2216         Point aEditPos = aAreaRect.TopLeft();
2217         aEditPos.X() += adjust_x;
2218         aEditPos.Y() += adjust_y;
2219         aButtonRect.SetPos( aEditPos );
2220     }
2221 
2222 	return( aButtonRect );
2223 }
2224 
2225 //-------------------------------------
2226 
2227 
2228 
2229 sal_Bool GtkSalGraphics::NWPaintGTKTabItem( ControlType nType, ControlPart,
2230                                         const Rectangle& rControlRectangle,
2231                                         const clipList&,
2232                                         ControlState nState,
2233                                         const ImplControlValue& aValue,
2234                                         const OUString& )
2235 {
2236     OSL_ASSERT( nType != CTRL_TAB_ITEM || aValue.getType() == CTRL_TAB_ITEM );
2237 	GdkPixmap *	pixmap;
2238 	Rectangle		pixmapRect;
2239 	Rectangle		tabRect;
2240 	GtkStateType	stateType;
2241 	GtkShadowType	shadowType;
2242     if( ! gWidgetData[ m_nScreen ].gCacheTabItems )
2243     {
2244         gWidgetData[ m_nScreen ].gCacheTabItems = new NWPixmapCache( m_nScreen );
2245         gWidgetData[ m_nScreen ].gCacheTabPages = new NWPixmapCache( m_nScreen );
2246     }
2247     NWPixmapCache& aCacheItems = *gWidgetData[ m_nScreen ].gCacheTabItems;
2248     NWPixmapCache& aCachePage = *gWidgetData[ m_nScreen ].gCacheTabPages;
2249 
2250     if( !aCacheItems.GetSize() )
2251         aCacheItems.SetSize( 20 );
2252     if( !aCachePage.GetSize() )
2253         aCachePage.SetSize( 1 );
2254 
2255 	if ( (nType == CTRL_TAB_ITEM) && (aValue.getType() != CTRL_TAB_ITEM) )
2256 	{
2257 		return( false );
2258 	}
2259 
2260 	NWEnsureGTKButton( m_nScreen );
2261 	NWEnsureGTKNotebook( m_nScreen );
2262 	NWConvertVCLStateToGTKState( nState, &stateType, &shadowType );
2263 
2264 	// Find the overall bounding rect of the buttons's drawing area,
2265 	// plus its actual draw rect excluding adornment
2266 	pixmapRect = rControlRectangle;
2267 	if ( nType == CTRL_TAB_ITEM )
2268 	{
2269         const TabitemValue *	pTabitemValue = static_cast<const TabitemValue *>(&aValue);
2270 		if ( !pTabitemValue->isFirst() )
2271 		{
2272 			// GTK+ tabs overlap on the right edge (the top tab obscures the
2273 			// left edge of the tab right "below" it, so adjust the rectangle
2274 			// to draw tabs slightly large so the overlap happens
2275 			pixmapRect.Move( -2, 0 );
2276 			pixmapRect.SetSize( Size( pixmapRect.GetWidth() + 2, pixmapRect.GetHeight() ) );
2277 		}
2278 		if ( nState & CTRL_STATE_SELECTED )
2279 		{
2280 			// In GTK+, the selected tab is 2px taller than all other tabs
2281 			pixmapRect.Move( 0, -2 );
2282 			pixmapRect.Bottom() += 2;
2283 			tabRect = pixmapRect;
2284 			// Only draw over 1 pixel of the tab pane that this tab is drawn on top of.
2285 			tabRect.Bottom() -= 1;
2286 		}
2287 		else
2288 			tabRect = pixmapRect;
2289 
2290 		// Allow the tab to draw a right border if needed
2291 		tabRect.Right() -= 1;
2292 
2293         // #129732# avoid degenerate cases which might lead to crashes
2294         if( tabRect.GetWidth() <= 1 || tabRect.GetHeight() <= 1 )
2295             return false;
2296 	}
2297 
2298     if( nType == CTRL_TAB_ITEM )
2299     {
2300         if( aCacheItems.Find( nType, nState, pixmapRect, &pixmap ) )
2301             return NWRenderPixmapToScreen( pixmap, pixmapRect );
2302     }
2303     else
2304     {
2305         if( aCachePage.Find( nType, nState, pixmapRect, &pixmap ) )
2306             return NWRenderPixmapToScreen( pixmap, pixmapRect );
2307     }
2308 
2309 
2310 //	gtk_widget_set_state( gWidgetData[m_nScreen].gNotebookWidget, stateType );
2311 
2312     pixmap = gdk_pixmap_new( NULL, pixmapRect.GetWidth(), pixmapRect.GetHeight(),
2313                              GetX11SalData()->GetDisplay()->GetVisual( m_nScreen ).GetDepth() );
2314     GdkRectangle paintRect;
2315     paintRect.x = paintRect.y = 0;
2316     paintRect.width = pixmapRect.GetWidth();
2317     paintRect.height = pixmapRect.GetHeight();
2318 
2319     gtk_paint_flat_box( m_pWindow->style, pixmap, GTK_STATE_NORMAL,
2320 		                GTK_SHADOW_NONE, &paintRect, m_pWindow, "base", 0, 0, -1, -1);
2321 
2322 	NWSetWidgetState( gWidgetData[m_nScreen].gNotebookWidget, nState, stateType );
2323 
2324 	switch( nType )
2325 	{
2326 		case CTRL_TAB_BODY:
2327 			break;
2328 
2329 		case CTRL_FIXEDBORDER:
2330 		case CTRL_TAB_PANE:
2331 			gtk_paint_box_gap( gWidgetData[m_nScreen].gNotebookWidget->style, pixmap, GTK_STATE_NORMAL, GTK_SHADOW_OUT, NULL, gWidgetData[m_nScreen].gNotebookWidget,
2332 				(char *)"notebook", 0, 0, pixmapRect.GetWidth(), pixmapRect.GetHeight(), GTK_POS_TOP, 0, 0 );
2333 			break;
2334 
2335 		case CTRL_TAB_ITEM:
2336 			stateType = ( nState & CTRL_STATE_SELECTED ) ? GTK_STATE_NORMAL : GTK_STATE_ACTIVE;
2337 
2338 			gtk_paint_extension( gWidgetData[m_nScreen].gNotebookWidget->style, pixmap, stateType, GTK_SHADOW_OUT, NULL, gWidgetData[m_nScreen].gNotebookWidget,
2339 				(char *)"tab", (tabRect.Left() - pixmapRect.Left()), (tabRect.Top() - pixmapRect.Top()),
2340 				tabRect.GetWidth(), tabRect.GetHeight(), GTK_POS_BOTTOM );
2341 
2342 			if ( nState & CTRL_STATE_SELECTED )
2343 			{
2344 				gtk_paint_flat_box( gWidgetData[m_nScreen].gNotebookWidget->style, pixmap, stateType, GTK_SHADOW_NONE, NULL, m_pWindow,
2345 					(char *)"base", 0, (pixmapRect.GetHeight() - 1), pixmapRect.GetWidth(), 1 );
2346 			}
2347 			break;
2348 
2349 		default:
2350 			break;
2351 	}
2352 
2353 	// Crux seems to think it can make the pane without a left edge
2354 	if ( nType == CTRL_FIXEDBORDER )
2355 		pixmapRect.Move( 1, 0 );
2356 
2357     // cache data
2358     if( nType == CTRL_TAB_ITEM )
2359         aCacheItems.Fill( nType, nState, pixmapRect, pixmap );
2360     else
2361         aCachePage.Fill( nType, nState, pixmapRect, pixmap );
2362 
2363 	sal_Bool bSuccess = NWRenderPixmapToScreen(pixmap, pixmapRect);
2364 	g_object_unref( pixmap );
2365 	return bSuccess;
2366 }
2367 
2368 //-------------------------------------
2369 
2370 sal_Bool GtkSalGraphics::NWPaintGTKListBox( GdkDrawable* gdkDrawable,
2371                                         ControlType nType, ControlPart nPart,
2372                                         const Rectangle& rControlRectangle,
2373                                         const clipList& rClipList,
2374                                         ControlState nState,
2375                                         const ImplControlValue& aValue,
2376                                         const OUString& rCaption )
2377 {
2378 	Rectangle		pixmapRect;
2379 	Rectangle		widgetRect;
2380 	Rectangle		aIndicatorRect;
2381 	GtkStateType	stateType;
2382 	GtkShadowType	shadowType;
2383 	gint			bInteriorFocus;
2384 	gint			nFocusLineWidth;
2385 	gint			nFocusPadding;
2386     gint			x,y;
2387     GdkRectangle    clipRect;
2388 
2389 	NWEnsureGTKButton( m_nScreen );
2390 	NWEnsureGTKOptionMenu( m_nScreen );
2391 	NWEnsureGTKScrolledWindow( m_nScreen );
2392 	NWConvertVCLStateToGTKState( nState, &stateType, &shadowType );
2393 
2394 	// Find the overall bounding rect of the buttons's drawing area,
2395 	// plus its actual draw rect excluding adornment
2396 	pixmapRect = rControlRectangle;
2397 	if ( nPart == PART_WINDOW )
2398 	{
2399 		// Make the widget a _bit_ bigger
2400 		pixmapRect.SetPos( Point( pixmapRect.Left() - 1,
2401                                   pixmapRect.Top() - 1 ) );
2402 		pixmapRect.SetSize( Size( pixmapRect.GetWidth() + 2,
2403 		                          pixmapRect.GetHeight() + 2 ) );
2404 	}
2405 
2406 	widgetRect = pixmapRect;
2407     x = pixmapRect.Left();
2408     y = pixmapRect.Top();
2409 
2410     // set up references to correct drawable and cliprect
2411 	NWSetWidgetState( gWidgetData[m_nScreen].gBtnWidget, nState, stateType );
2412 	NWSetWidgetState( gWidgetData[m_nScreen].gOptionMenuWidget, nState, stateType );
2413 	NWSetWidgetState( gWidgetData[m_nScreen].gScrolledWindowWidget, nState, stateType );
2414 
2415 	if ( nPart != PART_WINDOW )
2416 	{
2417 		gtk_widget_style_get( gWidgetData[m_nScreen].gOptionMenuWidget,
2418 			"interior_focus",	&bInteriorFocus,
2419 			"focus_line_width",	&nFocusLineWidth,
2420 			"focus_padding",	&nFocusPadding,
2421 			(char *)NULL);
2422     }
2423 
2424     for( clipList::const_iterator it = rClipList.begin(); it != rClipList.end(); ++it )
2425     {
2426         clipRect.x = it->Left();
2427         clipRect.y = it->Top();
2428         clipRect.width = it->GetWidth();
2429         clipRect.height = it->GetHeight();
2430 
2431         if ( nPart != PART_WINDOW )
2432         {
2433             // Listboxes must paint opaque since some themes have alpha-channel enabled bodies
2434             gtk_paint_flat_box( gWidgetData[m_nScreen].gBtnWidget->style, gdkDrawable, GTK_STATE_NORMAL, GTK_SHADOW_NONE,
2435                                 &clipRect, m_pWindow, "base", x, y,
2436                                 pixmapRect.GetWidth(), pixmapRect.GetHeight() );
2437             gtk_paint_box( gWidgetData[m_nScreen].gOptionMenuWidget->style, gdkDrawable, stateType, shadowType, &clipRect,
2438                            gWidgetData[m_nScreen].gOptionMenuWidget, "optionmenu",
2439                            x+(widgetRect.Left() - pixmapRect.Left()),
2440                            y+(widgetRect.Top() - pixmapRect.Top()),
2441                            widgetRect.GetWidth(), widgetRect.GetHeight() );
2442             aIndicatorRect = NWGetListBoxIndicatorRect( m_nScreen, nType, nPart, widgetRect, nState,
2443                                                         aValue, rCaption );
2444             gtk_paint_tab( gWidgetData[m_nScreen].gOptionMenuWidget->style, gdkDrawable, stateType, shadowType, &clipRect,
2445                            gWidgetData[m_nScreen].gOptionMenuWidget, "optionmenutab",
2446                            x+(aIndicatorRect.Left() - pixmapRect.Left()),
2447                            y+(aIndicatorRect.Top() - pixmapRect.Top()),
2448                            aIndicatorRect.GetWidth(), aIndicatorRect.GetHeight() );
2449         }
2450         else
2451         {
2452             shadowType = GTK_SHADOW_IN;
2453 
2454             gtk_paint_shadow( gWidgetData[m_nScreen].gScrolledWindowWidget->style, gdkDrawable, GTK_STATE_NORMAL, shadowType,
2455                 &clipRect, gWidgetData[m_nScreen].gScrolledWindowWidget, "scrolled_window",
2456                 x+(widgetRect.Left() - pixmapRect.Left()), y+(widgetRect.Top() - pixmapRect.Top()),
2457                 widgetRect.GetWidth(), widgetRect.GetHeight() );
2458         }
2459     }
2460 
2461 	return( sal_True );
2462 }
2463 
2464 sal_Bool GtkSalGraphics::NWPaintGTKToolbar(
2465             GdkDrawable* gdkDrawable,
2466             ControlType, ControlPart nPart,
2467 			const Rectangle& rControlRectangle,
2468             const clipList& rClipList,
2469             ControlState nState, const ImplControlValue& aValue,
2470 			const OUString& )
2471 {
2472 	GtkStateType	stateType;
2473 	GtkShadowType	shadowType;
2474 	gint			x, y, w, h;
2475     gint            g_x=0, g_y=0, g_w=10, g_h=10;
2476     bool            bPaintButton = true;
2477     GtkWidget*      pButtonWidget = gWidgetData[m_nScreen].gToolbarButtonWidget;
2478     GdkRectangle	clipRect;
2479 
2480 	NWEnsureGTKToolbar( m_nScreen );
2481     if( nPart == PART_BUTTON ) // toolbar buttons cannot focus in gtk
2482         nState &= ~CTRL_STATE_FOCUSED;
2483 	NWConvertVCLStateToGTKState( nState, &stateType, &shadowType );
2484 
2485 	x = rControlRectangle.Left();
2486     y = rControlRectangle.Top();
2487 	w = rControlRectangle.GetWidth();
2488 	h = rControlRectangle.GetHeight();
2489 
2490     // handle toolbar
2491     if( nPart == PART_DRAW_BACKGROUND_HORZ || nPart == PART_DRAW_BACKGROUND_VERT )
2492     {
2493 	    NWSetWidgetState( gWidgetData[m_nScreen].gToolbarWidget, nState, stateType );
2494 
2495         GTK_WIDGET_UNSET_FLAGS( gWidgetData[m_nScreen].gToolbarWidget, GTK_SENSITIVE );
2496         if ( nState & CTRL_STATE_ENABLED )
2497             GTK_WIDGET_SET_FLAGS( gWidgetData[m_nScreen].gToolbarWidget, GTK_SENSITIVE );
2498 
2499         if( nPart == PART_DRAW_BACKGROUND_HORZ )
2500             gtk_toolbar_set_orientation( GTK_TOOLBAR(gWidgetData[m_nScreen].gToolbarWidget), GTK_ORIENTATION_HORIZONTAL );
2501         else
2502             gtk_toolbar_set_orientation( GTK_TOOLBAR(gWidgetData[m_nScreen].gToolbarWidget), GTK_ORIENTATION_VERTICAL );
2503     }
2504     // handle grip
2505     else if( nPart == PART_THUMB_HORZ || nPart == PART_THUMB_VERT )
2506     {
2507 	    NWSetWidgetState( gWidgetData[m_nScreen].gHandleBoxWidget, nState, stateType );
2508 
2509         GTK_WIDGET_UNSET_FLAGS( gWidgetData[m_nScreen].gHandleBoxWidget, GTK_SENSITIVE );
2510         if ( nState & CTRL_STATE_ENABLED )
2511             GTK_WIDGET_SET_FLAGS( gWidgetData[m_nScreen].gHandleBoxWidget, GTK_SENSITIVE );
2512 
2513         gtk_handle_box_set_shadow_type( GTK_HANDLE_BOX(gWidgetData[m_nScreen].gHandleBoxWidget), shadowType );
2514 
2515         // evaluate grip rect
2516         if( aValue.getType() == CTRL_TOOLBAR )
2517         {
2518             const ToolbarValue* pVal = static_cast<const ToolbarValue*>(&aValue);
2519             g_x = pVal->maGripRect.Left();
2520             g_y = pVal->maGripRect.Top();
2521             g_w = pVal->maGripRect.GetWidth();
2522             g_h = pVal->maGripRect.GetHeight();
2523         }
2524     }
2525     // handle button
2526     else if( nPart == PART_BUTTON )
2527     {
2528         bPaintButton =
2529             (GTK_BUTTON(pButtonWidget)->relief != GTK_RELIEF_NONE)
2530             || (nState & CTRL_STATE_PRESSED)
2531 		    || (nState & CTRL_STATE_ROLLOVER);
2532         if( aValue.getTristateVal() == BUTTONVALUE_ON )
2533         {
2534             pButtonWidget = gWidgetData[m_nScreen].gToolbarToggleWidget;
2535             shadowType = GTK_SHADOW_IN;
2536             stateType = GTK_STATE_ACTIVE;
2537             // special case stateType value for depressed toggle buttons
2538             // cf. gtk+/gtk/gtktogglebutton.c (gtk_toggle_button_update_state)
2539             if( (nState & (CTRL_STATE_ROLLOVER|CTRL_STATE_PRESSED)) )
2540             {
2541                 stateType = GTK_STATE_PRELIGHT;
2542                 shadowType = GTK_SHADOW_OUT;
2543             }
2544             bPaintButton = true;
2545         }
2546         else
2547             stateType = GTK_STATE_PRELIGHT; // only for bPaintButton = true, in which case always rollver is meant
2548 
2549         NWSetWidgetState( pButtonWidget, nState, stateType );
2550         gtk_widget_ensure_style( pButtonWidget );
2551     }
2552 
2553     for( clipList::const_iterator it = rClipList.begin(); it != rClipList.end(); ++it )
2554     {
2555         clipRect.x = it->Left();
2556         clipRect.y = it->Top();
2557         clipRect.width = it->GetWidth();
2558         clipRect.height = it->GetHeight();
2559 
2560         // draw toolbar
2561         if( nPart == PART_DRAW_BACKGROUND_HORZ || nPart == PART_DRAW_BACKGROUND_VERT )
2562         {
2563             gtk_paint_flat_box( gWidgetData[m_nScreen].gToolbarWidget->style,
2564                                 gdkDrawable,
2565                                 (GtkStateType)GTK_STATE_NORMAL,
2566                                 GTK_SHADOW_NONE,
2567                                 &clipRect,
2568                                 gWidgetData[m_nScreen].gToolbarWidget,
2569                                 "base",
2570                                 x, y, w, h );
2571             gtk_paint_box( gWidgetData[m_nScreen].gToolbarWidget->style,
2572                            gdkDrawable,
2573                            stateType,
2574                            shadowType,
2575                            &clipRect,
2576                            gWidgetData[m_nScreen].gToolbarWidget,
2577                            "toolbar",
2578                            x, y, w, h );
2579         }
2580         // draw grip
2581         else if( nPart == PART_THUMB_HORZ || nPart == PART_THUMB_VERT )
2582         {
2583             gtk_paint_handle( gWidgetData[m_nScreen].gHandleBoxWidget->style,
2584                               gdkDrawable,
2585                               GTK_STATE_NORMAL,
2586                               GTK_SHADOW_OUT,
2587                               &clipRect,
2588                               gWidgetData[m_nScreen].gHandleBoxWidget,
2589                               "handlebox",
2590                               g_x, g_y, g_w, g_h,
2591                               nPart == PART_THUMB_HORZ ?
2592                               GTK_ORIENTATION_HORIZONTAL :
2593                               GTK_ORIENTATION_VERTICAL
2594                               );
2595         }
2596         // draw button
2597         else if( nPart == PART_BUTTON )
2598         {
2599             if( bPaintButton )
2600             {
2601                 gtk_paint_box( pButtonWidget->style, gdkDrawable,
2602                                stateType,
2603                                shadowType,
2604                                &clipRect,
2605                                pButtonWidget, "button", x, y, w, h );
2606             }
2607         }
2608     }
2609 
2610 	return( sal_True );
2611 }
2612 
2613 //----
2614 
2615 sal_Bool GtkSalGraphics::NWPaintGTKMenubar(
2616             GdkDrawable* gdkDrawable,
2617             ControlType, ControlPart nPart,
2618 			const Rectangle& rControlRectangle,
2619             const clipList& rClipList,
2620             ControlState nState, const ImplControlValue&,
2621 			const OUString& )
2622 {
2623 	GtkStateType	stateType;
2624 	GtkShadowType	shadowType;
2625     GtkShadowType   selected_shadow_type = GTK_SHADOW_OUT;
2626 	gint			x, y, w, h;
2627     GdkRectangle	clipRect;
2628 
2629 	NWEnsureGTKMenubar( m_nScreen );
2630 	NWConvertVCLStateToGTKState( nState, &stateType, &shadowType );
2631 
2632 	x = rControlRectangle.Left();
2633     y = rControlRectangle.Top();
2634 	w = rControlRectangle.GetWidth();
2635 	h = rControlRectangle.GetHeight();
2636 
2637     if( nPart == PART_MENU_ITEM )
2638     {
2639         if( nState & (CTRL_STATE_SELECTED|CTRL_STATE_ROLLOVER) )
2640         {
2641             gtk_widget_style_get( gWidgetData[m_nScreen].gMenuItemMenubarWidget,
2642                                   "selected_shadow_type", &selected_shadow_type,
2643                                   (char *)NULL);
2644         }
2645     }
2646 
2647     for( clipList::const_iterator it = rClipList.begin(); it != rClipList.end(); ++it )
2648     {
2649         clipRect.x = it->Left();
2650         clipRect.y = it->Top();
2651         clipRect.width = it->GetWidth();
2652         clipRect.height = it->GetHeight();
2653 
2654         // handle Menubar
2655         if( nPart == PART_ENTIRE_CONTROL )
2656         {
2657             NWSetWidgetState( gWidgetData[m_nScreen].gMenubarWidget, nState, stateType );
2658 
2659             GTK_WIDGET_UNSET_FLAGS( gWidgetData[m_nScreen].gMenubarWidget, GTK_SENSITIVE );
2660             if ( nState & CTRL_STATE_ENABLED )
2661                 GTK_WIDGET_SET_FLAGS( gWidgetData[m_nScreen].gMenubarWidget, GTK_SENSITIVE );
2662 
2663             // #118704# for translucent menubar styles paint background first
2664             gtk_paint_flat_box( gWidgetData[m_nScreen].gMenubarWidget->style,
2665                                 gdkDrawable,
2666                                 GTK_STATE_NORMAL,
2667                                 GTK_SHADOW_NONE,
2668                                 &clipRect,
2669                                 GTK_WIDGET(m_pWindow),
2670                                 "base",
2671                                 x, y, w, h );
2672             gtk_paint_box( gWidgetData[m_nScreen].gMenubarWidget->style,
2673                            gdkDrawable,
2674                            stateType,
2675                            shadowType,
2676                            &clipRect,
2677                            gWidgetData[m_nScreen].gMenubarWidget,
2678                            "menubar",
2679                            x, y, w, h );
2680         }
2681         else if( nPart == PART_MENU_ITEM )
2682         {
2683             if( nState & (CTRL_STATE_SELECTED|CTRL_STATE_ROLLOVER) )
2684             {
2685                 gtk_paint_box( gWidgetData[m_nScreen].gMenuItemMenubarWidget->style,
2686                                gdkDrawable,
2687                                GTK_STATE_PRELIGHT,
2688                                selected_shadow_type,
2689                                &clipRect,
2690                                gWidgetData[m_nScreen].gMenuItemMenubarWidget,
2691                                "menuitem",
2692                                x, y, w, h);
2693             }
2694         }
2695     }
2696 
2697 	return( sal_True );
2698 }
2699 
2700 sal_Bool GtkSalGraphics::NWPaintGTKPopupMenu(
2701             GdkDrawable* gdkDrawable,
2702             ControlType, ControlPart nPart,
2703 			const Rectangle& rControlRectangle,
2704             const clipList& rClipList,
2705             ControlState nState, const ImplControlValue&,
2706 			const OUString& )
2707 {
2708     // #i50745# gtk does not draw disabled menu entries (and crux theme
2709     // even crashes), draw them using vcl functionality.
2710     if( nPart == PART_MENU_ITEM && ! (nState & CTRL_STATE_ENABLED) )
2711         return sal_False;
2712 
2713 	GtkStateType	stateType;
2714 	GtkShadowType	shadowType;
2715     GtkShadowType   selected_shadow_type = GTK_SHADOW_OUT;
2716 	gint			x, y, w, h;
2717     GdkRectangle	clipRect;
2718 
2719 	NWEnsureGTKMenu( m_nScreen );
2720 	NWConvertVCLStateToGTKState( nState, &stateType, &shadowType );
2721 
2722 	x = rControlRectangle.Left();
2723     y = rControlRectangle.Top();
2724 	w = rControlRectangle.GetWidth();
2725 	h = rControlRectangle.GetHeight();
2726 
2727     if( nPart == PART_MENU_ITEM &&
2728         ( nState & (CTRL_STATE_SELECTED|CTRL_STATE_ROLLOVER) ) )
2729     {
2730         gtk_widget_style_get( gWidgetData[m_nScreen].gMenuItemMenuWidget,
2731                               "selected_shadow_type", &selected_shadow_type,
2732                               (char *)NULL);
2733     }
2734 
2735     NWSetWidgetState( gWidgetData[m_nScreen].gMenuWidget, nState, stateType );
2736 
2737     GTK_WIDGET_UNSET_FLAGS( gWidgetData[m_nScreen].gMenuWidget, GTK_SENSITIVE );
2738     if ( nState & CTRL_STATE_ENABLED )
2739         GTK_WIDGET_SET_FLAGS( gWidgetData[m_nScreen].gMenuWidget, GTK_SENSITIVE );
2740 
2741     for( clipList::const_iterator it = rClipList.begin(); it != rClipList.end(); ++it )
2742     {
2743         clipRect.x = it->Left();
2744         clipRect.y = it->Top();
2745         clipRect.width = it->GetWidth();
2746         clipRect.height = it->GetHeight();
2747 
2748         if( nPart == PART_ENTIRE_CONTROL )
2749         {
2750             // #118704# for translucent menubar styles paint background first
2751             gtk_paint_flat_box( gWidgetData[m_nScreen].gMenuWidget->style,
2752                                 gdkDrawable,
2753                                 GTK_STATE_NORMAL,
2754                                 GTK_SHADOW_NONE,
2755                                 &clipRect,
2756                                 GTK_WIDGET(m_pWindow),
2757                                 "base",
2758                                 x, y, w, h );
2759             gtk_paint_box( gWidgetData[m_nScreen].gMenuWidget->style,
2760                            gdkDrawable,
2761                            GTK_STATE_NORMAL,
2762                            GTK_SHADOW_OUT,
2763                            &clipRect,
2764                            gWidgetData[m_nScreen].gMenuWidget,
2765                            "menu",
2766                            x, y, w, h );
2767         }
2768         else if( nPart == PART_MENU_ITEM )
2769         {
2770             if( nState & (CTRL_STATE_SELECTED|CTRL_STATE_ROLLOVER) )
2771             {
2772                 if( nState & CTRL_STATE_ENABLED )
2773                 gtk_paint_box( gWidgetData[m_nScreen].gMenuItemMenuWidget->style,
2774                                gdkDrawable,
2775                                GTK_STATE_PRELIGHT,
2776                                selected_shadow_type,
2777                                &clipRect,
2778                                gWidgetData[m_nScreen].gMenuItemMenuWidget,
2779                                "menuitem",
2780                                x, y, w, h);
2781             }
2782         }
2783         else if( nPart == PART_MENU_ITEM_CHECK_MARK || nPart == PART_MENU_ITEM_RADIO_MARK )
2784         {
2785             GtkWidget* pWidget = (nPart == PART_MENU_ITEM_CHECK_MARK) ?
2786                                  gWidgetData[m_nScreen].gMenuItemCheckMenuWidget :
2787                                  gWidgetData[m_nScreen].gMenuItemRadioMenuWidget;
2788 
2789             GtkStateType nStateType = GTK_STATE_NORMAL;
2790             GtkShadowType nShadowType;
2791 
2792             if ( nState & CTRL_STATE_SELECTED )
2793                 nStateType = GTK_STATE_PRELIGHT;
2794 
2795             NWSetWidgetState( pWidget, nState, nStateType );
2796 
2797             if ( nState & CTRL_STATE_PRESSED )
2798                 nShadowType = GTK_SHADOW_IN;
2799             else
2800                 nShadowType = GTK_SHADOW_OUT;
2801 
2802             if ( nPart == PART_MENU_ITEM_CHECK_MARK )
2803             {
2804                 gtk_paint_check( pWidget->style,
2805                                  gdkDrawable,
2806                                  nStateType,
2807                                  nShadowType,
2808                                  &clipRect,
2809                                  gWidgetData[m_nScreen].gMenuItemMenuWidget,
2810                                  "check",
2811                                  x, y, w, h );
2812             }
2813             else
2814             {
2815                 gtk_paint_option( pWidget->style,
2816                                   gdkDrawable,
2817                                   nStateType,
2818                                   nShadowType,
2819                                   &clipRect,
2820                                   gWidgetData[m_nScreen].gMenuItemMenuWidget,
2821                                   "option",
2822                                   x, y, w, h );
2823             }
2824         }
2825     }
2826 
2827 	return( sal_True );
2828 }
2829 
2830 sal_Bool GtkSalGraphics::NWPaintGTKTooltip(
2831             GdkDrawable* gdkDrawable,
2832             ControlType, ControlPart,
2833 			const Rectangle& rControlRectangle,
2834             const clipList& rClipList,
2835             ControlState, const ImplControlValue&,
2836 			const OUString& )
2837 {
2838     NWEnsureGTKTooltip( m_nScreen );
2839 
2840 	gint			x, y, w, h;
2841     GdkRectangle	clipRect;
2842 
2843 	x = rControlRectangle.Left();
2844     y = rControlRectangle.Top();
2845 	w = rControlRectangle.GetWidth();
2846 	h = rControlRectangle.GetHeight();
2847 
2848     for( clipList::const_iterator it = rClipList.begin(); it != rClipList.end(); ++it )
2849     {
2850         clipRect.x = it->Left();
2851         clipRect.y = it->Top();
2852         clipRect.width = it->GetWidth();
2853         clipRect.height = it->GetHeight();
2854 
2855         gtk_paint_flat_box( gWidgetData[m_nScreen].gTooltipPopup->style,
2856                             gdkDrawable,
2857                             GTK_STATE_NORMAL,
2858                             GTK_SHADOW_OUT,
2859                             &clipRect,
2860                             gWidgetData[m_nScreen].gTooltipPopup,
2861                             "tooltip",
2862                             x, y, w, h );
2863     }
2864 
2865 	return( sal_True );
2866 }
2867 
2868 sal_Bool GtkSalGraphics::NWPaintGTKListNode(
2869             GdkDrawable*,
2870             ControlType, ControlPart,
2871 			const Rectangle& rControlRectangle,
2872             const clipList&,
2873             ControlState nState, const ImplControlValue& rValue,
2874 			const OUString& )
2875 {
2876     NWEnsureGTKTreeView( m_nScreen );
2877 
2878     Rectangle aRect( rControlRectangle );
2879     aRect.Left() -= 2;
2880     aRect.Right() += 2;
2881     aRect.Top() -= 2;
2882     aRect.Bottom() += 2;
2883 	gint			w, h;
2884 	w = aRect.GetWidth();
2885 	h = aRect.GetHeight();
2886 
2887 	GtkStateType	stateType;
2888 	GtkShadowType	shadowType;
2889 	NWConvertVCLStateToGTKState( nState, &stateType, &shadowType );
2890 
2891     ButtonValue aButtonValue = rValue.getTristateVal();
2892     GtkExpanderStyle eStyle = GTK_EXPANDER_EXPANDED;
2893 
2894     switch( aButtonValue )
2895     {
2896         case BUTTONVALUE_ON: eStyle = GTK_EXPANDER_EXPANDED;break;
2897         case BUTTONVALUE_OFF: eStyle = GTK_EXPANDER_COLLAPSED; break;
2898         default:
2899             break;
2900     }
2901 
2902     GdkPixmap* pixmap = NWGetPixmapFromScreen( aRect );
2903     if( ! pixmap )
2904         return sal_False;
2905 
2906     GdkDrawable* const &pixDrawable = GDK_DRAWABLE( pixmap );
2907     gtk_paint_expander( gWidgetData[m_nScreen].gTreeView->style,
2908                         pixDrawable,
2909                         stateType,
2910                         NULL,
2911                         gWidgetData[m_nScreen].gTreeView,
2912                         "treeview",
2913                         w/2, h/2,
2914                         eStyle );
2915 
2916 	sal_Bool bRet = NWRenderPixmapToScreen( pixmap, aRect );
2917     g_object_unref( pixmap );
2918 
2919 	return bRet;
2920 }
2921 
2922 sal_Bool GtkSalGraphics::NWPaintGTKProgress(
2923             GdkDrawable*,
2924             ControlType, ControlPart,
2925 			const Rectangle& rControlRectangle,
2926             const clipList&,
2927             ControlState, const ImplControlValue& rValue,
2928 			const OUString& )
2929 {
2930     NWEnsureGTKProgressBar( m_nScreen );
2931 
2932 	gint			w, h;
2933 	w = rControlRectangle.GetWidth();
2934 	h = rControlRectangle.GetHeight();
2935 
2936     long nProgressWidth = rValue.getNumericVal();
2937 
2938     GdkPixmap* pixmap = NWGetPixmapFromScreen( Rectangle( Point( 0, 0 ), Size( w, h ) ) );
2939     if( ! pixmap )
2940         return sal_False;
2941 
2942     GdkDrawable* const &pixDrawable = GDK_DRAWABLE( pixmap );
2943 
2944     // paint background
2945     gtk_paint_flat_box( gWidgetData[m_nScreen].gProgressBar->style,
2946                         pixDrawable,
2947                         GTK_STATE_NORMAL,
2948                         GTK_SHADOW_NONE,
2949                         NULL,
2950                         gWidgetData[m_nScreen].gProgressBar,
2951                         "trough",
2952                         0, 0, w, h );
2953     if( nProgressWidth > 0 )
2954     {
2955         // paint progress
2956         if( Application::GetSettings().GetLayoutRTL() )
2957         {
2958             gtk_paint_box( gWidgetData[m_nScreen].gProgressBar->style,
2959                            pixDrawable,
2960                            GTK_STATE_PRELIGHT, GTK_SHADOW_OUT,
2961                            NULL,
2962                            gWidgetData[m_nScreen].gProgressBar,
2963                            "bar",
2964                            w-nProgressWidth, 0, nProgressWidth, h
2965                            );
2966         }
2967         else
2968         {
2969             gtk_paint_box( gWidgetData[m_nScreen].gProgressBar->style,
2970                            pixDrawable,
2971                            GTK_STATE_PRELIGHT, GTK_SHADOW_OUT,
2972                            NULL,
2973                            gWidgetData[m_nScreen].gProgressBar,
2974                            "bar",
2975                            0, 0, nProgressWidth, h
2976                            );
2977         }
2978     }
2979 
2980 	sal_Bool bRet = NWRenderPixmapToScreen( pixmap, rControlRectangle );
2981     g_object_unref( pixmap );
2982 
2983 	return bRet;
2984 }
2985 
2986 sal_Bool GtkSalGraphics::NWPaintGTKSlider(
2987             GdkDrawable*,
2988             ControlType, ControlPart nPart,
2989 			const Rectangle& rControlRectangle,
2990             const clipList&,
2991             ControlState nState, const ImplControlValue& rValue,
2992 			const OUString& )
2993 {
2994     OSL_ASSERT( rValue.getType() == CTRL_SLIDER );
2995     NWEnsureGTKSlider( m_nScreen );
2996 
2997 	gint			w, h;
2998 	w = rControlRectangle.GetWidth();
2999 	h = rControlRectangle.GetHeight();
3000 
3001     const SliderValue* pVal = static_cast<const SliderValue*>(&rValue);
3002 
3003     GdkPixmap* pixmap = NWGetPixmapFromScreen( rControlRectangle );
3004     if( ! pixmap )
3005         return sal_False;
3006 
3007     GdkDrawable* const &pixDrawable = GDK_DRAWABLE( pixmap );
3008     GtkWidget* pWidget = (nPart == PART_TRACK_HORZ_AREA)
3009                          ? GTK_WIDGET(gWidgetData[m_nScreen].gHScale)
3010                          : GTK_WIDGET(gWidgetData[m_nScreen].gVScale);
3011     const gchar* pDetail = (nPart == PART_TRACK_HORZ_AREA) ? "hscale" : "vscale";
3012     GtkOrientation eOri = (nPart == PART_TRACK_HORZ_AREA) ? GTK_ORIENTATION_HORIZONTAL : GTK_ORIENTATION_VERTICAL;
3013     GtkStateType eState = (nState & CTRL_STATE_ENABLED) ? GTK_STATE_ACTIVE : GTK_STATE_INSENSITIVE;
3014     gint slider_width = 10;
3015     gint slider_length = 10;
3016     gint trough_border = 0;
3017     gtk_widget_style_get( pWidget,
3018                           "slider-width", &slider_width,
3019                           "slider-length", &slider_length,
3020                           "trough-border", &trough_border,
3021                           NULL);
3022 
3023     eState = (nState & CTRL_STATE_ENABLED) ? GTK_STATE_NORMAL : GTK_STATE_INSENSITIVE;
3024     if( nPart == PART_TRACK_HORZ_AREA )
3025     {
3026         gtk_paint_box( pWidget->style,
3027                        pixDrawable,
3028                        eState,
3029                        GTK_SHADOW_IN,
3030                        NULL,
3031                        pWidget,
3032                        "trough",
3033                        0, (h-slider_width-2*trough_border)/2, w, slider_width + 2*trough_border);
3034         gint x = (w - slider_length + 1) * (pVal->mnCur - pVal->mnMin) / (pVal->mnMax - pVal->mnMin);
3035         gtk_paint_slider( pWidget->style,
3036                           pixDrawable,
3037                           eState,
3038                           GTK_SHADOW_OUT,
3039                           NULL,
3040                           pWidget,
3041                           pDetail,
3042                           x, (h-slider_width)/2,
3043                           slider_length, slider_width,
3044                           eOri );
3045     }
3046     else
3047     {
3048         gtk_paint_box( pWidget->style,
3049                        pixDrawable,
3050                        eState,
3051                        GTK_SHADOW_IN,
3052                        NULL,
3053                        pWidget,
3054                        "trough",
3055                        (w-slider_width-2*trough_border)/2, 0, slider_width + 2*trough_border, h);
3056         gint y = (h - slider_length + 1) * (pVal->mnCur - pVal->mnMin) / (pVal->mnMax - pVal->mnMin);
3057         gtk_paint_slider( pWidget->style,
3058                           pixDrawable,
3059                           eState,
3060                           GTK_SHADOW_OUT,
3061                           NULL,
3062                           pWidget,
3063                           pDetail,
3064                           (w-slider_width)/2, y,
3065                           slider_width, slider_length,
3066                           eOri );
3067     }
3068     #if 0
3069     // paint background
3070     gtk_paint_flat_box( gWidgetData[m_nScreen].gProgressBar->style,
3071                         pixDrawable,
3072                         GTK_STATE_NORMAL,
3073                         GTK_SHADOW_NONE,
3074                         NULL,
3075                         gWidgetData[m_nScreen].gProgressBar,
3076                         "trough",
3077                         0, 0, w, h );
3078     if( nProgressWidth > 0 )
3079     {
3080         // paint progress
3081         if( Application::GetSettings().GetLayoutRTL() )
3082         {
3083             gtk_paint_box( gWidgetData[m_nScreen].gProgressBar->style,
3084                            pixDrawable,
3085                            GTK_STATE_PRELIGHT, GTK_SHADOW_OUT,
3086                            NULL,
3087                            gWidgetData[m_nScreen].gProgressBar,
3088                            "bar",
3089                            w-nProgressWidth, 0, nProgressWidth, h
3090                            );
3091         }
3092         else
3093         {
3094             gtk_paint_box( gWidgetData[m_nScreen].gProgressBar->style,
3095                            pixDrawable,
3096                            GTK_STATE_PRELIGHT, GTK_SHADOW_OUT,
3097                            NULL,
3098                            gWidgetData[m_nScreen].gProgressBar,
3099                            "bar",
3100                            0, 0, nProgressWidth, h
3101                            );
3102         }
3103     }
3104     #endif
3105 
3106 	sal_Bool bRet = NWRenderPixmapToScreen( pixmap, rControlRectangle );
3107     g_object_unref( pixmap );
3108 
3109 	return bRet;
3110 }
3111 
3112 //----
3113 
3114 static Rectangle NWGetListBoxButtonRect( int nScreen,
3115                                          ControlType,
3116                                          ControlPart    nPart,
3117                                          Rectangle      aAreaRect,
3118                                          ControlState,
3119                                          const ImplControlValue&,
3120                                          const OUString& )
3121 {
3122 	Rectangle       aPartRect;
3123 	GtkRequisition *pIndicatorSize = NULL;
3124 	GtkBorder      *pIndicatorSpacing = NULL;
3125 	gint            width = 13;	// GTK+ default
3126 	gint            right = 5;	// GTK+ default
3127 	gint            nButtonAreaWidth = 0;
3128     gint            xthickness = 0;
3129 
3130 	NWEnsureGTKOptionMenu( nScreen );
3131 
3132 	gtk_widget_style_get( gWidgetData[nScreen].gOptionMenuWidget,
3133 			"indicator_size",	&pIndicatorSize,
3134 			"indicator_spacing",&pIndicatorSpacing, (char *)NULL);
3135 
3136 	if ( pIndicatorSize )
3137 		width = pIndicatorSize->width;
3138 
3139 	if ( pIndicatorSpacing )
3140 		right = pIndicatorSpacing->right;
3141 
3142     Size aPartSize( 0, aAreaRect.GetHeight() );
3143     Point aPartPos ( 0, aAreaRect.Top() );
3144 
3145     xthickness = gWidgetData[nScreen].gOptionMenuWidget->style->xthickness;
3146 	nButtonAreaWidth = width + right + (xthickness * 2);
3147 	switch( nPart )
3148 	{
3149 		case PART_BUTTON_DOWN:
3150 			aPartSize.Width() = nButtonAreaWidth;
3151 			aPartPos.X() = aAreaRect.Left() + aAreaRect.GetWidth() - aPartSize.Width();
3152 			break;
3153 
3154 		case PART_SUB_EDIT:
3155 			aPartSize.Width() = aAreaRect.GetWidth() - nButtonAreaWidth - xthickness;
3156 			aPartPos.X() = aAreaRect.Left() + xthickness;
3157 			break;
3158 
3159 		default:
3160 			aPartSize.Width() = aAreaRect.GetWidth();
3161 			aPartPos.X() = aAreaRect.Left();
3162 			break;
3163 	}
3164     aPartRect = Rectangle( aPartPos, aPartSize );
3165 
3166 	if ( pIndicatorSize )
3167 		gtk_requisition_free( pIndicatorSize );
3168 	if ( pIndicatorSpacing )
3169 		gtk_border_free( pIndicatorSpacing );
3170 
3171 	return( aPartRect );
3172 }
3173 
3174 //----
3175 
3176 static Rectangle NWGetListBoxIndicatorRect( int nScreen,
3177                                             ControlType,
3178                                             ControlPart,
3179                                             Rectangle				aAreaRect,
3180                                             ControlState,
3181                                             const ImplControlValue&,
3182                                             const OUString& )
3183 {
3184 	Rectangle       aIndicatorRect;
3185 	GtkRequisition *pIndicatorSize = NULL;
3186 	GtkBorder      *pIndicatorSpacing = NULL;
3187 	gint            width = 13;	// GTK+ default
3188 	gint            height = 13;	// GTK+ default
3189 	gint            right = 5;	// GTK+ default
3190 
3191 	NWEnsureGTKOptionMenu( nScreen );
3192 
3193 	gtk_widget_style_get( gWidgetData[nScreen].gOptionMenuWidget,
3194 			"indicator_size",	&pIndicatorSize,
3195 			"indicator_spacing",&pIndicatorSpacing, (char *)NULL);
3196 
3197 	if ( pIndicatorSize )
3198     {
3199 		width = pIndicatorSize->width;
3200 		height = pIndicatorSize->height;
3201     }
3202 
3203 	if ( pIndicatorSpacing )
3204 		right = pIndicatorSpacing->right;
3205 
3206     aIndicatorRect.SetSize( Size( width, height ) );
3207 	aIndicatorRect.SetPos( Point( aAreaRect.Left() + aAreaRect.GetWidth() - width - right - gWidgetData[nScreen].gOptionMenuWidget->style->xthickness,
3208                                   aAreaRect.Top() + ((aAreaRect.GetHeight() - height) / 2) ) );
3209 
3210 	// If height is odd, move the indicator down 1 pixel
3211 	if ( aIndicatorRect.GetHeight() % 2 )
3212 		aIndicatorRect.Move( 0, 1 );
3213 
3214 	if ( pIndicatorSize )
3215 		gtk_requisition_free( pIndicatorSize );
3216 	if ( pIndicatorSpacing )
3217 		gtk_border_free( pIndicatorSpacing );
3218 
3219 	return( aIndicatorRect );
3220 }
3221 
3222 static Rectangle NWGetToolbarRect(  int nScreen,
3223                                     ControlType,
3224 									ControlPart				nPart,
3225 									Rectangle				aAreaRect,
3226 									ControlState,
3227 									const ImplControlValue&,
3228 									const OUString& )
3229 {
3230     Rectangle aRet;
3231 
3232     if( nPart == PART_DRAW_BACKGROUND_HORZ ||
3233         nPart == PART_DRAW_BACKGROUND_VERT )
3234         aRet = aAreaRect;
3235     else if( nPart == PART_THUMB_HORZ )
3236         aRet = Rectangle( Point( 0, 0 ), Size( aAreaRect.GetWidth(), 10 ) );
3237     else if( nPart == PART_THUMB_VERT )
3238         aRet = Rectangle( Point( 0, 0 ), Size( 10, aAreaRect.GetHeight() ) );
3239     else if( nPart == PART_BUTTON )
3240     {
3241         aRet = aAreaRect;
3242 
3243         NWEnsureGTKToolbar( nScreen );
3244 
3245         gint nMinWidth =
3246             2*gWidgetData[nScreen].gToolbarButtonWidget->style->xthickness
3247             + 1 // CHILD_SPACING constant, found in gtk_button.c
3248             + 3*gWidgetData[nScreen].gToolbarButtonWidget->style->xthickness; // Murphy factor
3249         gint nMinHeight =
3250             2*gWidgetData[nScreen].gToolbarButtonWidget->style->ythickness
3251             + 1 // CHILD_SPACING constant, found in gtk_button.c
3252             + 3*gWidgetData[nScreen].gToolbarButtonWidget->style->ythickness; // Murphy factor
3253 
3254         gtk_widget_ensure_style( gWidgetData[nScreen].gToolbarButtonWidget );
3255         if( aAreaRect.GetWidth() < nMinWidth )
3256             aRet.Right() = aRet.Left() + nMinWidth;
3257         if( aAreaRect.GetHeight() < nMinHeight  )
3258             aRet.Bottom() = aRet.Top() + nMinHeight;
3259     }
3260 
3261     return aRet;
3262 }
3263 
3264 /************************************************************************
3265  * helper for GtkSalFrame
3266  ************************************************************************/
3267 static inline Color getColor( const GdkColor& rCol )
3268 {
3269     return Color( rCol.red >> 8, rCol.green >> 8, rCol.blue >> 8 );
3270 }
3271 
3272 #if OSL_DEBUG_LEVEL > 1
3273 
3274 void printColor( const char* name, const GdkColor& rCol )
3275 {
3276     std::fprintf( stderr, "   %s = 0x%2x 0x%2x 0x%2x\n",
3277              name,
3278              rCol.red >> 8, rCol.green >> 8, rCol.blue >> 8 );
3279 }
3280 
3281 void printStyleColors( GtkStyle* pStyle )
3282 {
3283     static const char* pStates[] = { "NORMAL", "ACTIVE", "PRELIGHT", "SELECTED", "INSENSITIVE" };
3284 
3285     for( int i = 0; i < 5; i++ )
3286     {
3287         std::fprintf( stderr, "state %s colors:\n", pStates[i] );
3288         printColor( "bg     ", pStyle->bg[i] );
3289         printColor( "fg     ", pStyle->fg[i] );
3290         printColor( "light  ", pStyle->light[i] );
3291         printColor( "dark   ", pStyle->dark[i] );
3292         printColor( "mid    ", pStyle->mid[i] );
3293         printColor( "text   ", pStyle->text[i] );
3294         printColor( "base   ", pStyle->base[i] );
3295         printColor( "text_aa", pStyle->text_aa[i] );
3296     }
3297 }
3298 #endif
3299 
3300 void GtkSalGraphics::updateSettings( AllSettings& rSettings )
3301 {
3302     // get the widgets in place
3303     NWEnsureGTKMenu( m_nScreen );
3304     NWEnsureGTKMenubar( m_nScreen );
3305     NWEnsureGTKScrollbars( m_nScreen );
3306     NWEnsureGTKEditBox( m_nScreen );
3307     NWEnsureGTKTooltip( m_nScreen );
3308 
3309     gtk_widget_ensure_style( m_pWindow );
3310     GtkStyle* pStyle = gtk_widget_get_style( m_pWindow );
3311 
3312     StyleSettings aStyleSet = rSettings.GetStyleSettings();
3313 
3314 #if OSL_DEBUG_LEVEL > 2
3315     printStyleColors( pStyle );
3316 #endif
3317 
3318     // text colors
3319     Color aTextColor = getColor( pStyle->text[GTK_STATE_NORMAL] );
3320     aStyleSet.SetDialogTextColor( aTextColor );
3321     aStyleSet.SetButtonTextColor( aTextColor );
3322     aStyleSet.SetRadioCheckTextColor( aTextColor );
3323     aStyleSet.SetGroupTextColor( aTextColor );
3324     aStyleSet.SetLabelTextColor( aTextColor );
3325     aStyleSet.SetInfoTextColor( aTextColor );
3326     aStyleSet.SetWindowTextColor( aTextColor );
3327     aStyleSet.SetFieldTextColor( aTextColor );
3328 
3329     // Tooltip colors
3330     GtkStyle* pTooltipStyle = gtk_widget_get_style( gWidgetData[m_nScreen].gTooltipPopup );
3331     aTextColor = getColor( pTooltipStyle->fg[ GTK_STATE_NORMAL ] );
3332     aStyleSet.SetHelpTextColor( aTextColor );
3333 
3334     // mouse over text colors
3335     aTextColor = getColor( pStyle->fg[ GTK_STATE_PRELIGHT ] );
3336     aStyleSet.SetButtonRolloverTextColor( aTextColor );
3337     aStyleSet.SetFieldRolloverTextColor( aTextColor );
3338 
3339     // background colors
3340     Color aBackColor = getColor( pStyle->bg[GTK_STATE_NORMAL] );
3341     Color aBackFieldColor = getColor( pStyle->base[ GTK_STATE_NORMAL ] );
3342     aStyleSet.Set3DColors( aBackColor );
3343     aStyleSet.SetFaceColor( aBackColor );
3344     aStyleSet.SetDialogColor( aBackColor );
3345     aStyleSet.SetWorkspaceColor( aBackColor );
3346     aStyleSet.SetFieldColor( aBackFieldColor );
3347     aStyleSet.SetWindowColor( aBackFieldColor );
3348 //    aStyleSet.SetHelpColor( aBackColor );
3349     // ancient wisdom tells us a mystic algorithm how to set checked color
3350     if( aBackColor == COL_LIGHTGRAY )
3351         aStyleSet.SetCheckedColor( Color( 0xCC, 0xCC, 0xCC ) );
3352     else
3353     {
3354         Color aColor2 = aStyleSet.GetLightColor();
3355         Color aCheck( (sal_uInt8)(((sal_uInt16)aBackColor.GetRed()+(sal_uInt16)aColor2.GetRed())/2),
3356                       (sal_uInt8)(((sal_uInt16)aBackColor.GetGreen()+(sal_uInt16)aColor2.GetGreen())/2),
3357                       (sal_uInt8)(((sal_uInt16)aBackColor.GetBlue()+(sal_uInt16)aColor2.GetBlue())/2)
3358                       );
3359         aStyleSet.SetCheckedColor( aCheck );
3360     }
3361 
3362     // highlighting colors
3363     Color aHighlightColor = getColor( pStyle->base[GTK_STATE_SELECTED] );
3364     Color aHighlightTextColor = getColor( pStyle->text[GTK_STATE_SELECTED] );
3365     aStyleSet.SetHighlightColor( aHighlightColor );
3366     aStyleSet.SetHighlightTextColor( aHighlightTextColor );
3367 
3368     if( ! gtk_check_version( 2, 10, 0 ) ) // link colors came in with 2.10, avoid an assertion
3369     {
3370         // hyperlink colors
3371         GdkColor *link_color = NULL;
3372         gtk_widget_style_get (m_pWindow, "link-color", &link_color, NULL);
3373         if (link_color)
3374         {
3375             aStyleSet.SetLinkColor(getColor(*link_color));
3376             gdk_color_free (link_color);
3377             link_color = NULL;
3378         }
3379         gtk_widget_style_get (m_pWindow, "visited-link-color", &link_color, NULL);
3380         if (link_color)
3381         {
3382             aStyleSet.SetVisitedLinkColor(getColor(*link_color));
3383             gdk_color_free (link_color);
3384         }
3385     }
3386 
3387     // Tab colors
3388     aStyleSet.SetActiveTabColor( aBackFieldColor ); // same as the window color.
3389     Color aSelectedBackColor = getColor( pStyle->bg[GTK_STATE_ACTIVE] );
3390     aStyleSet.SetInactiveTabColor( aSelectedBackColor );
3391 
3392     // menu disabled entries handling
3393     aStyleSet.SetSkipDisabledInMenus( sal_True );
3394     // menu colors
3395     GtkStyle* pMenuStyle = gtk_widget_get_style( gWidgetData[m_nScreen].gMenuWidget );
3396     GtkStyle* pMenuItemStyle = gtk_rc_get_style( gWidgetData[m_nScreen].gMenuItemMenuWidget );
3397     GtkStyle* pMenubarStyle = gtk_rc_get_style( gWidgetData[m_nScreen].gMenubarWidget );
3398     GtkStyle* pMenuTextStyle = gtk_rc_get_style( gtk_bin_get_child( GTK_BIN(gWidgetData[m_nScreen].gMenuItemMenuWidget) ) );
3399 
3400     aBackColor = getColor( pMenubarStyle->bg[GTK_STATE_NORMAL] );
3401     aStyleSet.SetMenuBarColor( aBackColor );
3402     aBackColor = getColor( pMenuStyle->bg[GTK_STATE_NORMAL] );
3403     aTextColor = getColor( pMenuTextStyle->fg[GTK_STATE_NORMAL] );
3404     aStyleSet.SetMenuColor( aBackColor );
3405     aStyleSet.SetMenuTextColor( aTextColor );
3406 
3407     aTextColor = getColor( pMenubarStyle->fg[GTK_STATE_NORMAL] );
3408     aStyleSet.SetMenuBarTextColor( aTextColor );
3409 
3410 #if OSL_DEBUG_LEVEL > 1
3411     std::fprintf( stderr, "==\n" );
3412     std::fprintf( stderr, "MenuColor = %x (%d)\n", (int)aStyleSet.GetMenuColor().GetColor(), aStyleSet.GetMenuColor().GetLuminance() );
3413     std::fprintf( stderr, "MenuTextColor = %x (%d)\n", (int)aStyleSet.GetMenuTextColor().GetColor(), aStyleSet.GetMenuTextColor().GetLuminance() );
3414     std::fprintf( stderr, "MenuBarColor = %x (%d)\n", (int)aStyleSet.GetMenuBarColor().GetColor(), aStyleSet.GetMenuBarColor().GetLuminance() );
3415     std::fprintf( stderr, "MenuBarTextColor = %x (%d)\n", (int)aStyleSet.GetMenuBarTextColor().GetColor(), aStyleSet.GetMenuBarTextColor().GetLuminance() );
3416     std::fprintf( stderr, "LightColor = %x (%d)\n", (int)aStyleSet.GetLightColor().GetColor(), aStyleSet.GetLightColor().GetLuminance() );
3417     std::fprintf( stderr, "ShadowColor = %x (%d)\n", (int)aStyleSet.GetShadowColor().GetColor(), aStyleSet.GetShadowColor().GetLuminance() );
3418 #endif
3419 
3420     // Awful hack for menu separators in the Sonar and similar themes.
3421     // If the menu color is not too dark, and the menu text color is lighter,
3422     // make the "light" color lighter than the menu color and the "shadow"
3423     // color darker than it.
3424     if ( aStyleSet.GetMenuColor().GetLuminance() >= 32 &&
3425 	 aStyleSet.GetMenuColor().GetLuminance() <= aStyleSet.GetMenuTextColor().GetLuminance() )
3426     {
3427       Color temp = aStyleSet.GetMenuColor();
3428       temp.IncreaseLuminance( 8 );
3429       aStyleSet.SetLightColor( temp );
3430       temp = aStyleSet.GetMenuColor();
3431       temp.DecreaseLuminance( 16 );
3432       aStyleSet.SetShadowColor( temp );
3433     }
3434 
3435     aHighlightColor = getColor( pMenuItemStyle->bg[ GTK_STATE_SELECTED ] );
3436     aHighlightTextColor = getColor( pMenuTextStyle->fg[ GTK_STATE_PRELIGHT ] );
3437     if( aHighlightColor == aHighlightTextColor )
3438         aHighlightTextColor = (aHighlightColor.GetLuminance() < 128) ? Color( COL_WHITE ) : Color( COL_BLACK );
3439     aStyleSet.SetMenuHighlightColor( aHighlightColor );
3440     aStyleSet.SetMenuHighlightTextColor( aHighlightTextColor );
3441 
3442     // UI font
3443     OString	aFamily		= pango_font_description_get_family( pStyle->font_desc );
3444     int nPangoHeight	= pango_font_description_get_size( pStyle->font_desc );
3445     PangoStyle	eStyle	= pango_font_description_get_style( pStyle->font_desc );
3446     PangoWeight	eWeight	= pango_font_description_get_weight( pStyle->font_desc );
3447     PangoStretch eStretch = pango_font_description_get_stretch( pStyle->font_desc );
3448 
3449     psp::FastPrintFontInfo aInfo;
3450     // set family name
3451     aInfo.m_aFamilyName = OStringToOUString( aFamily, RTL_TEXTENCODING_UTF8 );
3452     // set italic
3453     switch( eStyle )
3454     {
3455         case PANGO_STYLE_NORMAL:	aInfo.m_eItalic = psp::italic::Upright;break;
3456         case PANGO_STYLE_ITALIC:	aInfo.m_eItalic = psp::italic::Italic;break;
3457         case PANGO_STYLE_OBLIQUE:	aInfo.m_eItalic = psp::italic::Oblique;break;
3458     }
3459     // set weight
3460     if( eWeight <= PANGO_WEIGHT_ULTRALIGHT )
3461         aInfo.m_eWeight = psp::weight::UltraLight;
3462     else if( eWeight <= PANGO_WEIGHT_LIGHT )
3463         aInfo.m_eWeight = psp::weight::Light;
3464     else if( eWeight <= PANGO_WEIGHT_NORMAL )
3465         aInfo.m_eWeight = psp::weight::Normal;
3466     else if( eWeight <= PANGO_WEIGHT_BOLD )
3467         aInfo.m_eWeight = psp::weight::Bold;
3468     else
3469         aInfo.m_eWeight = psp::weight::UltraBold;
3470     // set width
3471     switch( eStretch )
3472     {
3473         case PANGO_STRETCH_ULTRA_CONDENSED:	aInfo.m_eWidth = psp::width::UltraCondensed;break;
3474         case PANGO_STRETCH_EXTRA_CONDENSED:	aInfo.m_eWidth = psp::width::ExtraCondensed;break;
3475         case PANGO_STRETCH_CONDENSED:		aInfo.m_eWidth = psp::width::Condensed;break;
3476         case PANGO_STRETCH_SEMI_CONDENSED:	aInfo.m_eWidth = psp::width::SemiCondensed;break;
3477         case PANGO_STRETCH_NORMAL:			aInfo.m_eWidth = psp::width::Normal;break;
3478         case PANGO_STRETCH_SEMI_EXPANDED:	aInfo.m_eWidth = psp::width::SemiExpanded;break;
3479         case PANGO_STRETCH_EXPANDED:		aInfo.m_eWidth = psp::width::Expanded;break;
3480         case PANGO_STRETCH_EXTRA_EXPANDED:	aInfo.m_eWidth = psp::width::ExtraExpanded;break;
3481         case PANGO_STRETCH_ULTRA_EXPANDED:	aInfo.m_eWidth = psp::width::UltraExpanded;break;
3482     }
3483 
3484 #if OSL_DEBUG_LEVEL > 1
3485     std::fprintf( stderr, "font name BEFORE system match: \"%s\"\n", aFamily.getStr() );
3486 #endif
3487 
3488     // match font to e.g. resolve "Sans"
3489     psp::PrintFontManager::get().matchFont( aInfo, rSettings.GetUILocale() );
3490 
3491 #if OSL_DEBUG_LEVEL > 1
3492     std::fprintf( stderr, "font match %s, name AFTER: \"%s\"\n",
3493              aInfo.m_nID != 0 ? "succeeded" : "failed",
3494              OUStringToOString( aInfo.m_aFamilyName, RTL_TEXTENCODING_ISO_8859_1 ).getStr() );
3495 #endif
3496 
3497     sal_Int32 nDispDPIY = GetDisplay()->GetResolution().B();
3498     int nPointHeight = 0;
3499     static gboolean(*pAbso)(const PangoFontDescription*) =
3500         (gboolean(*)(const PangoFontDescription*))osl_getAsciiFunctionSymbol( GetSalData()->m_pPlugin, "pango_font_description_get_size_is_absolute" );
3501 
3502     if( pAbso && pAbso( pStyle->font_desc ) )
3503         nPointHeight = (nPangoHeight * 72 + nDispDPIY*PANGO_SCALE/2) / (nDispDPIY * PANGO_SCALE);
3504     else
3505         nPointHeight = nPangoHeight/PANGO_SCALE;
3506 
3507     Font aFont( aInfo.m_aFamilyName, Size( 0, nPointHeight ) );
3508     if( aInfo.m_eWeight != psp::weight::Unknown )
3509         aFont.SetWeight( PspGraphics::ToFontWeight( aInfo.m_eWeight ) );
3510     if( aInfo.m_eWidth != psp::width::Unknown )
3511         aFont.SetWidthType( PspGraphics::ToFontWidth( aInfo.m_eWidth ) );
3512     if( aInfo.m_eItalic != psp::italic::Unknown )
3513         aFont.SetItalic( PspGraphics::ToFontItalic( aInfo.m_eItalic ) );
3514     if( aInfo.m_ePitch != psp::pitch::Unknown )
3515         aFont.SetPitch( PspGraphics::ToFontPitch( aInfo.m_ePitch ) );
3516 
3517     aStyleSet.SetAppFont( aFont );
3518     aStyleSet.SetHelpFont( aFont );
3519     aStyleSet.SetTitleFont( aFont );
3520     aStyleSet.SetFloatTitleFont( aFont );
3521     aStyleSet.SetMenuFont( aFont );
3522     aStyleSet.SetToolFont( aFont );
3523     aStyleSet.SetLabelFont( aFont );
3524     aStyleSet.SetInfoFont( aFont );
3525     aStyleSet.SetRadioCheckFont( aFont );
3526     aStyleSet.SetPushButtonFont( aFont );
3527     aStyleSet.SetFieldFont( aFont );
3528     aStyleSet.SetIconFont( aFont );
3529     aStyleSet.SetGroupFont( aFont );
3530 
3531     // get cursor blink time
3532     GtkSettings *pSettings = gtk_widget_get_settings( gWidgetData[m_nScreen].gEditBoxWidget );
3533     gboolean blink = false;
3534 
3535     g_object_get( pSettings, "gtk-cursor-blink", &blink, (char *)NULL );
3536     if( blink )
3537     {
3538         gint blink_time = STYLE_CURSOR_NOBLINKTIME;
3539         g_object_get( pSettings, "gtk-cursor-blink-time", &blink_time, (char *)NULL );
3540         // set the blink_time if there is a setting and it is reasonable
3541         // else leave the default value
3542         if( blink_time > 100 && blink_time != gint(STYLE_CURSOR_NOBLINKTIME) )
3543             aStyleSet.SetCursorBlinkTime( blink_time/2 );
3544     }
3545     else
3546         aStyleSet.SetCursorBlinkTime( STYLE_CURSOR_NOBLINKTIME );
3547 
3548     gboolean showmenuicons = true;
3549     pSettings = gtk_widget_get_settings( gWidgetData[m_nScreen].gImageMenuItem );
3550     g_object_get( pSettings, "gtk-menu-images", &showmenuicons, (char *)NULL );
3551     aStyleSet.SetUseImagesInMenus( showmenuicons );
3552 
3553     // set scrollbar settings
3554     gint slider_width = 14;
3555     gint trough_border = 1;
3556     gint min_slider_length = 21;
3557 
3558     // Grab some button style attributes
3559     gtk_widget_style_get( gWidgetData[m_nScreen].gScrollHorizWidget,
3560                           "slider-width", &slider_width,
3561                           "trough-border", &trough_border,
3562                           "min-slider-length", &min_slider_length,
3563                           (char *)NULL );
3564     gint magic = trough_border ? 1 : 0;
3565     aStyleSet.SetScrollBarSize( slider_width + 2*trough_border );
3566     aStyleSet.SetMinThumbSize( min_slider_length - magic );
3567 
3568     // preferred icon style
3569     gchar* pIconThemeName = NULL;
3570     g_object_get( gtk_settings_get_default(), "gtk-icon-theme-name", &pIconThemeName, (char *)NULL );
3571     aStyleSet.SetPreferredSymbolsStyleName( OUString::createFromAscii( pIconThemeName ) );
3572     g_free( pIconThemeName );
3573 
3574     //  FIXME: need some way of fetching toolbar icon size.
3575 //	aStyleSet.SetToolbarIconSize( STYLE_TOOLBAR_ICONSIZE_SMALL );
3576 
3577     const cairo_font_options_t* pNewOptions = NULL;
3578     if( GdkScreen* pScreen = gdk_display_get_screen( gdk_display_get_default(), m_nScreen ) )
3579     {
3580 //#if !GTK_CHECK_VERSION(2,8,1)
3581 #if !GTK_CHECK_VERSION(2,9,0)
3582 	static cairo_font_options_t* (*gdk_screen_get_font_options)(GdkScreen*) =
3583 		(cairo_font_options_t*(*)(GdkScreen*))osl_getAsciiFunctionSymbol( GetSalData()->m_pPlugin, "gdk_screen_get_font_options" );
3584     if( gdk_screen_get_font_options != NULL )
3585 #endif
3586 		pNewOptions = gdk_screen_get_font_options( pScreen );
3587     }
3588     aStyleSet.SetCairoFontOptions( pNewOptions );
3589 
3590     // finally update the collected settings
3591     rSettings.SetStyleSettings( aStyleSet );
3592 
3593     #if OSL_DEBUG_LEVEL > 1
3594     {
3595         GtkSettings* pGtkSettings = gtk_settings_get_default();
3596         GValue aValue;
3597         memset( &aValue, 0, sizeof(GValue) );
3598         g_value_init( &aValue, G_TYPE_STRING );
3599         g_object_get_property( G_OBJECT(pGtkSettings), "gtk-theme-name", &aValue );
3600         const gchar* pThemeName = g_value_get_string( &aValue );
3601         std::fprintf( stderr, "Theme name is \"%s\"\n", pThemeName );
3602         g_value_unset( &aValue );
3603     }
3604     #endif
3605     GtkSettings* pGtkSettings = gtk_settings_get_default();
3606     GValue aValue;
3607     memset( &aValue, 0, sizeof(GValue) );
3608     g_value_init( &aValue, G_TYPE_STRING );
3609     g_object_get_property( G_OBJECT(pGtkSettings), "gtk-theme-name", &aValue );
3610     const gchar* pThemeName = g_value_get_string( &aValue );
3611 
3612     // default behaviour
3613     bNeedPixmapPaint = bGlobalNeedPixmapPaint;
3614     bToolbarGripWorkaround = false;
3615     bNeedButtonStyleAsEditBackgroundWorkaround = false;
3616 
3617     // setup some workarounds for "blueprint" theme
3618     if( pThemeName && strncasecmp( pThemeName, "blueprint", 9 ) == 0 )
3619     {
3620         bNeedButtonStyleAsEditBackgroundWorkaround = true;
3621         if( GetX11SalData()->GetDisplay()->GetServerVendor() == vendor_sun )
3622         {
3623             // #i52570#, #i61532# workaround a weird paint issue;
3624             // on a Sunray Xserver sometimes painting buttons and edits
3625             // won't work when using the blueprint theme
3626             // not reproducible with simpler programs or other themes
3627             if( pThemeName && strncasecmp( pThemeName, "blueprint", 9 ) == 0 )
3628             {
3629                 bNeedPixmapPaint = true;
3630                 bToolbarGripWorkaround = true;
3631             }
3632         }
3633     }
3634     // clean up
3635     g_value_unset( &aValue );
3636 }
3637 
3638 
3639 /************************************************************************
3640  * Create a GdkPixmap filled with the contents of an area of an Xlib window
3641  ************************************************************************/
3642 
3643 GdkPixmap* GtkSalGraphics::NWGetPixmapFromScreen( Rectangle srcRect )
3644 {
3645     // Create a new pixmap to hold the composite of the window background and the control
3646     GdkPixmap * pPixmap		= gdk_pixmap_new( GDK_DRAWABLE(GetGdkWindow()), srcRect.GetWidth(), srcRect.GetHeight(), -1 );
3647 	GdkGC *	 pPixmapGC	= gdk_gc_new( pPixmap );
3648 
3649     if( !pPixmap || !pPixmapGC )
3650     {
3651         if ( pPixmap )
3652             g_object_unref( pPixmap );
3653         if ( pPixmapGC )
3654             g_object_unref( pPixmapGC );
3655         std::fprintf( stderr, "salnativewidgets-gtk.cxx: could not get valid pixmap from screen\n" );
3656         return( NULL );
3657     }
3658 
3659     // Copy the background of the screen into a composite pixmap
3660     CopyScreenArea( GetXDisplay(),
3661               GetDrawable(), GetScreenNumber(), GetVisual().GetDepth(),
3662               gdk_x11_drawable_get_xid(pPixmap),
3663               gdk_screen_get_number( gdk_drawable_get_screen( GDK_DRAWABLE(pPixmap) ) ),
3664               gdk_drawable_get_depth( GDK_DRAWABLE( pPixmap ) ),
3665               gdk_x11_gc_get_xgc(pPixmapGC),
3666               srcRect.Left(), srcRect.Top(), srcRect.GetWidth(), srcRect.GetHeight(), 0, 0 );
3667 
3668     g_object_unref( pPixmapGC );
3669     return( pPixmap );
3670 }
3671 
3672 
3673 
3674 
3675 /************************************************************************
3676  * Copy an alpha pixmap to screen using a gc with clipping
3677  ************************************************************************/
3678 
3679 sal_Bool GtkSalGraphics::NWRenderPixmapToScreen( GdkPixmap* pPixmap, Rectangle dstRect )
3680 {
3681     // The GC can't be null, otherwise we'd have no clip region
3682     GC aFontGC = GetFontGC();
3683     if( aFontGC == NULL )
3684     {
3685         std::fprintf(stderr, "salnativewidgets.cxx: no valid GC\n" );
3686         return( sal_False );
3687     }
3688 
3689     if ( !pPixmap )
3690         return( sal_False );
3691 
3692     // Copy the background of the screen into a composite pixmap
3693     CopyScreenArea( GetXDisplay(),
3694               GDK_DRAWABLE_XID(pPixmap),
3695               gdk_screen_get_number( gdk_drawable_get_screen( GDK_DRAWABLE(pPixmap) ) ),
3696               gdk_drawable_get_depth( GDK_DRAWABLE(pPixmap) ),
3697               GetDrawable(), m_nScreen, GetVisual().GetDepth(),
3698               aFontGC,
3699               0, 0, dstRect.GetWidth(), dstRect.GetHeight(), dstRect.Left(), dstRect.Top() );
3700 
3701     return( sal_True );
3702 }
3703 
3704 
3705 /************************************************************************
3706  * State conversion
3707  ************************************************************************/
3708 static void NWConvertVCLStateToGTKState( ControlState nVCLState,
3709 			GtkStateType* nGTKState, GtkShadowType* nGTKShadow )
3710 {
3711 	*nGTKShadow = GTK_SHADOW_OUT;
3712 	*nGTKState = GTK_STATE_INSENSITIVE;
3713 
3714 	if ( nVCLState & CTRL_STATE_ENABLED )
3715 	{
3716 		if ( nVCLState & CTRL_STATE_PRESSED )
3717 		{
3718 			*nGTKState = GTK_STATE_ACTIVE;
3719 			*nGTKShadow = GTK_SHADOW_IN;
3720 		}
3721 		else if ( nVCLState & CTRL_STATE_ROLLOVER )
3722 		{
3723 			*nGTKState = GTK_STATE_PRELIGHT;
3724 			*nGTKShadow = GTK_SHADOW_OUT;
3725 		}
3726 		else
3727 		{
3728 			*nGTKState = GTK_STATE_NORMAL;
3729 			*nGTKShadow = GTK_SHADOW_OUT;
3730 		}
3731 	}
3732 }
3733 
3734 /************************************************************************
3735  * Set widget flags
3736  ************************************************************************/
3737 static void NWSetWidgetState( GtkWidget* widget, ControlState nState, GtkStateType nGtkState )
3738 {
3739 	// Set to default state, then build up from there
3740 	GTK_WIDGET_UNSET_FLAGS( widget, GTK_HAS_DEFAULT );
3741 	GTK_WIDGET_UNSET_FLAGS( widget, GTK_HAS_FOCUS );
3742 	GTK_WIDGET_UNSET_FLAGS( widget, GTK_SENSITIVE );
3743 	GTK_WIDGET_SET_FLAGS( widget, gWidgetDefaultFlags[(long)widget] );
3744 
3745 	if ( nState & CTRL_STATE_DEFAULT )
3746 		GTK_WIDGET_SET_FLAGS( widget, GTK_HAS_DEFAULT );
3747 	if ( !GTK_IS_TOGGLE_BUTTON(widget) && (nState & CTRL_STATE_FOCUSED) )
3748 		GTK_WIDGET_SET_FLAGS( widget, GTK_HAS_FOCUS );
3749 	if ( nState & CTRL_STATE_ENABLED )
3750 		GTK_WIDGET_SET_FLAGS( widget, GTK_SENSITIVE );
3751 	gtk_widget_set_state( widget, nGtkState );
3752 }
3753 
3754 /************************************************************************
3755  * Widget ensure functions - make sure cached objects are valid
3756  ************************************************************************/
3757 
3758 //-------------------------------------
3759 
3760 static void NWAddWidgetToCacheWindow( GtkWidget* widget, int nScreen )
3761 {
3762     NWFWidgetData& rData = gWidgetData[nScreen];
3763 	if ( !rData.gCacheWindow || !rData.gDumbContainer )
3764 	{
3765 		if ( !rData.gCacheWindow )
3766         {
3767 			rData.gCacheWindow = gtk_window_new( GTK_WINDOW_TOPLEVEL );
3768             GdkScreen* pScreen = gdk_display_get_screen( gdk_display_get_default(), nScreen );
3769             if( pScreen )
3770                 gtk_window_set_screen( GTK_WINDOW(rData.gCacheWindow), pScreen );
3771         }
3772 		if ( !rData.gDumbContainer )
3773 			rData.gDumbContainer = gtk_fixed_new();
3774 		gtk_container_add( GTK_CONTAINER(rData.gCacheWindow), rData.gDumbContainer );
3775 		gtk_widget_realize( rData.gDumbContainer );
3776 		gtk_widget_realize( rData.gCacheWindow );
3777 	}
3778 
3779 	gtk_container_add( GTK_CONTAINER(rData.gDumbContainer), widget );
3780 	gtk_widget_realize( widget );
3781 	gtk_widget_ensure_style( widget );
3782 
3783 	// Store widget's default flags
3784 	gWidgetDefaultFlags[ (long)widget ] = GTK_WIDGET_FLAGS( widget );
3785 }
3786 
3787 //-------------------------------------
3788 
3789 static void NWEnsureGTKButton( int nScreen )
3790 {
3791 	if ( !gWidgetData[nScreen].gBtnWidget )
3792 	{
3793 		gWidgetData[nScreen].gBtnWidget = gtk_button_new_with_label( "" );
3794 		NWAddWidgetToCacheWindow( gWidgetData[nScreen].gBtnWidget, nScreen );
3795 	}
3796 }
3797 
3798 //-------------------------------------
3799 
3800 static void NWEnsureGTKRadio( int nScreen )
3801 {
3802 	if ( !gWidgetData[nScreen].gRadioWidget || !gWidgetData[nScreen].gRadioWidgetSibling )
3803 	{
3804 		gWidgetData[nScreen].gRadioWidget = gtk_radio_button_new( NULL );
3805 		gWidgetData[nScreen].gRadioWidgetSibling = gtk_radio_button_new_from_widget( GTK_RADIO_BUTTON(gWidgetData[nScreen].gRadioWidget) );
3806 		NWAddWidgetToCacheWindow( gWidgetData[nScreen].gRadioWidget, nScreen );
3807 		NWAddWidgetToCacheWindow( gWidgetData[nScreen].gRadioWidgetSibling, nScreen );
3808 	}
3809 }
3810 
3811 //-------------------------------------
3812 
3813 static void NWEnsureGTKCheck( int nScreen )
3814 {
3815 	if ( !gWidgetData[nScreen].gCheckWidget )
3816 	{
3817 		gWidgetData[nScreen].gCheckWidget = gtk_check_button_new();
3818 		NWAddWidgetToCacheWindow( gWidgetData[nScreen].gCheckWidget, nScreen );
3819 	}
3820 }
3821 
3822 //-------------------------------------
3823 
3824 static void NWEnsureGTKScrollbars( int nScreen )
3825 {
3826 	if ( !gWidgetData[nScreen].gScrollHorizWidget )
3827 	{
3828 		gWidgetData[nScreen].gScrollHorizWidget = gtk_hscrollbar_new( NULL );
3829 		NWAddWidgetToCacheWindow( gWidgetData[nScreen].gScrollHorizWidget, nScreen );
3830 	}
3831 
3832 	if ( !gWidgetData[nScreen].gScrollVertWidget )
3833 	{
3834 		gWidgetData[nScreen].gScrollVertWidget = gtk_vscrollbar_new( NULL );
3835 		NWAddWidgetToCacheWindow( gWidgetData[nScreen].gScrollVertWidget, nScreen );
3836 	}
3837 }
3838 
3839 //-------------------------------------
3840 
3841 static void NWEnsureGTKArrow( int nScreen )
3842 {
3843 	if ( !gWidgetData[nScreen].gArrowWidget || !gWidgetData[nScreen].gDropdownWidget )
3844 	{
3845 		gWidgetData[nScreen].gDropdownWidget = gtk_toggle_button_new();
3846 		NWAddWidgetToCacheWindow( gWidgetData[nScreen].gDropdownWidget, nScreen );
3847 		gWidgetData[nScreen].gArrowWidget = gtk_arrow_new( GTK_ARROW_DOWN, GTK_SHADOW_OUT );
3848 		gtk_container_add( GTK_CONTAINER(gWidgetData[nScreen].gDropdownWidget), gWidgetData[nScreen].gArrowWidget );
3849 		gtk_widget_set_rc_style( gWidgetData[nScreen].gArrowWidget );
3850 		gtk_widget_realize( gWidgetData[nScreen].gArrowWidget );
3851 	}
3852 }
3853 
3854 //-------------------------------------
3855 
3856 static void NWEnsureGTKEditBox( int nScreen )
3857 {
3858 	if ( !gWidgetData[nScreen].gEditBoxWidget )
3859 	{
3860 		gWidgetData[nScreen].gEditBoxWidget = gtk_entry_new();
3861 		NWAddWidgetToCacheWindow( gWidgetData[nScreen].gEditBoxWidget, nScreen );
3862 	}
3863 }
3864 
3865 //-------------------------------------
3866 
3867 static void NWEnsureGTKSpinButton( int nScreen )
3868 {
3869 	if ( !gWidgetData[nScreen].gSpinButtonWidget )
3870 	{
3871 		GtkAdjustment *adj = GTK_ADJUSTMENT( gtk_adjustment_new(0, 0, 1, 1, 1, 0) );
3872 		gWidgetData[nScreen].gSpinButtonWidget = gtk_spin_button_new( adj, 1, 2 );
3873 
3874 		//Setting non-editable means it doesn't blink, so there's no timeouts
3875 		//running around to nobble us
3876 		gtk_editable_set_editable(GTK_EDITABLE(gWidgetData[nScreen].gSpinButtonWidget), false);
3877 
3878 		NWAddWidgetToCacheWindow( gWidgetData[nScreen].gSpinButtonWidget, nScreen );
3879 	}
3880 }
3881 
3882 //-------------------------------------
3883 
3884 static void NWEnsureGTKNotebook( int nScreen )
3885 {
3886 	if ( !gWidgetData[nScreen].gNotebookWidget )
3887 	{
3888 		gWidgetData[nScreen].gNotebookWidget = gtk_notebook_new();
3889 		NWAddWidgetToCacheWindow( gWidgetData[nScreen].gNotebookWidget, nScreen );
3890 	}
3891 }
3892 
3893 //-------------------------------------
3894 
3895 static void NWEnsureGTKOptionMenu( int nScreen )
3896 {
3897 	if ( !gWidgetData[nScreen].gOptionMenuWidget )
3898 	{
3899 		gWidgetData[nScreen].gOptionMenuWidget = gtk_option_menu_new();
3900 		NWAddWidgetToCacheWindow( gWidgetData[nScreen].gOptionMenuWidget, nScreen );
3901 	}
3902 }
3903 
3904 //-------------------------------------
3905 
3906 static void NWEnsureGTKCombo( int nScreen )
3907 {
3908 	if ( !gWidgetData[nScreen].gComboWidget )
3909 	{
3910 		gWidgetData[nScreen].gComboWidget = gtk_combo_new();
3911 
3912 		// #i59129# Setting non-editable means it doesn't blink, so
3913         // there are no timeouts running around to nobble us
3914 		gtk_editable_set_editable(GTK_EDITABLE(GTK_COMBO(gWidgetData[nScreen].gComboWidget)->entry), false);
3915 
3916 		NWAddWidgetToCacheWindow( gWidgetData[nScreen].gComboWidget, nScreen );
3917 		// Must realize the ComboBox's children, since GTK
3918 		// does not do this for us in GtkCombo::gtk_widget_realize()
3919 		gtk_widget_realize( GTK_COMBO(gWidgetData[nScreen].gComboWidget)->button );
3920 		gtk_widget_realize( GTK_COMBO(gWidgetData[nScreen].gComboWidget)->entry );
3921 	}
3922 }
3923 
3924 //-------------------------------------
3925 
3926 static void NWEnsureGTKScrolledWindow( int nScreen )
3927 {
3928 	if ( !gWidgetData[nScreen].gScrolledWindowWidget )
3929 	{
3930 		GtkAdjustment *hadj = GTK_ADJUSTMENT( gtk_adjustment_new(0, 0, 0, 0, 0, 0) );
3931 		GtkAdjustment *vadj = GTK_ADJUSTMENT( gtk_adjustment_new(0, 0, 0, 0, 0, 0) );
3932 
3933 		gWidgetData[nScreen].gScrolledWindowWidget = gtk_scrolled_window_new( hadj, vadj );
3934 		NWAddWidgetToCacheWindow( gWidgetData[nScreen].gScrolledWindowWidget, nScreen );
3935 	}
3936 }
3937 
3938 //-------------------------------------
3939 
3940 static void NWEnsureGTKToolbar( int nScreen )
3941 {
3942     if( !gWidgetData[nScreen].gToolbarWidget )
3943     {
3944         gWidgetData[nScreen].gToolbarWidget = gtk_toolbar_new();
3945         NWAddWidgetToCacheWindow( gWidgetData[nScreen].gToolbarWidget, nScreen );
3946         gWidgetData[nScreen].gToolbarButtonWidget = gtk_button_new();
3947         gWidgetData[nScreen].gToolbarToggleWidget = gtk_toggle_button_new();
3948 
3949         GtkReliefStyle aRelief = GTK_RELIEF_NORMAL;
3950         gtk_widget_ensure_style( gWidgetData[nScreen].gToolbarWidget );
3951         gtk_widget_style_get( gWidgetData[nScreen].gToolbarWidget,
3952 			                  "button_relief", &aRelief,
3953                               (char *)NULL);
3954 
3955         gtk_button_set_relief( GTK_BUTTON(gWidgetData[nScreen].gToolbarButtonWidget), aRelief );
3956         GTK_WIDGET_UNSET_FLAGS( gWidgetData[nScreen].gToolbarButtonWidget, GTK_CAN_FOCUS );
3957         GTK_WIDGET_UNSET_FLAGS( gWidgetData[nScreen].gToolbarButtonWidget, GTK_CAN_DEFAULT );
3958         NWAddWidgetToCacheWindow( gWidgetData[nScreen].gToolbarButtonWidget, nScreen );
3959 
3960         gtk_button_set_relief( GTK_BUTTON(gWidgetData[nScreen].gToolbarToggleWidget), aRelief );
3961         GTK_WIDGET_UNSET_FLAGS( gWidgetData[nScreen].gToolbarToggleWidget, GTK_CAN_FOCUS );
3962         GTK_WIDGET_UNSET_FLAGS( gWidgetData[nScreen].gToolbarToggleWidget, GTK_CAN_DEFAULT );
3963         NWAddWidgetToCacheWindow( gWidgetData[nScreen].gToolbarToggleWidget, nScreen );
3964     }
3965     if( ! gWidgetData[nScreen].gHandleBoxWidget )
3966     {
3967         gWidgetData[nScreen].gHandleBoxWidget = gtk_handle_box_new();
3968         NWAddWidgetToCacheWindow( gWidgetData[nScreen].gHandleBoxWidget, nScreen );
3969     }
3970 }
3971 
3972 //-------------------------------------
3973 
3974 static void NWEnsureGTKMenubar( int nScreen )
3975 {
3976     if( !gWidgetData[nScreen].gMenubarWidget )
3977     {
3978         gWidgetData[nScreen].gMenubarWidget = gtk_menu_bar_new();
3979         gWidgetData[nScreen].gMenuItemMenubarWidget = gtk_menu_item_new_with_label( "b" );
3980         gtk_menu_shell_append( GTK_MENU_SHELL( gWidgetData[nScreen].gMenubarWidget ), gWidgetData[nScreen].gMenuItemMenubarWidget );
3981         gtk_widget_show( gWidgetData[nScreen].gMenuItemMenubarWidget );
3982         NWAddWidgetToCacheWindow( gWidgetData[nScreen].gMenubarWidget, nScreen );
3983         gtk_widget_show( gWidgetData[nScreen].gMenubarWidget );
3984 
3985         // do what NWAddWidgetToCacheWindow does except adding to def container
3986         gtk_widget_realize( gWidgetData[nScreen].gMenuItemMenubarWidget );
3987         gtk_widget_ensure_style( gWidgetData[nScreen].gMenuItemMenubarWidget );
3988 
3989         gWidgetDefaultFlags[ (long)gWidgetData[nScreen].gMenuItemMenubarWidget ] = GTK_WIDGET_FLAGS( gWidgetData[nScreen].gMenuItemMenubarWidget );
3990     }
3991 }
3992 
3993 static void NWEnsureGTKMenu( int nScreen )
3994 {
3995     if( !gWidgetData[nScreen].gMenuWidget )
3996     {
3997         gWidgetData[nScreen].gMenuWidget              = gtk_menu_new();
3998         gWidgetData[nScreen].gMenuItemMenuWidget      = gtk_menu_item_new_with_label( "b" );
3999         gWidgetData[nScreen].gMenuItemCheckMenuWidget = gtk_check_menu_item_new_with_label( "b" );
4000         gWidgetData[nScreen].gMenuItemRadioMenuWidget = gtk_radio_menu_item_new_with_label( NULL, "b" );
4001         gWidgetData[nScreen].gImageMenuItem           = gtk_image_menu_item_new();
4002 
4003         gtk_menu_shell_append( GTK_MENU_SHELL( gWidgetData[nScreen].gMenuWidget ), gWidgetData[nScreen].gMenuItemMenuWidget );
4004         gtk_menu_shell_append( GTK_MENU_SHELL( gWidgetData[nScreen].gMenuWidget ), gWidgetData[nScreen].gMenuItemCheckMenuWidget );
4005         gtk_menu_shell_append( GTK_MENU_SHELL( gWidgetData[nScreen].gMenuWidget ), gWidgetData[nScreen].gMenuItemRadioMenuWidget );
4006         gtk_menu_shell_append( GTK_MENU_SHELL( gWidgetData[nScreen].gMenuWidget ), gWidgetData[nScreen].gImageMenuItem );
4007 
4008         // do what NWAddWidgetToCacheWindow does except adding to def container
4009         gtk_widget_realize( gWidgetData[nScreen].gMenuWidget );
4010         gtk_widget_ensure_style( gWidgetData[nScreen].gMenuWidget );
4011 
4012         gtk_widget_realize( gWidgetData[nScreen].gMenuItemMenuWidget );
4013         gtk_widget_ensure_style( gWidgetData[nScreen].gMenuItemMenuWidget );
4014 
4015         gtk_widget_realize( gWidgetData[nScreen].gMenuItemCheckMenuWidget );
4016         gtk_widget_ensure_style( gWidgetData[nScreen].gMenuItemCheckMenuWidget );
4017 
4018         gtk_widget_realize( gWidgetData[nScreen].gMenuItemRadioMenuWidget );
4019         gtk_widget_ensure_style( gWidgetData[nScreen].gMenuItemRadioMenuWidget );
4020 
4021         gtk_widget_realize( gWidgetData[nScreen].gImageMenuItem );
4022         gtk_widget_ensure_style( gWidgetData[nScreen].gImageMenuItem );
4023 
4024         gWidgetDefaultFlags[ (long)gWidgetData[nScreen].gMenuWidget ] = GTK_WIDGET_FLAGS( gWidgetData[nScreen].gMenuWidget );
4025         gWidgetDefaultFlags[ (long)gWidgetData[nScreen].gMenuItemMenuWidget ] = GTK_WIDGET_FLAGS( gWidgetData[nScreen].gMenuItemMenuWidget );
4026         gWidgetDefaultFlags[ (long)gWidgetData[nScreen].gMenuItemCheckMenuWidget ] = GTK_WIDGET_FLAGS( gWidgetData[nScreen].gMenuItemCheckMenuWidget );
4027         gWidgetDefaultFlags[ (long)gWidgetData[nScreen].gMenuItemRadioMenuWidget ] = GTK_WIDGET_FLAGS( gWidgetData[nScreen].gMenuItemRadioMenuWidget );
4028         gWidgetDefaultFlags[ (long)gWidgetData[nScreen].gImageMenuItem ] = GTK_WIDGET_FLAGS( gWidgetData[nScreen].gImageMenuItem );
4029     }
4030 }
4031 
4032 static void NWEnsureGTKTooltip( int nScreen )
4033 {
4034     if( !gWidgetData[nScreen].gTooltipPopup )
4035     {
4036         gWidgetData[nScreen].gTooltipPopup = gtk_window_new (GTK_WINDOW_POPUP);
4037         GdkScreen* pScreen = gdk_display_get_screen( gdk_display_get_default(), nScreen );
4038         if( pScreen )
4039             gtk_window_set_screen( GTK_WINDOW(gWidgetData[nScreen].gTooltipPopup), pScreen );
4040         gtk_widget_set_name( gWidgetData[nScreen].gTooltipPopup, "gtk-tooltips");
4041         gtk_widget_realize( gWidgetData[nScreen].gTooltipPopup );
4042         gtk_widget_ensure_style( gWidgetData[nScreen].gTooltipPopup );
4043     }
4044 }
4045 
4046 static void NWEnsureGTKProgressBar( int nScreen )
4047 {
4048     if( !gWidgetData[nScreen].gProgressBar )
4049     {
4050         gWidgetData[nScreen].gProgressBar = gtk_progress_bar_new ();
4051 		NWAddWidgetToCacheWindow( gWidgetData[nScreen].gProgressBar, nScreen );
4052     }
4053 }
4054 
4055 static void NWEnsureGTKTreeView( int nScreen )
4056 {
4057     if( !gWidgetData[nScreen].gTreeView )
4058     {
4059         gWidgetData[nScreen].gTreeView = gtk_tree_view_new ();
4060 		NWAddWidgetToCacheWindow( gWidgetData[nScreen].gTreeView, nScreen );
4061     }
4062 }
4063 
4064 static void NWEnsureGTKSlider( int nScreen )
4065 {
4066     if( !gWidgetData[nScreen].gHScale )
4067     {
4068         gWidgetData[nScreen].gHScale = gtk_hscale_new_with_range(0, 10, 1);
4069 		NWAddWidgetToCacheWindow( gWidgetData[nScreen].gHScale, nScreen );
4070     }
4071     if( !gWidgetData[nScreen].gVScale )
4072     {
4073         gWidgetData[nScreen].gVScale = gtk_vscale_new_with_range(0, 10, 1);
4074 		NWAddWidgetToCacheWindow( gWidgetData[nScreen].gVScale, nScreen );
4075     }
4076 }
4077