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_fpicker.hxx"
26 
27 //------------------------------------------------------------------------
28 // includes
29 //------------------------------------------------------------------------
30 #include <com/sun/star/lang/DisposedException.hpp>
31 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
32 #include <com/sun/star/ui/dialogs/ExecutableDialogResults.hpp>
33 #include <com/sun/star/ui/dialogs/ExtendedFilePickerElementIds.hpp>
34 #include <com/sun/star/ui/dialogs/CommonFilePickerElementIds.hpp>
35 #include <com/sun/star/ui/dialogs/ExtendedFilePickerElementIds.hpp>
36 #include <cppuhelper/interfacecontainer.h>
37 #include <osl/diagnose.h>
38 #include <osl/process.h>
39 #include <com/sun/star/ui/dialogs/TemplateDescription.hpp>
40 #include <com/sun/star/ui/dialogs/ControlActions.hpp>
41 #include <com/sun/star/uno/Any.hxx>
42 #include <FPServiceInfo.hxx>
43 #include <vos/mutex.hxx>
44 #include <vcl/svapp.hxx>
45 #include <SalGtkFilePicker.hxx>
46 
47 #include <tools/urlobj.hxx>
48 
49 #include <iostream>
50 #include <algorithm>
51 #include <set>
52 #include "resourceprovider.hxx"
53 #ifndef _SV_RC_H
54 #include <tools/rc.hxx>
55 #endif
56 
57 //------------------------------------------------------------------------
58 // namespace directives
59 //------------------------------------------------------------------------
60 
61 using namespace ::com::sun::star;
62 using namespace ::com::sun::star::ui::dialogs;
63 using namespace ::com::sun::star::ui::dialogs::TemplateDescription;
64 using namespace ::com::sun::star::ui::dialogs::ExtendedFilePickerElementIds;
65 using namespace ::com::sun::star::ui::dialogs::CommonFilePickerElementIds;
66 using namespace ::com::sun::star::lang;
67 using namespace ::com::sun::star::beans;
68 using namespace ::com::sun::star::uno;
69 
70 //------------------------------------------------------------------------
71 // helper functions
72 //------------------------------------------------------------------------
73 
74 namespace
75 {
76 	// controlling event notifications
77 	const bool STARTUP_SUSPENDED = true;
78 	const bool STARTUP_ALIVE     = false;
79 
80 	uno::Sequence<rtl::OUString> SAL_CALL FilePicker_getSupportedServiceNames()
81 	{
82 		uno::Sequence<rtl::OUString> aRet(3);
83 	        aRet[0] = rtl::OUString::createFromAscii( "com.sun.star.ui.dialogs.FilePicker" );
84 		aRet[1] = rtl::OUString::createFromAscii( "com.sun.star.ui.dialogs.SystemFilePicker" );
85 		aRet[2] = rtl::OUString::createFromAscii( "com.sun.star.ui.dialogs.GtkFilePicker" );
86 		return aRet;
87 	}
88 }
89 
90 //-----------------------------------------------------------------------------------------
91 // constructor
92 //-----------------------------------------------------------------------------------------
93 
94 static void expandexpanders(GtkContainer *pWidget)
95 {
96     GdkThreadLock aLock;
97 
98     GList *pChildren = gtk_container_get_children(pWidget);
99     for( GList *p = pChildren; p; p = p->next )
100     {
101         if GTK_IS_CONTAINER(GTK_WIDGET(p->data))
102             expandexpanders(GTK_CONTAINER(GTK_WIDGET(p->data)));
103         if GTK_IS_EXPANDER(GTK_WIDGET(p->data))
104             gtk_expander_set_expanded(GTK_EXPANDER(GTK_WIDGET(p->data)), sal_True);
105     }
106     g_list_free(pChildren);
107 }
108 
109 void SalGtkFilePicker::dialog_mapped_cb(GtkWidget *, SalGtkFilePicker *pobjFP)
110 {
111     pobjFP->InitialMapping();
112 }
113 
114 void SalGtkFilePicker::InitialMapping()
115 {
116     GdkThreadLock aLock;
117 
118     if (!mbPreviewState )
119     {
120         gtk_widget_hide( m_pPreview );
121         gtk_file_chooser_set_preview_widget_active( GTK_FILE_CHOOSER( m_pDialog ), false);
122     }
123     gtk_widget_set_size_request (m_pPreview, -1, -1);
124 }
125 
126 SalGtkFilePicker::SalGtkFilePicker( const uno::Reference<lang::XMultiServiceFactory>& xServiceMgr ) :
127 	SalGtkPicker(xServiceMgr),
128 	cppu::WeakComponentImplHelper10<
129 		XFilterManager,
130 	        XFilterGroupManager,
131 	        XFilePickerControlAccess,
132 		XFilePickerNotifier,
133 	        XFilePreview,
134 	        XFilePicker2,
135 		lang::XInitialization,
136 		util::XCancellable,
137 		lang::XEventListener,
138 		lang::XServiceInfo>( m_rbHelperMtx ),
139 	m_xServiceMgr( xServiceMgr ),
140     m_pFilterList( NULL ),
141     m_pVBox ( NULL ),
142     mnHID_FolderChange( 0 ),
143     mnHID_SelectionChange( 0 ),
144     bVersionWidthUnset( false ),
145     mbPreviewState( sal_False ),
146     mHID_Preview( 0 ),
147 	m_pPreview( NULL ),
148     m_pPseudoFilter( NULL ),
149 	m_PreviewImageWidth( 256 ),
150     m_PreviewImageHeight( 256 )
151 {
152 	int i;
153 
154 	for( i = 0; i < TOGGLE_LAST; i++ )
155 	{
156 		m_pToggles[i] = NULL;
157 		mbToggleVisibility[i] = false;
158 	}
159 
160 	for( i = 0; i < BUTTON_LAST; i++ )
161     {
162 		m_pButtons[i] = NULL;
163 		mbButtonVisibility[i] = false;
164     }
165 
166 	for( i = 0; i < LIST_LAST; i++ )
167     {
168         m_pHBoxs[i] = NULL;
169         m_pAligns[i] = NULL;
170 		m_pLists[i] = NULL;
171 		m_pListLabels[i] = NULL;
172 		mbListVisibility[i] = false;
173     }
174 
175 	CResourceProvider aResProvider;
176 	OUString aFilePickerTitle = aResProvider.getResString( FILE_PICKER_TITLE_OPEN );
177 
178     GdkThreadLock aLock;
179 
180     m_pDialog = gtk_file_chooser_dialog_new(
181             OUStringToOString( aFilePickerTitle, RTL_TEXTENCODING_UTF8 ).getStr(),
182             NULL,
183 			GTK_FILE_CHOOSER_ACTION_OPEN,
184 			GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
185 			GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
186 			(char *)NULL );
187 
188 	gtk_dialog_set_default_response( GTK_DIALOG (m_pDialog), GTK_RESPONSE_ACCEPT );
189 
190 	gtk_file_chooser_set_local_only( GTK_FILE_CHOOSER( m_pDialog ), sal_False );
191 	gtk_file_chooser_set_select_multiple( GTK_FILE_CHOOSER( m_pDialog ), sal_False );
192 
193 	m_pVBox = gtk_vbox_new( sal_False, 0 );
194 
195     // We don't want clickable items to have a huge hit-area
196     GtkWidget *pHBox = gtk_hbox_new( sal_False, 0 );
197     GtkWidget *pThinVBox = gtk_vbox_new( sal_False, 0 );
198 
199     gtk_box_pack_end (GTK_BOX( m_pVBox ), pHBox, sal_False, sal_False, 0);
200     gtk_box_pack_start (GTK_BOX( pHBox ), pThinVBox, sal_False, sal_False, 0);
201     gtk_widget_show( pHBox );
202     gtk_widget_show( pThinVBox );
203 
204     OUString aLabel;
205 
206 	for( i = 0; i < TOGGLE_LAST; i++ )
207 	{
208 		m_pToggles[i] = gtk_check_button_new();
209 
210 #define LABEL_TOGGLE( elem ) \
211 		case elem : \
212 			aLabel = aResProvider.getResString( CHECKBOX_##elem ); \
213 			setLabel( CHECKBOX_##elem, aLabel ); \
214 			break
215 
216   		switch( i ) {
217 
218 		LABEL_TOGGLE( AUTOEXTENSION );
219 		LABEL_TOGGLE( PASSWORD );
220 		LABEL_TOGGLE( FILTEROPTIONS );
221 		LABEL_TOGGLE( READONLY );
222 		LABEL_TOGGLE( LINK );
223 		LABEL_TOGGLE( PREVIEW );
224 		LABEL_TOGGLE( SELECTION );
225 			default:
226 				OSL_TRACE("Handle unknown control %d\n", i);
227 				break;
228 		}
229 
230 		gtk_box_pack_end( GTK_BOX( pThinVBox ), m_pToggles[i], sal_False, sal_False, 0 );
231 	}
232 
233 	for( i = 0; i < LIST_LAST; i++ )
234 	{
235         m_pHBoxs[i] = gtk_hbox_new( sal_False, 0 );
236 
237         m_pAligns[i] = gtk_alignment_new(0, 0, 0, 1);
238 
239 		m_pLists[i] = gtk_combo_box_new_text();
240 
241 		m_pListLabels[i] = gtk_label_new( "" );
242 
243 #define LABEL_LIST( elem ) \
244 		case elem : \
245 			aLabel = aResProvider.getResString( LISTBOX_##elem##_LABEL ); \
246 			setLabel( LISTBOX_##elem##_LABEL, aLabel ); \
247 			break
248 
249   		switch( i )
250         {
251             LABEL_LIST( VERSION );
252             LABEL_LIST( TEMPLATE );
253             LABEL_LIST( IMAGE_TEMPLATE );
254 			default:
255 				OSL_TRACE("Handle unknown control %d\n", i);
256 				break;
257 		}
258 
259         gtk_container_add( GTK_CONTAINER( m_pAligns[i]), m_pLists[i] );
260         gtk_box_pack_end( GTK_BOX( m_pHBoxs[i] ), m_pAligns[i], sal_False, sal_False, 0 );
261 
262         gtk_box_pack_end( GTK_BOX( m_pHBoxs[i] ), m_pListLabels[i], sal_False, sal_False, 0 );
263 
264         gtk_box_pack_end( GTK_BOX( m_pVBox ), m_pHBoxs[i], sal_False, sal_False, 0 );
265 	}
266 
267     aLabel = aResProvider.getResString( FILE_PICKER_FILE_TYPE );
268     m_pFilterExpander = gtk_expander_new_with_mnemonic(
269         OUStringToOString( aLabel, RTL_TEXTENCODING_UTF8 ).getStr());
270 
271     gtk_box_pack_end( GTK_BOX( m_pVBox ), m_pFilterExpander, sal_False, sal_True, 0 );
272 
273     GtkWidget *scrolled_window = gtk_scrolled_window_new (NULL, NULL);
274     gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
275         GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
276     gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window),
277         GTK_SHADOW_IN);
278     gtk_container_add (GTK_CONTAINER (m_pFilterExpander), scrolled_window);
279     gtk_widget_show (scrolled_window);
280 
281     ByteString sExpand(getenv("SAL_EXPANDFPICKER"));
282     sal_Int32 nExpand  = sExpand.ToInt32();
283     switch (nExpand)
284     {
285         default:
286         case 0:
287             break;
288         case 1:
289             gtk_expander_set_expanded( GTK_EXPANDER(m_pFilterExpander), sal_True);
290             break;
291         case 2:
292             expandexpanders(GTK_CONTAINER(m_pDialog));
293             gtk_expander_set_expanded( GTK_EXPANDER(m_pFilterExpander), sal_True);
294             break;
295     }
296 
297     m_pFilterStore = gtk_list_store_new (4, G_TYPE_STRING, G_TYPE_STRING,
298         G_TYPE_STRING, G_TYPE_STRING);
299     m_pFilterView = gtk_tree_view_new_with_model (GTK_TREE_MODEL(m_pFilterStore));
300     gtk_tree_view_set_headers_visible (GTK_TREE_VIEW(m_pFilterView), false);
301     gtk_tree_view_set_rules_hint (GTK_TREE_VIEW(m_pFilterView), true);
302 
303     GtkTreeViewColumn *column;
304     GtkCellRenderer *cell;
305 
306     for (i = 0; i < 2; ++i)
307     {
308         column = gtk_tree_view_column_new ();
309         cell = gtk_cell_renderer_text_new ();
310         gtk_tree_view_column_set_expand (column, sal_True);
311         gtk_tree_view_column_pack_start (column, cell, sal_False);
312         gtk_tree_view_column_set_attributes (column, cell, "text", i, (char *)NULL);
313         gtk_tree_view_append_column (GTK_TREE_VIEW(m_pFilterView), column);
314     }
315 
316     gtk_container_add (GTK_CONTAINER (scrolled_window), m_pFilterView);
317     gtk_widget_show (m_pFilterView);
318 
319 	gtk_file_chooser_set_extra_widget( GTK_FILE_CHOOSER( m_pDialog ), m_pVBox );
320 
321 	m_pPreview = gtk_image_new();
322 	gtk_file_chooser_set_preview_widget( GTK_FILE_CHOOSER( m_pDialog ), m_pPreview );
323 
324 	g_signal_connect( G_OBJECT( m_pToggles[PREVIEW] ), "toggled",
325 					  G_CALLBACK( preview_toggled_cb ), this );
326     g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW(m_pFilterView)), "changed",
327                       G_CALLBACK ( type_changed_cb ), this);
328 	g_signal_connect( G_OBJECT( m_pDialog ), "notify::filter",
329 					  G_CALLBACK( filter_changed_cb ), this);
330 	g_signal_connect( G_OBJECT( m_pFilterExpander ), "activate",
331 					  G_CALLBACK( expander_changed_cb ), this);
332     g_signal_connect (G_OBJECT( m_pDialog ), "map",
333                       G_CALLBACK (dialog_mapped_cb), this);
334 
335     gtk_widget_show( m_pVBox );
336 
337     PangoLayout  *layout = gtk_widget_create_pango_layout (m_pFilterView, NULL);
338     guint ypad;
339     PangoRectangle row_height;
340     pango_layout_set_markup (layout, "All Files", -1);
341     pango_layout_get_pixel_extents (layout, NULL, &row_height);
342     g_object_get (cell, "ypad", &ypad, (char *)NULL);
343     guint height = (row_height.height + 2*ypad) * 5;
344     gtk_widget_set_size_request (m_pFilterView, -1, height);
345     gtk_widget_set_size_request (m_pPreview, 1, height);
346 
347     gtk_file_chooser_set_preview_widget_active( GTK_FILE_CHOOSER( m_pDialog ), true);
348 }
349 
350 //------------------------------------------------------------------------------------
351 // XFilePickerNotifier
352 //------------------------------------------------------------------------------------
353 
354 void SAL_CALL SalGtkFilePicker::addFilePickerListener( const uno::Reference<XFilePickerListener>& xListener )
355 	throw( uno::RuntimeException )
356 {
357     m_xListener = xListener;
358 }
359 
360 void SAL_CALL SalGtkFilePicker::removeFilePickerListener( const uno::Reference<XFilePickerListener>& )
361 	throw( uno::RuntimeException )
362 {
363     m_xListener.clear();
364 }
365 
366 // -------------------------------------------------
367 // XEventListener
368 // -------------------------------------------------
369 
370 void SAL_CALL SalGtkFilePicker::disposing( const lang::EventObject& aEvent ) throw( uno::RuntimeException )
371 {
372 	uno::Reference<XFilePickerListener> xFilePickerListener( aEvent.Source, ::com::sun::star::uno::UNO_QUERY );
373 
374 	if( xFilePickerListener.is() )
375 		removeFilePickerListener( xFilePickerListener );
376 }
377 
378 //-----------------------------------------------------------------------------------------
379 // FilePicker Event functions
380 //-----------------------------------------------------------------------------------------
381 
382 void SAL_CALL SalGtkFilePicker::fileSelectionChanged( FilePickerEvent aEvent )
383 {
384 	OSL_TRACE( "file selection changed");
385     if (m_xListener.is()) m_xListener->fileSelectionChanged( aEvent );
386 }
387 
388 void SAL_CALL SalGtkFilePicker::directoryChanged( FilePickerEvent aEvent )
389 {
390 	OSL_TRACE("directory changed");
391     if (m_xListener.is()) m_xListener->directoryChanged( aEvent );
392 }
393 
394 void SAL_CALL SalGtkFilePicker::controlStateChanged( FilePickerEvent aEvent )
395 {
396 	OSL_TRACE("control state changed");
397     if (m_xListener.is()) m_xListener->controlStateChanged( aEvent );
398 }
399 
400 //-----------------------------------------------------------------------------------------
401 // If there are more then one listener the return value of the last one wins
402 //-----------------------------------------------------------------------------------------
403 
404 rtl::OUString SAL_CALL SalGtkFilePicker::helpRequested( FilePickerEvent aEvent ) const
405 {
406 	rtl::OUString aHelpText;
407 
408 	::cppu::OInterfaceContainerHelper* pICHelper =
409 		rBHelper.getContainer( getCppuType( ( uno::Reference<XFilePickerListener> * )0 ) );
410 
411 	if( pICHelper )
412 	{
413 		::cppu::OInterfaceIteratorHelper iter( *pICHelper );
414 
415 		while( iter.hasMoreElements() )
416 		{
417 			try
418 			{
419 				/*
420 			          if there are multiple listeners responding
421 		                  to this notification the next response
422 				  overwrittes  the one before if it is not empty
423 		                */
424 
425 				rtl::OUString aTempString;
426 
427 				uno::Reference<XFilePickerListener> xFPListener( iter.next(), uno::UNO_QUERY );
428 				if( xFPListener.is() )
429 		                {
430 					aTempString = xFPListener->helpRequested( aEvent );
431 					if( aTempString.getLength() )
432 						aHelpText = aTempString;
433 		                }
434 
435 			}
436 			catch( uno::RuntimeException& )
437 			{
438 				OSL_ENSURE( false, "RuntimeException during event dispatching" );
439 			}
440 		}
441 	}
442 
443 	return aHelpText;
444 }
445 
446 //=====================================================================
447 
448 struct FilterEntry
449 {
450 protected:
451 	::rtl::OUString		m_sTitle;
452 	::rtl::OUString		m_sFilter;
453 
454 	UnoFilterList		m_aSubFilters;
455 
456 public:
457 	FilterEntry( const ::rtl::OUString& _rTitle, const ::rtl::OUString& _rFilter )
458 		:m_sTitle( _rTitle )
459 		,m_sFilter( _rFilter )
460 	{
461 	}
462 
463 	FilterEntry( const ::rtl::OUString& _rTitle, const UnoFilterList& _rSubFilters );
464 
465 	::rtl::OUString		getTitle() const { return m_sTitle; }
466 	::rtl::OUString		getFilter() const { return m_sFilter; }
467 
468 	/// determines if the filter has sub filter (i.e., the filter is a filter group in real)
469 	sal_Bool		hasSubFilters( ) const;
470 
471 	/** retrieves the filters belonging to the entry
472 	@return
473 		the number of sub filters
474 	*/
475 	sal_Int32		getSubFilters( UnoFilterList& _rSubFilterList );
476 
477 	// helpers for iterating the sub filters
478 	const UnoFilterEntry*	beginSubFilters() const { return m_aSubFilters.getConstArray(); }
479 	const UnoFilterEntry*	endSubFilters() const { return m_aSubFilters.getConstArray() + m_aSubFilters.getLength(); }
480 };
481 
482 //=====================================================================
483 
484 //---------------------------------------------------------------------
485 FilterEntry::FilterEntry( const ::rtl::OUString& _rTitle, const UnoFilterList& _rSubFilters )
486 	:m_sTitle( _rTitle )
487 	,m_aSubFilters( _rSubFilters )
488 {
489 }
490 
491 //---------------------------------------------------------------------
492 sal_Bool FilterEntry::hasSubFilters() const
493 {
494 	return( 0 < m_aSubFilters.getLength() );
495 }
496 
497 //---------------------------------------------------------------------
498 sal_Int32 FilterEntry::getSubFilters( UnoFilterList& _rSubFilterList )
499 {
500 	_rSubFilterList = m_aSubFilters;
501 	return m_aSubFilters.getLength();
502 }
503 
504 static bool
505 isFilterString( const rtl::OUString &rFilterString, const char *pMatch )
506 {
507 		sal_Int32 nIndex = 0;
508 		rtl::OUString aToken;
509 		bool bIsFilter = true;
510 
511         rtl::OUString aMatch(rtl::OUString::createFromAscii(pMatch));
512 
513 		do
514 		{
515 			aToken = rFilterString.getToken( 0, ';', nIndex );
516 			if( !aToken.match( aMatch ) )
517 			{
518 				bIsFilter = false;
519 				break;
520 			}
521 		}
522 		while( nIndex >= 0 );
523 
524 		return bIsFilter;
525 }
526 
527 static rtl::OUString
528 shrinkFilterName( const rtl::OUString &rFilterName, bool bAllowNoStar = false )
529 {
530 	int i;
531 	int nBracketLen = -1;
532 	int nBracketEnd = -1;
533 	const sal_Unicode* pStr = rFilterName.getStr();
534 	OUString aRealName = rFilterName;
535 
536 	for( i = aRealName.getLength() - 1; i > 0; i-- )
537 	{
538 		if( pStr[i] == ')' )
539 			nBracketEnd = i;
540 		else if( pStr[i] == '(' )
541 		{
542 			nBracketLen = nBracketEnd - i;
543 			if( nBracketEnd <= 0 )
544                 continue;
545 			if( isFilterString( rFilterName.copy( i + 1, nBracketLen - 1 ), "*." ) )
546                 aRealName = aRealName.replaceAt( i, nBracketLen + 1, rtl::OUString() );
547             else if (bAllowNoStar)
548             {
549 			    if( isFilterString( rFilterName.copy( i + 1, nBracketLen - 1 ), ".") )
550                     aRealName = aRealName.replaceAt( i, nBracketLen + 1, rtl::OUString() );
551             }
552 		}
553 	}
554 
555 	return aRealName;
556 }
557 
558 static void
559 dialog_remove_buttons( GtkDialog *pDialog )
560 {
561     GdkThreadLock aLock;
562 
563     g_return_if_fail( GTK_IS_DIALOG( pDialog ) );
564 
565     GList *pChildren =
566         gtk_container_get_children( GTK_CONTAINER( pDialog->action_area ) );
567 
568     for( GList *p = pChildren; p; p = p->next )
569         gtk_widget_destroy( GTK_WIDGET( p->data ) );
570 
571     g_list_free( pChildren );
572 }
573 
574 //------------------------------------------------------------------------------------
575 namespace {
576 	//................................................................................
577 	struct FilterTitleMatch : public ::std::unary_function< FilterEntry, bool >
578 	{
579 	protected:
580 		const ::rtl::OUString& rTitle;
581 
582 	public:
583 		FilterTitleMatch( const ::rtl::OUString& _rTitle ) : rTitle( _rTitle ) { }
584 
585 		//............................................................................
586 		bool operator () ( const FilterEntry& _rEntry )
587 		{
588 			sal_Bool bMatch;
589 			if( !_rEntry.hasSubFilters() )
590 				// a real filter
591 				bMatch = ( _rEntry.getTitle() == rTitle );
592 			else
593 				// a filter group -> search the sub filters
594 				bMatch =
595 					_rEntry.endSubFilters() != ::std::find_if(
596 						_rEntry.beginSubFilters(),
597 						_rEntry.endSubFilters(),
598 						*this
599 					);
600 
601 			return bMatch ? true : false;
602 		}
603 		bool operator () ( const UnoFilterEntry& _rEntry )
604 		{
605 			OUString aShrunkName = shrinkFilterName( _rEntry.First );
606 			return aShrunkName == rTitle ? true : false;
607 		}
608 	};
609 }
610 
611 
612 //------------------------------------------------------------------------------------
613 sal_Bool SalGtkFilePicker::FilterNameExists( const ::rtl::OUString& rTitle )
614 {
615 	sal_Bool bRet = sal_False;
616 
617 	if( m_pFilterList )
618 		bRet =
619 			m_pFilterList->end() != ::std::find_if(
620 				m_pFilterList->begin(),
621 				m_pFilterList->end(),
622 				FilterTitleMatch( rTitle )
623 			);
624 
625 	return bRet;
626 }
627 
628 //------------------------------------------------------------------------------------
629 sal_Bool SalGtkFilePicker::FilterNameExists( const UnoFilterList& _rGroupedFilters )
630 {
631 	sal_Bool bRet = sal_False;
632 
633 	if( m_pFilterList )
634 	{
635 		const UnoFilterEntry* pStart = _rGroupedFilters.getConstArray();
636 		const UnoFilterEntry* pEnd = pStart + _rGroupedFilters.getLength();
637 		for( ; pStart != pEnd; ++pStart )
638 			if( m_pFilterList->end() != ::std::find_if(
639 						m_pFilterList->begin(),
640 						m_pFilterList->end(),
641 						FilterTitleMatch( pStart->First ) ) )
642 				break;
643 
644 		bRet = pStart != pEnd;
645 	}
646 
647 	return bRet;
648 }
649 
650 //------------------------------------------------------------------------------------
651 void SalGtkFilePicker::ensureFilterList( const ::rtl::OUString& _rInitialCurrentFilter )
652 {
653 	if( !m_pFilterList )
654 	{
655 		m_pFilterList = new FilterList;
656 
657 		// set the first filter to the current filter
658 		if ( !m_aCurrentFilter.getLength() )
659 			m_aCurrentFilter = _rInitialCurrentFilter;
660 	}
661 }
662 
663 
664 //-----------------------------------------------------------------------------------------
665 //
666 //-----------------------------------------------------------------------------------------
667 
668 void SAL_CALL SalGtkFilePicker::appendFilter( const rtl::OUString& aTitle, const rtl::OUString& aFilter )
669 	throw( lang::IllegalArgumentException, uno::RuntimeException )
670 {
671 	OSL_ASSERT( m_pDialog != NULL );
672 
673 	if( FilterNameExists( aTitle ) )
674 	        throw IllegalArgumentException();
675 
676 	// ensure that we have a filter list
677 	ensureFilterList( aTitle );
678 
679 	// append the filter
680 	m_pFilterList->insert( m_pFilterList->end(), FilterEntry( aTitle, aFilter ) );
681 }
682 
683 //-----------------------------------------------------------------------------------------
684 //
685 //-----------------------------------------------------------------------------------------
686 
687 void SAL_CALL SalGtkFilePicker::setCurrentFilter( const rtl::OUString& aTitle )
688 	throw( lang::IllegalArgumentException, uno::RuntimeException )
689 {
690 	OSL_ASSERT( m_pDialog != NULL );
691 
692 	OSL_TRACE( "Setting current filter to %s\n",
693 		OUStringToOString( aTitle, RTL_TEXTENCODING_UTF8 ).getStr() );
694 
695 	if( aTitle != m_aCurrentFilter )
696 	{
697 		m_aCurrentFilter = aTitle;
698 		SetCurFilter( m_aCurrentFilter );
699 		OSL_TRACE( "REALLY Setting current filter to %s\n",
700 			OUStringToOString( aTitle, RTL_TEXTENCODING_UTF8 ).getStr() );
701 
702 	}
703 
704 	// TODO m_pImpl->setCurrentFilter( aTitle );
705 }
706 
707 //-----------------------------------------------------------------------------------------
708 //
709 //-----------------------------------------------------------------------------------------
710 
711 void SalGtkFilePicker::updateCurrentFilterFromName(const gchar* filtername)
712 {
713 	OUString aFilterName(filtername, strlen(filtername), RTL_TEXTENCODING_UTF8);
714 	FilterList::iterator aEnd = m_pFilterList->end();
715     for (FilterList::iterator aIter = m_pFilterList->begin(); aIter != aEnd; ++aIter)
716     {
717         if (aFilterName == shrinkFilterName( aIter->getTitle()))
718         {
719             m_aCurrentFilter = aIter->getTitle();
720             break;
721         }
722     }
723 }
724 
725 void SalGtkFilePicker::UpdateFilterfromUI()
726 {
727 	// Update the filtername from the users selection if they have had a chance to do so.
728     // If the user explicitly sets a type then use that, if not then take the implicit type
729     // from the filter of the files glob on which he is currently searching
730 	if (!mnHID_FolderChange	|| !mnHID_SelectionChange)
731         return;
732 
733     GdkThreadLock aLock;
734 
735     GtkTreeSelection* selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(m_pFilterView));
736     GtkTreeIter iter;
737     GtkTreeModel *model;
738     if (gtk_tree_selection_get_selected (selection, &model, &iter))
739     {
740         gchar *title;
741         gtk_tree_model_get (model, &iter, 2, &title, -1);
742         updateCurrentFilterFromName(title);
743         g_free (title);
744     }
745     else if( GtkFileFilter *filter = gtk_file_chooser_get_filter(GTK_FILE_CHOOSER(m_pDialog)))
746     {
747 		if (m_pPseudoFilter != filter)
748         	updateCurrentFilterFromName(gtk_file_filter_get_name( filter ));
749 		else
750         	updateCurrentFilterFromName(OUStringToOString( m_aInitialFilter, RTL_TEXTENCODING_UTF8 ).getStr());
751     }
752 }
753 
754 rtl::OUString SAL_CALL SalGtkFilePicker::getCurrentFilter() throw( uno::RuntimeException )
755 {
756 	OSL_ASSERT( m_pDialog != NULL );
757 
758 	OSL_TRACE( "GetCURRENTfilter\n" );
759 
760     UpdateFilterfromUI();
761 
762 	OSL_TRACE( "Returning current filter of %s\n",
763 		OUStringToOString( m_aCurrentFilter, RTL_TEXTENCODING_UTF8 ).getStr() );
764 
765 	return m_aCurrentFilter;
766 }
767 
768 //-----------------------------------------------------------------------------------------
769 // XFilterGroupManager functions
770 //-----------------------------------------------------------------------------------------
771 
772 void SAL_CALL SalGtkFilePicker::appendFilterGroup( const rtl::OUString& /*sGroupTitle*/, const uno::Sequence<beans::StringPair>& aFilters )
773 	throw( lang::IllegalArgumentException, uno::RuntimeException )
774 {
775 	OSL_ASSERT( m_pDialog != NULL );
776 
777 	// TODO m_pImpl->appendFilterGroup( sGroupTitle, aFilters );
778 	// check the names
779 	if( FilterNameExists( aFilters ) )
780 		// TODO: a more precise exception message
781 	        throw IllegalArgumentException();
782 
783 	// ensure that we have a filter list
784 	::rtl::OUString sInitialCurrentFilter;
785 	if( aFilters.getLength() )
786 		sInitialCurrentFilter = aFilters[0].First;
787 
788 	ensureFilterList( sInitialCurrentFilter );
789 
790 	// append the filter
791 	const StringPair* pSubFilters   = aFilters.getConstArray();
792 	const StringPair* pSubFiltersEnd = pSubFilters + aFilters.getLength();
793 	for( ; pSubFilters != pSubFiltersEnd; ++pSubFilters )
794 		m_pFilterList->insert( m_pFilterList->end(), FilterEntry( pSubFilters->First, pSubFilters->Second ) );
795 
796 }
797 
798 //-----------------------------------------------------------------------------------------
799 // XFilePicker functions
800 //-----------------------------------------------------------------------------------------
801 
802 void SAL_CALL SalGtkFilePicker::setMultiSelectionMode( sal_Bool bMode ) throw( uno::RuntimeException )
803 {
804 	OSL_ASSERT( m_pDialog != NULL );
805 
806     GdkThreadLock aLock;
807 
808 	gtk_file_chooser_set_select_multiple( GTK_FILE_CHOOSER(m_pDialog), bMode );
809 }
810 
811 void SAL_CALL SalGtkFilePicker::setDefaultName( const rtl::OUString& aName )
812 	throw( uno::RuntimeException )
813 {
814 	OSL_ASSERT( m_pDialog != NULL );
815 
816     GdkThreadLock aLock;
817 
818 	OString aStr = OUStringToOString( aName, RTL_TEXTENCODING_UTF8 );
819     GtkFileChooserAction eAction = gtk_file_chooser_get_action( GTK_FILE_CHOOSER( m_pDialog ) );
820 
821     // set_current_name launches a Gtk critical error if called for other than save
822     if( GTK_FILE_CHOOSER_ACTION_SAVE == eAction )
823         gtk_file_chooser_set_current_name( GTK_FILE_CHOOSER( m_pDialog ), aStr.getStr() );
824 }
825 
826 void SAL_CALL SalGtkFilePicker::setDisplayDirectory( const rtl::OUString& rDirectory )
827 	throw( lang::IllegalArgumentException, uno::RuntimeException )
828 {
829 	implsetDisplayDirectory(rDirectory);
830 }
831 
832 rtl::OUString SAL_CALL SalGtkFilePicker::getDisplayDirectory() throw( uno::RuntimeException )
833 {
834 	return implgetDisplayDirectory();
835 }
836 
837 uno::Sequence<rtl::OUString> SAL_CALL SalGtkFilePicker::getFiles() throw( uno::RuntimeException )
838 {
839     uno::Sequence< rtl::OUString > aFiles = getSelectedFiles();
840     /*
841       The previous multiselection API design was completely broken
842       and unimplementable for some hetrogenous pseudo-URIs eg. search://
843       Thus crop unconditionally to a single selection.
844     */
845     aFiles.realloc (1);
846     return aFiles;
847 }
848 
849 uno::Sequence<rtl::OUString> SAL_CALL SalGtkFilePicker::getSelectedFiles() throw( uno::RuntimeException )
850 {
851 	OSL_ASSERT( m_pDialog != NULL );
852 
853     GdkThreadLock aLock;
854 
855 	GSList* pPathList = gtk_file_chooser_get_uris( GTK_FILE_CHOOSER(m_pDialog) );
856 
857 	int nCount = g_slist_length( pPathList );
858 	int nIndex = 0;
859 	OSL_TRACE( "GETFILES called %d files\n", nCount );
860 
861 	// get the current action setting
862 	GtkFileChooserAction eAction = gtk_file_chooser_get_action(
863         GTK_FILE_CHOOSER( m_pDialog ));
864 
865 	uno::Sequence< rtl::OUString > aSelectedFiles(nCount);
866 
867 	// Convert to OOo
868     for( GSList *pElem = pPathList; pElem; pElem = pElem->next)
869 	{
870 		gchar *pURI = reinterpret_cast<gchar*>(pElem->data);
871 		aSelectedFiles[ nIndex ] = uritounicode(pURI);
872 
873 		if( GTK_FILE_CHOOSER_ACTION_SAVE == eAction )
874 		{
875             OUString sFilterName;
876             sal_Int32 nTokenIndex = 0;
877             bool bExtensionTypedIn = false;
878 
879             GtkTreeSelection* selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(m_pFilterView));
880             GtkTreeIter iter;
881             GtkTreeModel *model;
882             if (gtk_tree_selection_get_selected (selection, &model, &iter))
883             {
884                 gchar *title;
885                 gtk_tree_model_get (model, &iter, 2, &title, -1);
886                 sFilterName = OUString( title, strlen( title), RTL_TEXTENCODING_UTF8 );
887                 g_free (title);
888             }
889             else
890             {
891                 if( aSelectedFiles[nIndex].indexOf('.') > 0 )
892                 {
893                     rtl::OUString sExtension;
894                     nTokenIndex = 0;
895                     do
896                         sExtension = aSelectedFiles[nIndex].getToken( 0, '.', nTokenIndex );
897                     while( nTokenIndex >= 0 );
898 
899                     if( sExtension.getLength() >= 3 ) // 3 = typical/minimum extension length
900                     {
901                         static const OUString aStarDot = OUString::createFromAscii( "*." );
902 
903                         ::rtl::OUString aNewFilter;
904                         ::rtl::OUString aOldFilter = getCurrentFilter();
905                         sal_Bool bChangeFilter = sal_True;
906                         for ( FilterList::iterator aListIter = m_pFilterList->begin();
907                               aListIter != m_pFilterList->end();
908                               ++aListIter
909                         )
910                         {
911                             if( aListIter->getFilter().indexOf( aStarDot+sExtension ) >= 0 )
912                             {
913                                 if( !aNewFilter.getLength() )
914                                     aNewFilter = aListIter->getTitle();
915 
916                                 if( aOldFilter == aListIter->getTitle() )
917                                     bChangeFilter = sal_False;
918 
919                                 bExtensionTypedIn = true;
920                             }
921                         }
922                         if( bChangeFilter )
923                             setCurrentFilter( aNewFilter );
924                     }
925                 }
926 
927 				GtkFileFilter *filter = gtk_file_chooser_get_filter(GTK_FILE_CHOOSER(m_pDialog));
928         		if (m_pPseudoFilter != filter)
929 				{
930 			    	const gchar* filtername =
931 				    	gtk_file_filter_get_name( filter );
932                 	sFilterName = OUString( filtername, strlen( filtername ), RTL_TEXTENCODING_UTF8 );
933 				}
934 				else
935 					sFilterName = m_aInitialFilter;
936             }
937 
938 			OSL_TRACE( "2: current filter is %s\n",
939 				OUStringToOString( sFilterName, RTL_TEXTENCODING_UTF8 ).getStr() );
940 
941 			FilterList::iterator aListIter = ::std::find_if(
942                 m_pFilterList->begin(), m_pFilterList->end(), FilterTitleMatch(sFilterName) );
943 
944 			OUString aFilter;
945             if (aListIter != m_pFilterList->end())
946 			    aFilter = aListIter->getFilter();
947 
948 			OSL_TRACE( "turned into %s\n",
949 				OUStringToOString( aFilter, RTL_TEXTENCODING_UTF8 ).getStr() );
950 
951 			nTokenIndex = 0;
952 			rtl::OUString sToken;
953 			//   rtl::OUString strExt;
954 			do
955 			{
956 				sToken = aFilter.getToken( 0, '.', nTokenIndex );
957 
958 				if ( sToken.lastIndexOf( ';' ) != -1 )
959 				{
960 					sal_Int32 nZero = 0;
961 					OUString aCurrentToken = sToken.getToken( 0, ';', nZero);
962 
963 					sToken = aCurrentToken;
964 					break;
965 				}
966 			}
967 			while( nTokenIndex >= 0 );
968 
969 			if( !bExtensionTypedIn && ( !sToken.equalsAscii( "*" ) ) )
970 			{
971 				//if the filename does not already have the auto extension, stick it on
972 				OUString sExtension = OUString::createFromAscii( "." ) + sToken;
973 				OUString &rBase = aSelectedFiles[nIndex];
974 				sal_Int32 nExtensionIdx = rBase.getLength() - sExtension.getLength();
975 				OSL_TRACE( "idx are %d %d\n", rBase.lastIndexOf( sExtension ), nExtensionIdx );
976 
977 				if( rBase.lastIndexOf( sExtension ) != nExtensionIdx )
978 					rBase += sExtension;
979 			}
980 
981 		}
982 
983 		nIndex++;
984 		g_free( pURI );
985 	}
986 
987 	g_slist_free( pPathList );
988 
989 	return aSelectedFiles;
990 }
991 
992 //-----------------------------------------------------------------------------------------
993 // XExecutableDialog functions
994 //-----------------------------------------------------------------------------------------
995 
996 void SAL_CALL SalGtkFilePicker::setTitle( const rtl::OUString& rTitle ) throw( uno::RuntimeException )
997 {
998 	implsetTitle(rTitle);
999 }
1000 
1001 sal_Int16 SAL_CALL SalGtkFilePicker::execute() throw( uno::RuntimeException )
1002 {
1003 	OSL_TRACE( "1: HERE WE ARE\n");
1004 	OSL_ASSERT( m_pDialog != NULL );
1005 
1006     GdkThreadLock aLock;
1007 
1008 	sal_Int16 retVal = 0;
1009 
1010 	SetFilters();
1011 
1012 	mnHID_FolderChange =
1013 		g_signal_connect( GTK_FILE_CHOOSER( m_pDialog ), "current-folder-changed",
1014 			G_CALLBACK( folder_changed_cb ), ( gpointer )this );
1015 
1016 	mnHID_SelectionChange =
1017 		g_signal_connect( GTK_FILE_CHOOSER( m_pDialog ), "selection-changed",
1018 			G_CALLBACK( selection_changed_cb ), ( gpointer )this );
1019 
1020 	int btn = GTK_RESPONSE_NO;
1021 
1022     uno::Reference< awt::XExtendedToolkit > xToolkit(
1023         m_xServiceMgr->createInstance( ::rtl::OUString::createFromAscii("com.sun.star.awt.Toolkit") ), uno::UNO_QUERY);
1024 
1025 	RunDialog* pRunDialog = new RunDialog(m_pDialog, xToolkit);
1026 	uno::Reference < awt::XTopWindowListener > xLifeCycle(pRunDialog);
1027 	while( GTK_RESPONSE_NO == btn )
1028 	{
1029 		btn = GTK_RESPONSE_YES; // we dont want to repeat unless user clicks NO for file save.
1030 
1031         gint nStatus = pRunDialog->run();
1032 		switch( nStatus )
1033 		{
1034 			case GTK_RESPONSE_ACCEPT:
1035 				if( GTK_FILE_CHOOSER_ACTION_SAVE == gtk_file_chooser_get_action( GTK_FILE_CHOOSER( m_pDialog ) ) )
1036 				{
1037 					Sequence < OUString > aPathSeq = getFiles();
1038 					if( aPathSeq.getLength() == 1 )
1039 					{
1040 						OString sFileName = unicodetouri( aPathSeq[0] );
1041 						if( g_file_test( g_filename_from_uri( sFileName.getStr(), NULL, NULL ), G_FILE_TEST_IS_REGULAR ) )
1042 						{
1043                             CResourceProvider aResProvider;
1044 							GtkWidget *dlg;
1045 
1046 							dlg = gtk_message_dialog_new( NULL,
1047                                 GTK_DIALOG_MODAL,
1048 								GTK_MESSAGE_QUESTION,
1049 								GTK_BUTTONS_YES_NO,
1050                                   OUStringToOString(
1051                                     aResProvider.getResString( FILE_PICKER_OVERWRITE ),
1052                                     RTL_TEXTENCODING_UTF8 ).getStr() );
1053 
1054                             gtk_window_set_title( GTK_WINDOW( dlg ),
1055                                 OUStringToOString(aResProvider.getResString(FILE_PICKER_TITLE_SAVE ),
1056                                 RTL_TEXTENCODING_UTF8 ).getStr() );
1057 
1058 	                        RunDialog* pAnotherDialog = new RunDialog(dlg, xToolkit);
1059 	                        uno::Reference < awt::XTopWindowListener > xAnotherLifeCycle(pAnotherDialog);
1060                             btn = pAnotherDialog->run();
1061 
1062 							gtk_widget_destroy( dlg );
1063 						}
1064 
1065 						if( btn == GTK_RESPONSE_YES )
1066 							retVal = ExecutableDialogResults::OK;
1067 					}
1068 				}
1069 				else
1070 					retVal = ExecutableDialogResults::OK;
1071 				break;
1072 
1073 			case GTK_RESPONSE_CANCEL:
1074 				retVal = ExecutableDialogResults::CANCEL;
1075 				break;
1076 
1077 			case 1:	//PLAY
1078 				{
1079 					FilePickerEvent evt;
1080 				    evt.ElementId = PUSHBUTTON_PLAY;
1081 				    OSL_TRACE( "filter_changed, isn't it great %x\n", this);
1082 				    controlStateChanged( evt );
1083 				    btn = GTK_RESPONSE_NO;
1084 				}
1085 				break;
1086 
1087 			default:
1088 				retVal = 0;
1089 				break;
1090 		}
1091 	}
1092 
1093 	if (mnHID_FolderChange)
1094 		g_signal_handler_disconnect(GTK_FILE_CHOOSER( m_pDialog ), mnHID_FolderChange);
1095 	if (mnHID_SelectionChange)
1096 		g_signal_handler_disconnect(GTK_FILE_CHOOSER( m_pDialog ), mnHID_SelectionChange);
1097 
1098 	return retVal;
1099 }
1100 
1101 //------------------------------------------------------------------------------------
1102 
1103 // cf. offapi/com/sun/star/ui/dialogs/ExtendedFilePickerElementIds.idl
1104 GtkWidget *SalGtkFilePicker::getWidget( sal_Int16 nControlId, GType *pType )
1105 {
1106 	OSL_TRACE("control id is %d", nControlId);
1107     GType      tType = GTK_TYPE_TOGGLE_BUTTON; //prevent waring by initializing
1108     GtkWidget *pWidget = 0;
1109 
1110 #define MAP_TOGGLE( elem ) \
1111 		case ExtendedFilePickerElementIds::CHECKBOX_##elem: \
1112 			pWidget = m_pToggles[elem]; tType = GTK_TYPE_TOGGLE_BUTTON; \
1113 			break
1114 #define MAP_BUTTON( elem ) \
1115 		case ExtendedFilePickerElementIds::PUSHBUTTON_##elem: \
1116 			pWidget = m_pButtons[elem]; tType = GTK_TYPE_BUTTON; \
1117 			break
1118 #define MAP_LIST( elem ) \
1119 		case ExtendedFilePickerElementIds::LISTBOX_##elem: \
1120 			pWidget = m_pLists[elem]; tType = GTK_TYPE_COMBO_BOX; \
1121 			break
1122 #define MAP_LIST_LABEL( elem ) \
1123 		case ExtendedFilePickerElementIds::LISTBOX_##elem##_LABEL: \
1124 			pWidget = m_pListLabels[elem]; tType = GTK_TYPE_LABEL; \
1125 			break
1126 
1127 	switch( nControlId )
1128 	{
1129 		MAP_TOGGLE( AUTOEXTENSION );
1130 		MAP_TOGGLE( PASSWORD );
1131 		MAP_TOGGLE( FILTEROPTIONS );
1132 		MAP_TOGGLE( READONLY );
1133 		MAP_TOGGLE( LINK );
1134 		MAP_TOGGLE( PREVIEW );
1135 		MAP_TOGGLE( SELECTION );
1136 		MAP_BUTTON( PLAY );
1137 		MAP_LIST( VERSION );
1138 		MAP_LIST( TEMPLATE );
1139 		MAP_LIST( IMAGE_TEMPLATE );
1140 		MAP_LIST_LABEL( VERSION );
1141 		MAP_LIST_LABEL( TEMPLATE );
1142 		MAP_LIST_LABEL( IMAGE_TEMPLATE );
1143 	default:
1144 		OSL_TRACE("Handle unknown control %d\n", nControlId);
1145 		break;
1146 	}
1147 #undef MAP
1148 
1149 	if( pType )
1150 		*pType = tType;
1151 	return pWidget;
1152 }
1153 
1154 
1155 
1156 //------------------------------------------------------------------------------------
1157 // XFilePickerControlAccess functions
1158 //------------------------------------------------------------------------------------
1159 namespace
1160 {
1161     void HackWidthToFirst(GtkComboBox *pWidget)
1162     {
1163         GdkThreadLock aLock;
1164 
1165         GtkRequisition requisition;
1166         gtk_widget_size_request(GTK_WIDGET(pWidget), &requisition);
1167         gtk_widget_set_size_request(GTK_WIDGET(pWidget), requisition.width, -1);
1168     }
1169 }
1170 
1171 void SalGtkFilePicker::HandleSetListValue(GtkComboBox *pWidget, sal_Int16 nControlAction, const uno::Any& rValue)
1172 {
1173     GdkThreadLock aLock;
1174 
1175     switch (nControlAction)
1176     {
1177         case ControlActions::ADD_ITEM:
1178             {
1179                 OUString sItem;
1180                 rValue >>= sItem;
1181                 gtk_combo_box_append_text(pWidget, rtl::OUStringToOString(sItem, RTL_TEXTENCODING_UTF8).getStr());
1182                 if (!bVersionWidthUnset)
1183                 {
1184                     HackWidthToFirst(pWidget);
1185                     bVersionWidthUnset = true;
1186                 }
1187             }
1188             break;
1189         case ControlActions::ADD_ITEMS:
1190             {
1191                 Sequence< OUString > aStringList;
1192                 rValue >>= aStringList;
1193                 sal_Int32 nItemCount = aStringList.getLength();
1194                 for (sal_Int32 i = 0; i < nItemCount; ++i)
1195                 {
1196                     gtk_combo_box_append_text(pWidget,
1197                         rtl::OUStringToOString(aStringList[i], RTL_TEXTENCODING_UTF8).getStr());
1198                     if (!bVersionWidthUnset)
1199                     {
1200                         HackWidthToFirst(pWidget);
1201                         bVersionWidthUnset = true;
1202                     }
1203                 }
1204             }
1205             break;
1206         case ControlActions::DELETE_ITEM:
1207             {
1208                 sal_Int32 nPos=0;
1209                 rValue >>= nPos;
1210                 gtk_combo_box_remove_text(pWidget, nPos);
1211             }
1212             break;
1213         case ControlActions::DELETE_ITEMS:
1214             {
1215                 gtk_combo_box_set_active(pWidget, -1);
1216                 gint nItems = 0;
1217                 do
1218                 {
1219                         nItems =
1220                                 gtk_tree_model_iter_n_children(
1221                                   gtk_combo_box_get_model(pWidget), NULL);
1222                         for (gint nI = 0; nI < nItems; ++nI)
1223                             gtk_combo_box_remove_text(pWidget, nI);
1224                 }
1225                 while (nItems);
1226             }
1227             break;
1228         case ControlActions::SET_SELECT_ITEM:
1229             {
1230                 sal_Int32 nPos=0;
1231                 rValue >>= nPos;
1232                 gtk_combo_box_set_active(pWidget, nPos);
1233             }
1234             break;
1235         default:
1236             OSL_TRACE("undocumented/unimplemented ControlAction for a list");
1237             break;
1238     }
1239 
1240     //I think its best to make it insensitive unless there is the chance to
1241     //actually select something from the list.
1242     gint nItems = gtk_tree_model_iter_n_children(
1243                     gtk_combo_box_get_model(pWidget), NULL);
1244     gtk_widget_set_sensitive(GTK_WIDGET(pWidget), nItems > 1 ? true : false);
1245 }
1246 
1247 uno::Any SalGtkFilePicker::HandleGetListValue(GtkComboBox *pWidget, sal_Int16 nControlAction) const
1248 {
1249     GdkThreadLock aLock;
1250 
1251     uno::Any aAny;
1252     switch (nControlAction)
1253     {
1254         case ControlActions::GET_ITEMS:
1255             {
1256                 Sequence< OUString > aItemList;
1257 
1258                 GtkTreeModel *pTree = gtk_combo_box_get_model(pWidget);
1259                 GtkTreeIter iter;
1260                 if (gtk_tree_model_get_iter_first(pTree, &iter))
1261                 {
1262                     sal_Int32 nSize = gtk_tree_model_iter_n_children(
1263                         pTree, NULL);
1264 
1265                     aItemList.realloc(nSize);
1266                     for (sal_Int32 i=0; i < nSize; ++i)
1267                     {
1268                         gchar *item;
1269                         gtk_tree_model_get(gtk_combo_box_get_model(pWidget),
1270                             &iter, 0, &item, -1);
1271                         aItemList[i] = OUString(item, strlen(item), RTL_TEXTENCODING_UTF8);
1272                         g_free(item);
1273                         gtk_tree_model_iter_next(pTree, &iter);
1274                     }
1275                 }
1276                 aAny <<= aItemList;
1277             }
1278             break;
1279         case ControlActions::GET_SELECTED_ITEM:
1280             {
1281                 GtkTreeIter iter;
1282                 if (gtk_combo_box_get_active_iter(pWidget, &iter))
1283                 {
1284                         gchar *item;
1285                         gtk_tree_model_get(gtk_combo_box_get_model(pWidget),
1286                             &iter, 0, &item, -1);
1287                         OUString sItem(item, strlen(item), RTL_TEXTENCODING_UTF8);
1288                         aAny <<= sItem;
1289                         g_free(item);
1290                 }
1291             }
1292             break;
1293         case ControlActions::GET_SELECTED_ITEM_INDEX:
1294             {
1295                 gint nActive = gtk_combo_box_get_active(pWidget);
1296                 aAny <<= static_cast< sal_Int32 >(nActive);
1297             }
1298             break;
1299         default:
1300             OSL_TRACE("undocumented/unimplemented ControlAction for a list");
1301             break;
1302     }
1303     return aAny;
1304 }
1305 
1306 void SAL_CALL SalGtkFilePicker::setValue( sal_Int16 nControlId, sal_Int16 nControlAction, const uno::Any& rValue )
1307 	throw( uno::RuntimeException )
1308 {
1309 	OSL_ASSERT( m_pDialog != NULL );
1310 
1311 	OSL_TRACE( "SETTING VALUE %d\n", nControlAction );
1312 	GType tType;
1313 	GtkWidget *pWidget;
1314 
1315     GdkThreadLock aLock;
1316 
1317 	if( !( pWidget = getWidget( nControlId, &tType ) ) )
1318 		OSL_TRACE("enable unknown control %d\n", nControlId);
1319 	else if( tType == GTK_TYPE_TOGGLE_BUTTON )
1320 	{
1321 		sal_Bool bChecked = false;
1322 		rValue >>= bChecked;
1323 		gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( pWidget ), bChecked );
1324 	}
1325 	else if( tType == GTK_TYPE_COMBO_BOX )
1326 		HandleSetListValue(GTK_COMBO_BOX(pWidget), nControlAction, rValue);
1327 	else
1328 	{
1329 		OSL_TRACE("Can't set value on button / list %d %d\n",
1330 			nControlId, nControlAction);
1331 	}
1332 }
1333 
1334 uno::Any SAL_CALL SalGtkFilePicker::getValue( sal_Int16 nControlId, sal_Int16 nControlAction )
1335 	throw( uno::RuntimeException )
1336 {
1337 	OSL_ASSERT( m_pDialog != NULL );
1338 
1339 	uno::Any aRetval;
1340 
1341 	GType tType;
1342 	GtkWidget *pWidget;
1343 
1344     GdkThreadLock aLock;
1345 
1346 	if( !( pWidget = getWidget( nControlId, &tType ) ) )
1347 		OSL_TRACE("enable unknown control %d\n", nControlId);
1348 	else if( tType == GTK_TYPE_TOGGLE_BUTTON )
1349 		aRetval <<= (sal_Bool) gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( pWidget ) );
1350 	else if( tType == GTK_TYPE_COMBO_BOX )
1351 		aRetval = HandleGetListValue(GTK_COMBO_BOX(pWidget), nControlAction);
1352 	else
1353 		OSL_TRACE("Can't get value on button / list %d %d\n",
1354 			nControlId, nControlAction );
1355 
1356 	return aRetval;
1357 }
1358 
1359 void SAL_CALL SalGtkFilePicker::enableControl( sal_Int16 nControlId, sal_Bool bEnable )
1360 throw( uno::RuntimeException )
1361 {
1362 	OSL_ASSERT( m_pDialog != NULL );
1363 
1364 	GtkWidget *pWidget;
1365 
1366     GdkThreadLock aLock;
1367 
1368 	if ( nControlId == ExtendedFilePickerElementIds::LISTBOX_FILTER_SELECTOR )
1369 		gtk_expander_set_expanded( GTK_EXPANDER( m_pFilterExpander ), bEnable );
1370 	else if( ( pWidget = getWidget( nControlId ) ) )
1371 	{
1372 		if( bEnable )
1373 		{
1374 			OSL_TRACE( "enable\n" );
1375 			gtk_widget_set_sensitive( pWidget, sal_True );
1376 		}
1377 		else
1378 		{
1379 			OSL_TRACE( "disable\n" );
1380 			gtk_widget_set_sensitive( pWidget, sal_False );
1381 		}
1382 	}
1383 	else
1384 		OSL_TRACE("enable unknown control %d\n", nControlId );
1385 }
1386 
1387 void SAL_CALL SalGtkFilePicker::setLabel( sal_Int16 nControlId, const ::rtl::OUString& rLabel )
1388 	throw( uno::RuntimeException )
1389 {
1390 	OSL_ASSERT( m_pDialog != NULL );
1391 
1392 	GType tType;
1393 	GtkWidget *pWidget;
1394 
1395     GdkThreadLock aLock;
1396 
1397 	if( !( pWidget = getWidget( nControlId, &tType ) ) )
1398 	{
1399 	  	OSL_TRACE("Set label on unknown control %d\n", nControlId);
1400 		return;
1401 	}
1402 
1403     OString aTxt = OUStringToOString( rLabel.replace('~', '_'), RTL_TEXTENCODING_UTF8 );
1404     if (nControlId == ExtendedFilePickerElementIds::PUSHBUTTON_PLAY)
1405     {
1406 #ifdef GTK_STOCK_MEDIA_PLAY
1407         if (!msPlayLabel.getLength())
1408             msPlayLabel = rLabel;
1409         if (msPlayLabel == rLabel)
1410             gtk_button_set_label(GTK_BUTTON(pWidget), GTK_STOCK_MEDIA_PLAY);
1411         else
1412             gtk_button_set_label(GTK_BUTTON(pWidget), GTK_STOCK_MEDIA_STOP);
1413 #else
1414         gtk_button_set_label(GTK_BUTTON(pWidget), aTxt.getStr());
1415 #endif
1416     }
1417 	else if( tType == GTK_TYPE_TOGGLE_BUTTON || tType == GTK_TYPE_BUTTON || tType == GTK_TYPE_LABEL )
1418 		g_object_set( pWidget, "label", aTxt.getStr(),
1419 					  "use_underline", sal_True, (char *)NULL );
1420 	else
1421 		OSL_TRACE("Can't set label on list\n");
1422 }
1423 
1424 rtl::OUString SAL_CALL SalGtkFilePicker::getLabel( sal_Int16 nControlId )
1425 	throw( uno::RuntimeException )
1426 {
1427 	OSL_ASSERT( m_pDialog != NULL );
1428 
1429 	GType tType;
1430 	OString aTxt;
1431 	GtkWidget *pWidget;
1432 
1433     GdkThreadLock aLock;
1434 
1435 	if( !( pWidget = getWidget( nControlId, &tType ) ) )
1436 		OSL_TRACE("Get label on unknown control %d\n", nControlId);
1437 	else if( tType == GTK_TYPE_TOGGLE_BUTTON || tType == GTK_TYPE_BUTTON || tType == GTK_TYPE_LABEL )
1438 		aTxt = gtk_button_get_label( GTK_BUTTON( pWidget ) );
1439 	else
1440 		OSL_TRACE("Can't get label on list\n");
1441 
1442 	return OStringToOUString( aTxt, RTL_TEXTENCODING_UTF8 );
1443 }
1444 
1445 //------------------------------------------------------------------------------------
1446 // XFilePreview functions
1447 //------------------------------------------------------------------------------------
1448 
1449 uno::Sequence<sal_Int16> SAL_CALL SalGtkFilePicker::getSupportedImageFormats() throw( uno::RuntimeException )
1450 {
1451 	OSL_ASSERT( m_pDialog != NULL );
1452 
1453 	// TODO return m_pImpl->getSupportedImageFormats();
1454 	return uno::Sequence<sal_Int16>();
1455 }
1456 
1457 sal_Int32 SAL_CALL SalGtkFilePicker::getTargetColorDepth() throw( uno::RuntimeException )
1458 {
1459 	OSL_ASSERT( m_pDialog != NULL );
1460 
1461 	// TODO return m_pImpl->getTargetColorDepth();
1462 	return 0;
1463 }
1464 
1465 sal_Int32 SAL_CALL SalGtkFilePicker::getAvailableWidth() throw( uno::RuntimeException )
1466 {
1467 	OSL_ASSERT( m_pDialog != NULL );
1468 
1469 	return m_PreviewImageWidth;
1470 }
1471 
1472 sal_Int32 SAL_CALL SalGtkFilePicker::getAvailableHeight() throw( uno::RuntimeException )
1473 {
1474 	OSL_ASSERT( m_pDialog != NULL );
1475 
1476 	return m_PreviewImageHeight;
1477 }
1478 
1479 void SAL_CALL SalGtkFilePicker::setImage( sal_Int16 /*aImageFormat*/, const uno::Any& /*aImage*/ )
1480 	throw( lang::IllegalArgumentException, uno::RuntimeException )
1481 {
1482 	OSL_ASSERT( m_pDialog != NULL );
1483 
1484 	// TODO m_pImpl->setImage( aImageFormat, aImage );
1485 }
1486 
1487 void SalGtkFilePicker::implChangeType( GtkTreeSelection *selection )
1488 {
1489     CResourceProvider aResProvider;
1490     OUString aLabel = aResProvider.getResString( FILE_PICKER_FILE_TYPE );
1491 
1492     GdkThreadLock aLock;
1493 
1494     GtkTreeIter iter;
1495     GtkTreeModel *model;
1496     if (gtk_tree_selection_get_selected (selection, &model, &iter))
1497     {
1498         gchar *title;
1499         gtk_tree_model_get (model, &iter, 2, &title, -1);
1500         aLabel += rtl::OUString::createFromAscii( ": " );
1501         aLabel += rtl::OUString( title, strlen(title), RTL_TEXTENCODING_UTF8 );
1502         g_free (title);
1503     }
1504     gtk_expander_set_label (GTK_EXPANDER (m_pFilterExpander),
1505         OUStringToOString( aLabel, RTL_TEXTENCODING_UTF8 ).getStr());
1506 	FilePickerEvent evt;
1507 	evt.ElementId = LISTBOX_FILTER;
1508 	controlStateChanged( evt );
1509 }
1510 
1511 void SalGtkFilePicker::type_changed_cb( GtkTreeSelection *selection, SalGtkFilePicker *pobjFP )
1512 {
1513     pobjFP->implChangeType(selection);
1514 }
1515 
1516 void SalGtkFilePicker::unselect_type()
1517 {
1518     GdkThreadLock aLock;
1519 
1520     gtk_tree_selection_unselect_all(gtk_tree_view_get_selection(GTK_TREE_VIEW(m_pFilterView)));
1521 }
1522 
1523 void SalGtkFilePicker::expander_changed_cb( GtkExpander *expander, SalGtkFilePicker *pobjFP )
1524 {
1525     if (gtk_expander_get_expanded(expander))
1526         pobjFP->unselect_type();
1527 }
1528 
1529 void SalGtkFilePicker::filter_changed_cb( GtkFileChooser *, GParamSpec *,
1530 	SalGtkFilePicker *pobjFP )
1531 {
1532 	FilePickerEvent evt;
1533 	evt.ElementId = LISTBOX_FILTER;
1534 	OSL_TRACE( "filter_changed, isn't it great %x\n", pobjFP );
1535 	pobjFP->controlStateChanged( evt );
1536 }
1537 
1538 void SalGtkFilePicker::folder_changed_cb( GtkFileChooser *, SalGtkFilePicker *pobjFP )
1539 {
1540 	FilePickerEvent evt;
1541 	OSL_TRACE( "folder_changed, isn't it great %x\n", pobjFP );
1542 	pobjFP->directoryChanged( evt );
1543 }
1544 
1545 void SalGtkFilePicker::selection_changed_cb( GtkFileChooser *, SalGtkFilePicker *pobjFP )
1546 {
1547 	FilePickerEvent evt;
1548 	OSL_TRACE( "selection_changed, isn't it great %x\n", pobjFP );
1549 	pobjFP->fileSelectionChanged( evt );
1550 }
1551 
1552 void SalGtkFilePicker::update_preview_cb( GtkFileChooser *file_chooser, SalGtkFilePicker* pobjFP )
1553 {
1554 	GtkWidget *preview;
1555 	char *filename;
1556 	GdkPixbuf *pixbuf;
1557 	gboolean have_preview = sal_False;
1558 
1559 	preview = pobjFP->m_pPreview;
1560 	filename = gtk_file_chooser_get_preview_filename( file_chooser );
1561 
1562 	if( gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( pobjFP->m_pToggles[PREVIEW] ) ) && g_file_test( filename, G_FILE_TEST_IS_REGULAR ) )
1563 	{
1564 		pixbuf = gdk_pixbuf_new_from_file_at_size(
1565 				filename,
1566 				pobjFP->m_PreviewImageWidth,
1567 				pobjFP->m_PreviewImageHeight, NULL );
1568 
1569 		have_preview = ( pixbuf != NULL );
1570 
1571 		gtk_image_set_from_pixbuf( GTK_IMAGE( preview ), pixbuf );
1572 		if( pixbuf )
1573 			gdk_pixbuf_unref( pixbuf );
1574 
1575 	}
1576 
1577 	gtk_file_chooser_set_preview_widget_active( file_chooser, have_preview );
1578 
1579 	if( filename )
1580 		g_free( filename );
1581 }
1582 
1583 sal_Bool SAL_CALL SalGtkFilePicker::setShowState( sal_Bool bShowState ) throw( uno::RuntimeException )
1584 {
1585 	OSL_ASSERT( m_pDialog != NULL );
1586 
1587 	// TODO return m_pImpl->setShowState( bShowState );
1588 	if( bShowState != mbPreviewState )
1589 	{
1590         GdkThreadLock aLock;
1591 
1592 		if( bShowState )
1593 		{
1594 			// Show
1595             if( !mHID_Preview )
1596             {
1597                 mHID_Preview = g_signal_connect(
1598                     GTK_FILE_CHOOSER( m_pDialog ), "update-preview",
1599                     G_CALLBACK( update_preview_cb ), ( gpointer )this );
1600             }
1601 			gtk_widget_show( m_pPreview );
1602 		}
1603 		else
1604 		{
1605 			// Hide
1606 			gtk_widget_hide( m_pPreview );
1607 		}
1608 
1609 		// also emit the signal
1610 		g_signal_emit_by_name( GTK_OBJECT( m_pDialog ), "update-preview" );
1611 
1612 		mbPreviewState = bShowState;
1613 	}
1614 	return true;
1615 }
1616 
1617 sal_Bool SAL_CALL SalGtkFilePicker::getShowState() throw( uno::RuntimeException )
1618 {
1619 	OSL_ASSERT( m_pDialog != NULL );
1620 
1621 	return mbPreviewState;
1622 }
1623 
1624 //------------------------------------------------------------------------------------
1625 // XInitialization
1626 //------------------------------------------------------------------------------------
1627 
1628 void SAL_CALL SalGtkFilePicker::initialize( const uno::Sequence<uno::Any>& aArguments )
1629 	throw( uno::Exception, uno::RuntimeException )
1630 {
1631 	// parameter checking
1632 	uno::Any aAny;
1633 	if( 0 == aArguments.getLength() )
1634 		throw lang::IllegalArgumentException(
1635 			rtl::OUString::createFromAscii( "no arguments" ),
1636 			static_cast<XFilePicker2*>( this ), 1 );
1637 
1638 	aAny = aArguments[0];
1639 
1640 	if( ( aAny.getValueType() != ::getCppuType( ( sal_Int16* )0 ) ) &&
1641 	     (aAny.getValueType() != ::getCppuType( ( sal_Int8* )0 ) ) )
1642 		 throw lang::IllegalArgumentException(
1643 			rtl::OUString::createFromAscii( "invalid argument type" ),
1644 			static_cast<XFilePicker2*>( this ), 1 );
1645 
1646 	sal_Int16 templateId = -1;
1647 	aAny >>= templateId;
1648 
1649 	GtkFileChooserAction eAction = GTK_FILE_CHOOSER_ACTION_OPEN;
1650 	const gchar *first_button_text = GTK_STOCK_OPEN;
1651 
1652 
1653 	//   TODO: extract full semantic from
1654 	//   svtools/source/filepicker/filepicker.cxx (getWinBits)
1655 	switch( templateId )
1656 	{
1657 		case FILEOPEN_SIMPLE:
1658 			eAction = GTK_FILE_CHOOSER_ACTION_OPEN;
1659 			first_button_text = GTK_STOCK_OPEN;
1660 			OSL_TRACE( "3all true\n" );
1661 			break;
1662 		case FILESAVE_SIMPLE:
1663 			eAction = GTK_FILE_CHOOSER_ACTION_SAVE;
1664 			first_button_text = GTK_STOCK_SAVE;
1665 			OSL_TRACE( "2all true\n" );
1666 		        break;
1667 		case FILESAVE_AUTOEXTENSION_PASSWORD:
1668 			eAction = GTK_FILE_CHOOSER_ACTION_SAVE;
1669 			first_button_text = GTK_STOCK_SAVE;
1670 			mbToggleVisibility[PASSWORD] = true;
1671 			OSL_TRACE( "1all true\n" );
1672 			// TODO
1673 			break;
1674 		case FILESAVE_AUTOEXTENSION_PASSWORD_FILTEROPTIONS:
1675 			eAction = GTK_FILE_CHOOSER_ACTION_SAVE;
1676 			first_button_text = GTK_STOCK_SAVE;
1677 			mbToggleVisibility[PASSWORD] = true;
1678 			mbToggleVisibility[FILTEROPTIONS] = true;
1679 			OSL_TRACE( "4all true\n" );
1680 			// TODO
1681 		        break;
1682 		case FILESAVE_AUTOEXTENSION_SELECTION:
1683 			eAction = GTK_FILE_CHOOSER_ACTION_SAVE; // SELECT_FOLDER ?
1684 			first_button_text = GTK_STOCK_SAVE;
1685 			mbToggleVisibility[SELECTION] = true;
1686 			OSL_TRACE( "5all true\n" );
1687 			// TODO
1688 		        break;
1689 		case FILESAVE_AUTOEXTENSION_TEMPLATE:
1690 			eAction = GTK_FILE_CHOOSER_ACTION_SAVE;
1691 			first_button_text = GTK_STOCK_SAVE;
1692 			mbListVisibility[TEMPLATE] = true;
1693 			OSL_TRACE( "6all true\n" );
1694 			// TODO
1695 		        break;
1696 		case FILEOPEN_LINK_PREVIEW_IMAGE_TEMPLATE:
1697 			eAction = GTK_FILE_CHOOSER_ACTION_OPEN;
1698 			first_button_text = GTK_STOCK_OPEN;
1699 			mbToggleVisibility[LINK] = true;
1700 			mbToggleVisibility[PREVIEW] = true;
1701 			mbListVisibility[IMAGE_TEMPLATE] = true;
1702 			// TODO
1703 		        break;
1704 		case FILEOPEN_PLAY:
1705 			eAction = GTK_FILE_CHOOSER_ACTION_OPEN;
1706 			first_button_text = GTK_STOCK_OPEN;
1707 			mbButtonVisibility[PLAY] = true;
1708 			// TODO
1709 		        break;
1710 		case FILEOPEN_READONLY_VERSION:
1711 			eAction = GTK_FILE_CHOOSER_ACTION_OPEN;
1712 			first_button_text = GTK_STOCK_OPEN;
1713 			mbToggleVisibility[READONLY] = true;
1714             mbListVisibility[VERSION] = true;
1715 			break;
1716 		case FILEOPEN_LINK_PREVIEW:
1717 			eAction = GTK_FILE_CHOOSER_ACTION_OPEN;
1718 			first_button_text = GTK_STOCK_OPEN;
1719 			mbToggleVisibility[LINK] = true;
1720 			mbToggleVisibility[PREVIEW] = true;
1721 			// TODO
1722 		        break;
1723 		case FILESAVE_AUTOEXTENSION:
1724 			eAction = GTK_FILE_CHOOSER_ACTION_SAVE;
1725 			first_button_text = GTK_STOCK_SAVE;
1726 			OSL_TRACE( "7all true\n" );
1727 			// TODO
1728 		        break;
1729 		default:
1730 		        throw lang::IllegalArgumentException(
1731 				rtl::OUString::createFromAscii( "Unknown template" ),
1732 				static_cast< XFilePicker2* >( this ),
1733 				1 );
1734 	}
1735 
1736     GdkThreadLock aLock;
1737 
1738     if( GTK_FILE_CHOOSER_ACTION_SAVE == eAction )
1739     {
1740         CResourceProvider aResProvider;
1741         OUString aFilePickerTitle(aResProvider.getResString( FILE_PICKER_TITLE_SAVE ));
1742         gtk_window_set_title ( GTK_WINDOW( m_pDialog ),
1743             OUStringToOString( aFilePickerTitle, RTL_TEXTENCODING_UTF8 ).getStr() );
1744     }
1745 
1746     gtk_file_chooser_set_action( GTK_FILE_CHOOSER( m_pDialog ), eAction);
1747     dialog_remove_buttons( GTK_DIALOG( m_pDialog ) );
1748     gtk_dialog_add_button( GTK_DIALOG( m_pDialog ), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL );
1749     for( int nTVIndex = 0; nTVIndex < BUTTON_LAST; nTVIndex++ )
1750     {
1751         if( mbButtonVisibility[nTVIndex] )
1752         {
1753 #ifdef GTK_STOCK_MEDIA_PLAY
1754             m_pButtons[ nTVIndex ] = gtk_dialog_add_button( GTK_DIALOG( m_pDialog ), GTK_STOCK_MEDIA_PLAY, 1 );
1755 #else
1756 		    CResourceProvider aResProvider;
1757             OString aPlay = OUStringToOString( aResProvider.getResString( PUSHBUTTON_PLAY ), RTL_TEXTENCODING_UTF8 );
1758             m_pButtons[ nTVIndex ] = gtk_dialog_add_button( GTK_DIALOG( m_pDialog ), aPlay.getStr(), 1 );
1759 #endif
1760         }
1761     }
1762     gtk_dialog_add_button( GTK_DIALOG( m_pDialog ), first_button_text, GTK_RESPONSE_ACCEPT );
1763 
1764     gtk_dialog_set_default_response( GTK_DIALOG (m_pDialog), GTK_RESPONSE_ACCEPT );
1765 
1766 	// Setup special flags
1767 	for( int nTVIndex = 0; nTVIndex < TOGGLE_LAST; nTVIndex++ )
1768 	{
1769 		if( mbToggleVisibility[nTVIndex] )
1770 			gtk_widget_show( m_pToggles[ nTVIndex ] );
1771 	}
1772 
1773 	for( int nTVIndex = 0; nTVIndex < LIST_LAST; nTVIndex++ )
1774 	{
1775 		if( mbListVisibility[nTVIndex] )
1776         {
1777             gtk_widget_set_sensitive( m_pLists[ nTVIndex ], false );
1778 			gtk_widget_show( m_pLists[ nTVIndex ] );
1779 			gtk_widget_show( m_pListLabels[ nTVIndex ] );
1780             gtk_widget_show( m_pAligns[ nTVIndex ] );
1781 			gtk_widget_show( m_pHBoxs[ nTVIndex ] );
1782         }
1783 	}
1784 }
1785 
1786 void SalGtkFilePicker::preview_toggled_cb( GtkObject *cb, SalGtkFilePicker* pobjFP )
1787 {
1788 	if( pobjFP->mbToggleVisibility[PREVIEW] )
1789 		pobjFP->setShowState( gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( cb ) ) );
1790 }
1791 
1792 //------------------------------------------------------------------------------------
1793 // XCancellable
1794 //------------------------------------------------------------------------------------
1795 
1796 void SAL_CALL SalGtkFilePicker::cancel() throw( uno::RuntimeException )
1797 {
1798 	OSL_ASSERT( m_pDialog != NULL );
1799 
1800 	// TODO m_pImpl->cancel();
1801 }
1802 
1803 // -------------------------------------------------
1804 // XServiceInfo
1805 // -------------------------------------------------
1806 
1807 rtl::OUString SAL_CALL SalGtkFilePicker::getImplementationName()
1808 	throw( uno::RuntimeException )
1809 {
1810 	return rtl::OUString::createFromAscii( FILE_PICKER_IMPL_NAME );
1811 }
1812 
1813 // -------------------------------------------------
1814 //	XServiceInfo
1815 // -------------------------------------------------
1816 
1817 sal_Bool SAL_CALL SalGtkFilePicker::supportsService( const rtl::OUString& ServiceName )
1818 	throw( uno::RuntimeException )
1819 {
1820 	uno::Sequence <rtl::OUString> SupportedServicesNames = FilePicker_getSupportedServiceNames();
1821 
1822 	for( sal_Int32 n = SupportedServicesNames.getLength(); n--; )
1823 		if( SupportedServicesNames[n].compareTo( ServiceName ) == 0)
1824 			return sal_True;
1825 
1826 	return sal_False;
1827 }
1828 
1829 // -------------------------------------------------
1830 //	XServiceInfo
1831 // -------------------------------------------------
1832 
1833 uno::Sequence<rtl::OUString> SAL_CALL SalGtkFilePicker::getSupportedServiceNames()
1834 	throw( uno::RuntimeException )
1835 {
1836 	return FilePicker_getSupportedServiceNames();
1837 }
1838 
1839 
1840 //--------------------------------------------------
1841 // Misc
1842 //-------------------------------------------------
1843 void SalGtkFilePicker::SetCurFilter( const OUString& rFilter )
1844 {
1845     GdkThreadLock aLock;
1846 
1847 	// Get all the filters already added
1848 	GSList *filters = gtk_file_chooser_list_filters ( GTK_FILE_CHOOSER( m_pDialog ) );
1849 	bool bFound = false;
1850 
1851 	for( GSList *iter = filters; !bFound && iter; iter = iter->next )
1852 	{
1853 		GtkFileFilter* pFilter = reinterpret_cast<GtkFileFilter *>( iter->data );
1854 		G_CONST_RETURN gchar * filtername = gtk_file_filter_get_name( pFilter );
1855 		OUString sFilterName( filtername, strlen( filtername ), RTL_TEXTENCODING_UTF8 );
1856 
1857 		OUString aShrunkName = shrinkFilterName( rFilter );
1858 		if( aShrunkName.equals( sFilterName) )
1859 		{
1860 			OSL_TRACE( "actually setting %s\n", filtername );
1861 			gtk_file_chooser_set_filter( GTK_FILE_CHOOSER( m_pDialog ), pFilter );
1862 			bFound = true;
1863 		}
1864 	}
1865 
1866 	g_slist_free( filters );
1867 }
1868 
1869 extern "C"
1870 {
1871 static gboolean
1872 case_insensitive_filter (const GtkFileFilterInfo *filter_info, gpointer data)
1873 {
1874     gboolean bRetval = sal_False;
1875     const char *pFilter = (const char *) data;
1876 
1877     g_return_val_if_fail( data != NULL, sal_False );
1878     g_return_val_if_fail( filter_info != NULL, sal_False );
1879 
1880     if( !filter_info->uri )
1881         return sal_False;
1882 
1883     const char *pExtn = strrchr( filter_info->uri, '.' );
1884     if( !pExtn )
1885         return sal_False;
1886     pExtn++;
1887 
1888     if( !g_ascii_strcasecmp( pFilter, pExtn ) )
1889         bRetval = sal_True;
1890 
1891 #ifdef DEBUG
1892     fprintf( stderr, "'%s' match extn '%s' vs '%s' yeilds %d\n",
1893         filter_info->uri, pExtn, pFilter, bRetval );
1894 #endif
1895 
1896     return bRetval;
1897 }
1898 }
1899 
1900 GtkFileFilter* SalGtkFilePicker::implAddFilter( const OUString& rFilter, const OUString& rType )
1901 {
1902     GdkThreadLock aLock;
1903 
1904 	GtkFileFilter *filter = gtk_file_filter_new();
1905 
1906 	OUString aShrunkName = shrinkFilterName( rFilter );
1907 	OString aFilterName = rtl::OUStringToOString( aShrunkName, RTL_TEXTENCODING_UTF8 );
1908 	gtk_file_filter_set_name( filter, aFilterName.getStr() );
1909 
1910     static const OUString aStarDot = OUString::createFromAscii( "*." );
1911     OUString aTokens;
1912 
1913 	bool bAllGlob = !rType.compareToAscii( "*.*" ) || !rType.compareToAscii( "*" );
1914 	if (bAllGlob)
1915 		gtk_file_filter_add_pattern( filter, "*" );
1916 	else
1917 	{
1918 		sal_Int32 nIndex = 0;
1919 		rtl::OUString aToken;
1920 		do
1921 		{
1922 			aToken = rType.getToken( 0, ';', nIndex );
1923             // Assume all have the "*.<extn>" syntax
1924             aToken = aToken.copy( aToken.lastIndexOf( aStarDot ) + 2 );
1925 			if (aToken.getLength())
1926             {
1927                 if (aTokens.getLength())
1928                     aTokens += OUString::createFromAscii(",");
1929                 aTokens = aTokens += aToken;
1930                 gtk_file_filter_add_custom (filter, GTK_FILE_FILTER_URI,
1931                     case_insensitive_filter,
1932                     g_strdup( rtl::OUStringToOString( aToken, RTL_TEXTENCODING_UTF8).getStr() ),
1933                     (GDestroyNotify) g_free );
1934 
1935 	            OSL_TRACE( "fustering with %s\n", rtl::OUStringToOString( aToken, RTL_TEXTENCODING_UTF8 ).getStr());
1936             }
1937 #ifdef DEBUG
1938             else
1939             {
1940                 g_warning( "Duff filter token '%s'\n",
1941                     rtl::OUStringToOString( rType.getToken( 0, ';', nIndex ), RTL_TEXTENCODING_UTF8 ).getStr());
1942             }
1943 #endif
1944 		}
1945 		while( nIndex >= 0 );
1946 	}
1947 
1948 	gtk_file_chooser_add_filter( GTK_FILE_CHOOSER( m_pDialog ), filter );
1949 
1950     if (!bAllGlob)
1951     {
1952         GtkTreeIter iter;
1953         gtk_list_store_append (m_pFilterStore, &iter);
1954         gtk_list_store_set (m_pFilterStore, &iter,
1955             0, OUStringToOString(shrinkFilterName( rFilter, true ), RTL_TEXTENCODING_UTF8).getStr(),
1956             1, OUStringToOString(aTokens, RTL_TEXTENCODING_UTF8).getStr(),
1957             2, aFilterName.getStr(),
1958             3, OUStringToOString(rType, RTL_TEXTENCODING_UTF8).getStr(),
1959             -1);
1960     }
1961     return filter;
1962 }
1963 
1964 void SalGtkFilePicker::implAddFilterGroup( const OUString& /*_rFilter*/, const Sequence< StringPair >& _rFilters )
1965 {
1966 	// Gtk+ has no filter group concept I think so ...
1967 	// implAddFilter( _rFilter, String() );
1968 	const StringPair* pSubFilters	= _rFilters.getConstArray();
1969 	const StringPair* pSubFiltersEnd = pSubFilters + _rFilters.getLength();
1970 	for( ; pSubFilters != pSubFiltersEnd; ++pSubFilters )
1971 		implAddFilter( pSubFilters->First, pSubFilters->Second );
1972 }
1973 
1974 void SalGtkFilePicker::SetFilters()
1975 {
1976     GdkThreadLock aLock;
1977 
1978 	if (!m_aInitialFilter.getLength())
1979 		m_aInitialFilter = m_aCurrentFilter;
1980 
1981 	rtl::OUString sPseudoFilter;
1982     if( GTK_FILE_CHOOSER_ACTION_SAVE == gtk_file_chooser_get_action( GTK_FILE_CHOOSER( m_pDialog ) ) )
1983     {
1984 		std::set<OUString> aAllFormats;
1985 		if( m_pFilterList && !m_pFilterList->empty() )
1986 		{
1987 			for	(	FilterList::iterator aListIter = m_pFilterList->begin();
1988 					aListIter != m_pFilterList->end();
1989 					++aListIter
1990 				)
1991 			{
1992 				if( aListIter->hasSubFilters() )
1993 				{	// it's a filter group
1994 					UnoFilterList aSubFilters;
1995 					aListIter->getSubFilters( aSubFilters );
1996 					const StringPair* pSubFilters   = aSubFilters.getConstArray();
1997 					const StringPair* pSubFiltersEnd = pSubFilters + aSubFilters.getLength();
1998 					for( ; pSubFilters != pSubFiltersEnd; ++pSubFilters )
1999 						aAllFormats.insert(pSubFilters->Second);
2000 				}
2001 				else
2002 					aAllFormats.insert(aListIter->getFilter());
2003 			}
2004 		}
2005 		if (aAllFormats.size() > 1)
2006 		{
2007 			rtl::OUString sAllFilter;
2008 			std::set<OUString>::const_iterator aEnd = aAllFormats.end();
2009 			for (std::set<OUString>::const_iterator aIter = aAllFormats.begin(); aIter != aEnd; ++aIter)
2010 			{
2011 				if (sAllFilter.getLength())
2012 					sAllFilter += OUString(sal_Unicode(';'));
2013 				sAllFilter += *aIter;
2014 			}
2015 			CResourceProvider aResProvider;
2016 			sPseudoFilter = aResProvider.getResString(FILE_PICKER_ALLFORMATS);
2017 			m_pPseudoFilter = implAddFilter( sPseudoFilter, sAllFilter );
2018 		}
2019     }
2020 
2021 	if( m_pFilterList && !m_pFilterList->empty() )
2022 	{
2023 		for	(	FilterList::iterator aListIter = m_pFilterList->begin();
2024 				aListIter != m_pFilterList->end();
2025 				++aListIter
2026 			)
2027 		{
2028 			if( aListIter->hasSubFilters() )
2029 			{	// it's a filter group
2030 
2031 				UnoFilterList aSubFilters;
2032 				aListIter->getSubFilters( aSubFilters );
2033 
2034 				implAddFilterGroup( aListIter->getTitle(), aSubFilters );
2035 			}
2036 			else
2037 			{
2038 				// it's a single filter
2039 
2040 				implAddFilter( aListIter->getTitle(), aListIter->getFilter() );
2041 			}
2042 		}
2043 	}
2044 
2045     if (gtk_tree_model_iter_n_children(GTK_TREE_MODEL(m_pFilterStore), NULL)) //If m_pFilterStore is not empty
2046         gtk_widget_show( m_pFilterExpander );
2047     else
2048         gtk_widget_hide( m_pFilterExpander );
2049 
2050 	// set the default filter
2051 	if (sPseudoFilter.getLength())
2052 		SetCurFilter( sPseudoFilter );
2053 	else if(m_aCurrentFilter.getLength())
2054 		SetCurFilter( m_aCurrentFilter );
2055 
2056 	OSL_TRACE( "end setting filters\n");
2057 }
2058 
2059 SalGtkFilePicker::~SalGtkFilePicker()
2060 {
2061 	int i;
2062 
2063 	for( i = 0; i < TOGGLE_LAST; i++ )
2064 		gtk_widget_destroy( m_pToggles[i] );
2065 
2066 	for( i = 0; i < LIST_LAST; i++ )
2067     {
2068 		gtk_widget_destroy( m_pListLabels[i] );
2069 		gtk_widget_destroy( m_pAligns[i] ); //m_pAligns[i] owns m_pLists[i]
2070 		gtk_widget_destroy( m_pHBoxs[i] );
2071     }
2072 
2073 	delete m_pFilterList;
2074 
2075 	gtk_widget_destroy( m_pVBox );
2076 }
2077 
2078 /* vi:set tabstop=4 shiftwidth=4 expandtab: */
2079