fix filename self-references
[vlc.git] / modules / gui / qt4 / components / complete_preferences.cpp
1 /*****************************************************************************
2  * complete_preferences.cpp : "Normal preferences"
3  ****************************************************************************
4  * Copyright (C) 2006-2011 the VideoLAN team
5  * $Id$
6  *
7  * Authors: ClĂ©ment Stenac <zorglub@videolan.org>
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
22  *****************************************************************************/
23 #ifdef HAVE_CONFIG_H
24 # include "config.h"
25 #endif
26
27 #include <QApplication>
28 #include <QLabel>
29 #include <QTreeWidget>
30 #include <QTreeWidgetItem>
31 #include <QVariant>
32 #include <QString>
33 #include <QFont>
34 #include <QGroupBox>
35 #include <QScrollArea>
36 #include <QVBoxLayout>
37 #include <QGridLayout>
38
39 #include "components/complete_preferences.hpp"
40 #include "components/preferences_widgets.hpp"
41
42 #include <vlc_config_cat.h>
43 #include <vlc_intf_strings.h>
44 #include <vlc_modules.h>
45 #include <assert.h>
46
47 #define ITEM_HEIGHT 25
48
49 /*********************************************************************
50  * The Tree
51  *********************************************************************/
52 PrefsTree::PrefsTree( intf_thread_t *_p_intf, QWidget *_parent ) :
53                             QTreeWidget( _parent ), p_intf( _p_intf )
54 {
55     /* General Qt options */
56     setAlternatingRowColors( true );
57     setHeaderHidden( true );
58
59     setIconSize( QSize( ITEM_HEIGHT,ITEM_HEIGHT ) );
60     setTextElideMode( Qt::ElideNone );
61
62     setUniformRowHeights( true );
63     CONNECT( this, itemExpanded(QTreeWidgetItem*), this, resizeColumns() );
64
65     /* Nice icons */
66 #define BI( a,b) QIcon a##_icon = QIcon( b )
67     BI( audio, ":/prefsmenu/advanced/audio" );
68     BI( video, ":/prefsmenu/advanced/video" );
69     BI( input, ":/prefsmenu/advanced/codec" );
70     BI( sout, ":/prefsmenu/advanced/sout" );
71     BI( advanced, ":/prefsmenu/advanced/extended" );
72     BI( playlist, ":/prefsmenu/advanced/playlist" );
73     BI( interface, ":/prefsmenu/advanced/intf" );
74 #undef BI
75
76     /* Build the tree for the main module */
77     module_t *p_module = module_get_main();
78
79     /* Initialisation and get the confsize */
80     PrefsItemData *data = NULL;
81     PrefsItemData *data_sub = NULL;
82     QTreeWidgetItem *current_item = NULL;
83     unsigned confsize;
84     module_config_t *const p_config = module_config_get (p_module, &confsize);
85
86     /* Go through the list of conf */
87     for( size_t i = 0; i < confsize; i++ )
88     {
89         const char *psz_help;
90         QIcon icon;
91
92         /* Work on a new item */
93         module_config_t *p_item = p_config + i;
94
95         switch( p_item->i_type )
96         {
97         /* This is a category */
98         case CONFIG_CATEGORY:
99             if( p_item->value.i == -1 ) break;
100
101             /* PrefsItemData Init */
102             data = new PrefsItemData();
103             data->name = qtr( config_CategoryNameGet( p_item->value.i ) );
104             psz_help = config_CategoryHelpGet( p_item->value.i );
105             if( psz_help )
106                 data->help = qtr( psz_help );
107             else
108                 data->help.clear();
109             data->i_type = TYPE_CATEGORY;
110             data->i_object_id = p_item->value.i;
111
112             /* This is a category, put a nice icon */
113             switch( p_item->value.i )
114             {
115 #define CI(a,b) case a: icon = b##_icon;break
116             CI( CAT_AUDIO, audio );
117             CI( CAT_VIDEO, video );
118             CI( CAT_INPUT, input );
119             CI( CAT_SOUT, sout );
120             CI( CAT_ADVANCED, advanced );
121             CI( CAT_PLAYLIST, playlist );
122             CI( CAT_INTERFACE, interface );
123             }
124 #undef CI
125
126             /* Create a new QTreeItem to display it in the tree at top level */
127             current_item = new QTreeWidgetItem();
128             current_item->setText( 0, data->name );
129             current_item->setIcon( 0 , icon );
130             //current_item->setSizeHint( 0, QSize( -1, ITEM_HEIGHT ) );
131             current_item->setData( 0, Qt::UserRole,
132                                    qVariantFromValue( data ) );
133             addTopLevelItem( current_item );
134             break;
135
136         /* This is a subcategory */
137         case CONFIG_SUBCATEGORY:
138             if( p_item->value.i == -1 ) break;
139
140             /* Special cases: move the main subcategories to the parent cat*/
141             if( data &&
142                 ( p_item->value.i == SUBCAT_VIDEO_GENERAL ||
143                   p_item->value.i == SUBCAT_ADVANCED_MISC ||
144                   p_item->value.i == SUBCAT_INPUT_GENERAL ||
145                   p_item->value.i == SUBCAT_INTERFACE_GENERAL ||
146                   p_item->value.i == SUBCAT_SOUT_GENERAL||
147                   p_item->value.i == SUBCAT_PLAYLIST_GENERAL||
148                   p_item->value.i == SUBCAT_AUDIO_GENERAL ) )
149             {
150                 /* Data still contains the correct thing */
151                 data->i_type = TYPE_CATSUBCAT;
152                 data->i_subcat_id = p_item->value.i;
153                 data->name = qtr( config_CategoryNameGet( p_item->value.i ) );
154                 psz_help = config_CategoryHelpGet( p_item->value.i );
155                 if( psz_help )
156                     data->help = qtr( psz_help );
157                 else
158                     data->help.clear();
159                 current_item->setData( 0, Qt::UserRole,
160                                        QVariant::fromValue( data ) );
161                 continue;
162             }
163
164             /* Normal Subcategories */
165
166             /* Process the Data */
167             data_sub = new PrefsItemData();
168             data_sub->name = qtr( config_CategoryNameGet( p_item->value.i) );
169             psz_help = config_CategoryHelpGet( p_item->value.i );
170             if( psz_help )
171                 data_sub->help = qtr( psz_help );
172             else
173                 data_sub->help.clear();
174             data_sub->i_type = TYPE_SUBCATEGORY;
175             data_sub->i_object_id = p_item->value.i;
176
177             /* Create a new TreeWidget */
178             QTreeWidgetItem *subcat_item = new QTreeWidgetItem();
179             subcat_item->setText( 0, data_sub->name );
180             subcat_item->setData( 0, Qt::UserRole,
181                                   qVariantFromValue( data_sub ) );
182             //subcat_item->setSizeHint( 0, QSize( -1, ITEM_HEIGHT ) );
183
184             /* Add it to the parent */
185             assert( current_item );
186             current_item->addChild( subcat_item );
187             break;
188
189         /* Other items don't need yet a place on the tree */
190         }
191     }
192     module_config_free( p_config );
193
194
195     module_t **p_list = module_list_get( NULL );
196     /* Build the tree of plugins */
197     for( size_t i = 0; (p_module = p_list[i]) != NULL; i++ )
198     {
199         // Main module excluded
200         if( module_is_main( p_module) ) continue;
201
202         unsigned  confsize;
203         int i_subcategory = 0, i_category = 0;
204
205         bool b_options = false;
206         module_config_t *const p_config = module_config_get (p_module, &confsize);
207
208         /* Loop through the configurations items */
209         for (size_t i = 0; i < confsize; i++)
210         {
211             const module_config_t *p_item = p_config + i;
212
213             if( p_item->i_type == CONFIG_CATEGORY )
214                 i_category = p_item->value.i;
215             else if( p_item->i_type == CONFIG_SUBCATEGORY )
216                 i_subcategory = p_item->value.i;
217
218             if( CONFIG_ITEM(p_item->i_type) )
219                 b_options = true;
220
221             if( b_options && i_category && i_subcategory )
222                 break;
223         }
224         module_config_free (p_config);
225
226         /* Dummy item, please proceed */
227         if( !b_options || i_category == 0 || i_subcategory == 0 ) continue;
228
229
230         // Locate the category item;
231         QTreeWidgetItem *subcat_item = NULL;
232         bool b_found = false;
233
234         for( int i_cat_index = 0 ; i_cat_index < topLevelItemCount();
235                                    i_cat_index++ )
236         {
237             /* Get the treeWidgetItem that correspond to the category */
238             QTreeWidgetItem *cat_item = topLevelItem( i_cat_index );
239             PrefsItemData *data = cat_item->data( 0, Qt::UserRole ).
240                                              value<PrefsItemData *>();
241
242             /* If we match the good category */
243             if( data->i_object_id == i_category )
244             {
245                 for( int i_sc_index = 0; i_sc_index < cat_item->childCount();
246                          i_sc_index++ )
247                 {
248                     subcat_item = cat_item->child( i_sc_index );
249                     PrefsItemData *sc_data = subcat_item->data(0, Qt::UserRole).
250                                                 value<PrefsItemData *>();
251                     if( sc_data && sc_data->i_object_id == i_subcategory )
252                     {
253                         b_found = true;
254                         break;
255                     }
256                 }
257                 if( !b_found )
258                 {
259                     subcat_item = cat_item;
260                     b_found = true;
261                 }
262                 break;
263             }
264         }
265         if( !b_found ) continue;
266
267         PrefsItemData *module_data = new PrefsItemData();
268         module_data->i_type = TYPE_MODULE;
269         module_data->psz_name = strdup( module_get_object( p_module ) );
270         module_data->name = qtr( module_get_name( p_module, false ) );
271         module_data->help.clear();
272         const char *psz_help = module_get_help( p_module );
273         if ( psz_help )
274             module_data->help = qtr( psz_help );
275
276         QTreeWidgetItem *module_item = new QTreeWidgetItem();
277         module_item->setText( 0, module_data->name );
278         module_item->setData( 0, Qt::UserRole,
279                               QVariant::fromValue( module_data) );
280         //module_item->setSizeHint( 0, QSize( -1, ITEM_HEIGHT ) );
281         subcat_item->addChild( module_item );
282     }
283
284     /* We got everything, just sort a bit */
285     sortItems( 0, Qt::AscendingOrder );
286
287     module_list_free( p_list );
288     resizeColumnToContents( 0 );
289 }
290
291 void PrefsTree::applyAll()
292 {
293     doAll( false );
294 }
295
296 void PrefsTree::cleanAll()
297 {
298     doAll( true );
299 }
300
301 void PrefsTree::doAll( bool doclean )
302 {
303     for( int i_cat_index = 0 ; i_cat_index < topLevelItemCount();
304              i_cat_index++ )
305     {
306         QTreeWidgetItem *cat_item = topLevelItem( i_cat_index );
307         for( int i_sc_index = 0; i_sc_index < cat_item->childCount();
308                  i_sc_index++ )
309         {
310             QTreeWidgetItem *sc_item = cat_item->child( i_sc_index );
311             for( int i_module = 0 ; i_module < sc_item->childCount();
312                      i_module++ )
313             {
314                 PrefsItemData *data = sc_item->child( i_module )->
315                                data( 0, Qt::UserRole).value<PrefsItemData *>();
316                 if( data->panel && doclean )
317                 {
318                     delete data->panel;
319                     data->panel = NULL;
320                 }
321                 else if( data->panel )
322                     data->panel->apply();
323             }
324             PrefsItemData *data = sc_item->data( 0, Qt::UserRole).
325                                             value<PrefsItemData *>();
326             if( data->panel && doclean )
327             {
328                 delete data->panel;
329                 data->panel = NULL;
330             }
331             else if( data->panel )
332                 data->panel->apply();
333         }
334         PrefsItemData *data = cat_item->data( 0, Qt::UserRole).
335                                             value<PrefsItemData *>();
336         if( data->panel && doclean )
337         {
338             delete data->panel;
339             data->panel = NULL;
340         }
341         else if( data->panel )
342             data->panel->apply();
343     }
344 }
345
346 /* apply filter on tree item and recursively on its sub items
347  * returns whether the item was filtered */
348 bool PrefsTree::filterItems( QTreeWidgetItem *item, const QString &text,
349                            Qt::CaseSensitivity cs )
350 {
351     bool sub_filtered = true;
352
353     for( int i = 0; i < item->childCount(); i++ )
354     {
355         QTreeWidgetItem *sub_item = item->child( i );
356         if ( !filterItems( sub_item, text, cs ) )
357         {
358             /* not all the sub items were filtered */
359             sub_filtered = false;
360         }
361     }
362
363     PrefsItemData *data = item->data( 0, Qt::UserRole ).value<PrefsItemData *>();
364
365     bool filtered = sub_filtered && !data->contains( text, cs );
366     item->setExpanded( !sub_filtered );
367     item->setHidden( filtered );
368
369     return filtered;
370 }
371
372
373 /* collapse item if it's not selected or one of its sub items
374  * returns whether the item was collapsed */
375 bool PrefsTree::collapseUnselectedItems( QTreeWidgetItem *item )
376 {
377     bool sub_collapsed = true;
378
379     for( int i = 0; i < item->childCount(); i++ )
380     {
381         QTreeWidgetItem *sub_item = item->child( i );
382         if ( !collapseUnselectedItems( sub_item ) )
383         {
384             /* not all the sub items were collapsed */
385             sub_collapsed = false;
386         }
387     }
388
389     bool collapsed = sub_collapsed && !item->isSelected();
390     item->setExpanded( !sub_collapsed );
391     item->setHidden( false );
392
393     return collapsed;
394 }
395
396 /* apply filter on tree */
397 void PrefsTree::filter( const QString &text )
398 {
399     bool clear_filter = text.isEmpty();
400
401     for( int i = 0 ; i < topLevelItemCount(); i++ )
402     {
403         QTreeWidgetItem *cat_item = topLevelItem( i );
404         if ( clear_filter )
405         {
406             collapseUnselectedItems( cat_item );
407         }
408         else
409         {
410             filterItems( cat_item, text, Qt::CaseInsensitive );
411         }
412     }
413 }
414
415 void PrefsTree::resizeColumns()
416 {
417     resizeColumnToContents( 0 );
418 }
419
420 /* go over the module config items and search text in psz_text
421  * also search the module name and head */
422 bool PrefsItemData::contains( const QString &text, Qt::CaseSensitivity cs )
423 {
424     /* Find our module */
425     module_t *p_module = NULL;
426     if( this->i_type == TYPE_CATEGORY )
427         return false;
428     else if( this->i_type == TYPE_MODULE )
429         p_module = module_find( this->psz_name );
430     else
431     {
432         p_module = module_get_main();
433         assert( p_module );
434     }
435
436     unsigned confsize;
437     module_config_t *const p_config = module_config_get (p_module, &confsize),
438                     *p_item = p_config,
439                     *p_end = p_config + confsize;
440
441     if( this->i_type == TYPE_SUBCATEGORY || this->i_type ==  TYPE_CATSUBCAT )
442     {
443         while ( p_item < p_end )
444         {
445             if( p_item->i_type == CONFIG_SUBCATEGORY &&
446                 (
447                     ( this->i_type == TYPE_SUBCATEGORY &&
448                               p_item->value.i == this->i_object_id )
449                     ||
450                     ( this->i_type == TYPE_CATSUBCAT &&
451                               p_item->value.i == this->i_subcat_id )
452                 )
453               )
454                 break;
455             p_item++;
456         }
457     }
458
459     QString head;
460
461     if( this->i_type == TYPE_SUBCATEGORY || this->i_type ==  TYPE_CATSUBCAT )
462     {
463         head.clear();
464         p_item++; // Why that ? +1
465     }
466     else
467     {
468         head = QString( qtr( module_GetLongName( p_module ) ) );
469     }
470
471     if (name.contains( text, cs ) || head.contains( text, cs ) || help.contains( text, cs ))
472         return true;
473
474     if( p_item ) do
475     {
476         if (
477             (
478                 ( this->i_type == TYPE_SUBCATEGORY && p_item->value.i != this->i_object_id )
479                 ||
480                 ( this->i_type == TYPE_CATSUBCAT && p_item->value.i != this->i_subcat_id )
481             ) &&
482             ( p_item->i_type == CONFIG_CATEGORY || p_item->i_type == CONFIG_SUBCATEGORY )
483            ) break;
484
485         if( p_item->b_internal ) continue;
486
487         if ( p_item->psz_text && qtr( p_item->psz_text ).contains( text, cs ) )
488             return true;
489     }
490     while (
491             !(
492                 ( this->i_type == TYPE_SUBCATEGORY || this->i_type == TYPE_CATSUBCAT )
493                 &&
494                 ( p_item->i_type == CONFIG_CATEGORY || p_item->i_type == CONFIG_SUBCATEGORY )
495              )
496              && ( ++p_item < p_end )
497           );
498
499     return false;
500 }
501
502 /*********************************************************************
503  * The Panel
504  *********************************************************************/
505 AdvPrefsPanel::AdvPrefsPanel( QWidget *_parent ) : QWidget( _parent )
506 {}
507
508 AdvPrefsPanel::AdvPrefsPanel( intf_thread_t *_p_intf, QWidget *_parent,
509                         PrefsItemData * data ) :
510                         QWidget( _parent ), p_intf( _p_intf )
511 {
512     /* Find our module */
513     module_t *p_module = NULL;
514     if( data->i_type == TYPE_CATEGORY )
515         return;
516     else if( data->i_type == TYPE_MODULE )
517         p_module = module_find( data->psz_name );
518     else
519     {
520         p_module = module_get_main();
521         assert( p_module );
522     }
523
524     unsigned confsize;
525     module_config_t *const p_config = module_config_get (p_module, &confsize),
526                     *p_item = p_config,
527                     *p_end = p_config + confsize;
528
529     if( data->i_type == TYPE_SUBCATEGORY || data->i_type ==  TYPE_CATSUBCAT )
530     {
531         while (p_item < p_end)
532         {
533             if(  p_item->i_type == CONFIG_SUBCATEGORY &&
534                             ( ( data->i_type == TYPE_SUBCATEGORY &&
535                               p_item->value.i == data->i_object_id ) ||
536                             ( data->i_type == TYPE_CATSUBCAT &&
537                               p_item->value.i == data->i_subcat_id ) ) )
538                 break;
539             p_item++;
540         }
541     }
542
543     /* Widgets now */
544     global_layout = new QVBoxLayout();
545     global_layout->setMargin( 2 );
546     QString head;
547     QString help;
548
549     help = QString( data->help );
550
551     if( data->i_type == TYPE_SUBCATEGORY || data->i_type ==  TYPE_CATSUBCAT )
552     {
553         head = QString( data->name );
554         p_item++; // Why that ?
555     }
556     else
557     {
558         head = QString( qtr( module_GetLongName( p_module ) ) );
559     }
560
561     QLabel *titleLabel = new QLabel( head );
562     QFont titleFont = QApplication::font();
563     titleFont.setPointSize( titleFont.pointSize() + 6 );
564     titleLabel->setFont( titleFont );
565
566     // Title <hr>
567     QFrame *title_line = new QFrame;
568     title_line->setFrameShape(QFrame::HLine);
569     title_line->setFrameShadow(QFrame::Sunken);
570
571     QLabel *helpLabel = new QLabel( help, this );
572     helpLabel->setWordWrap( true );
573
574     global_layout->addWidget( titleLabel );
575     global_layout->addWidget( title_line );
576     global_layout->addWidget( helpLabel );
577
578     QGroupBox *box = NULL;
579     QGridLayout *boxlayout = NULL;
580
581     QScrollArea *scroller= new QScrollArea;
582     scroller->setFrameStyle( QFrame::NoFrame );
583     QWidget *scrolled_area = new QWidget;
584
585     QGridLayout *layout = new QGridLayout();
586     int i_line = 0, i_boxline = 0;
587     bool has_hotkey = false;
588
589     if( p_item ) do
590     {
591         if( ( ( data->i_type == TYPE_SUBCATEGORY &&
592                 p_item->value.i != data->i_object_id ) ||
593               ( data->i_type == TYPE_CATSUBCAT  &&
594                 p_item->value.i != data->i_subcat_id ) ) &&
595             ( p_item->i_type == CONFIG_CATEGORY ||
596               p_item->i_type == CONFIG_SUBCATEGORY ) )
597             break;
598         if( p_item->b_internal ) continue;
599
600         if( p_item->i_type == CONFIG_SECTION )
601         {
602             if( box )
603             {
604                 box->setLayout( boxlayout );
605                 box->show();
606                 layout->addWidget( box, i_line, 0, 1, -1 );
607                 i_line++;
608             }
609             box = new QGroupBox( qtr( p_item->psz_text ), this );
610             box->hide();
611             boxlayout = new QGridLayout();
612         }
613         /* Only one hotkey control */
614         if( p_item->i_type == CONFIG_ITEM_KEY )
615         {
616             if( has_hotkey )
617                 continue;
618             has_hotkey = true;
619         }
620
621         ConfigControl *control;
622         if( ! box )
623             control = ConfigControl::createControl( VLC_OBJECT( p_intf ),
624                                         p_item, this, layout, i_line );
625         else
626             control = ConfigControl::createControl( VLC_OBJECT( p_intf ),
627                                     p_item, this, boxlayout, i_boxline );
628         if( !control )
629             continue;
630
631         if( box ) i_boxline++;
632         else i_line++;
633         controls.append( control );
634     }
635     while( !( ( data->i_type == TYPE_SUBCATEGORY ||
636                data->i_type == TYPE_CATSUBCAT ) &&
637              ( p_item->i_type == CONFIG_CATEGORY ||
638                p_item->i_type == CONFIG_SUBCATEGORY ) )
639         && ( ++p_item < p_end ) );
640
641     if( box && i_boxline > 0 )
642     {
643         box->setLayout( boxlayout );
644         box->show();
645         layout->addWidget( box, i_line, 0, 1, -1 );
646     }
647
648     scrolled_area->setSizePolicy( QSizePolicy::Preferred,QSizePolicy::Fixed );
649     scrolled_area->setLayout( layout );
650     scroller->setWidget( scrolled_area );
651     scroller->setWidgetResizable( true );
652     global_layout->addWidget( scroller );
653     setLayout( global_layout );
654 }
655
656 void AdvPrefsPanel::apply()
657 {
658     foreach ( ConfigControl *cfg, controls )
659         cfg->doApply();
660 }
661
662 void AdvPrefsPanel::clean()
663 {}
664
665 AdvPrefsPanel::~AdvPrefsPanel()
666 {
667     qDeleteAll( controls ); controls.clear();
668 }
669