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