]> git.sesse.net Git - vlc/blob - modules/gui/macosx/prefs.m
* don't alloc more capacity than necessary
[vlc] / modules / gui / macosx / prefs.m
1 /*****************************************************************************
2  * prefs.m: MacOS X module for vlc
3  *****************************************************************************
4  * Copyright (C) 2002-2006 the VideoLAN team
5  * $Id$
6  *
7  * Authors: Jon Lech Johansen <jon-vl@nanocrew.net>
8  *          Derk-Jan Hartman <hartman at videolan dot org>
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or
13  * (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
23  *****************************************************************************/
24
25 /* VLCPrefs manages the main preferences dialog 
26    the class is related to wxwindows intf, PrefsPanel */
27 /* VLCTreeItem should contain:
28    - the children of the treeitem
29    - the associated prefs widgets
30    - the documentview with all the prefs widgets in it
31    - a saveChanges action
32    - a revertChanges action
33    - an advanced action (to hide/show advanced options)
34    - a redraw view action
35    - the children action should generate a list of the treeitems children (to be used by VLCPrefs datasource)
36
37    The class is sort of a mix of wxwindows intfs, PrefsTreeCtrl and ConfigTreeData
38 */
39 /* VLCConfigControl are subclassed NSView's containing and managing individual config items
40    the classes are VERY closely related to wxwindows ConfigControls */
41
42 /*****************************************************************************
43  * Preamble
44  *****************************************************************************/
45 #include <stdlib.h>                                      /* malloc(), free() */
46 #include <sys/param.h>                                    /* for MAXPATHLEN */
47 #include <string.h>
48
49 #include <vlc/vlc.h>
50 #include <vlc_config_cat.h>
51
52 #include "intf.h"
53 #include "prefs.h"
54 #include "prefs_widgets.h"
55 #include "vlc_keys.h"
56
57 /*****************************************************************************
58  * VLCPrefs implementation
59  *****************************************************************************/
60 @implementation VLCPrefs
61
62 static VLCPrefs *_o_sharedMainInstance = nil;
63
64 + (VLCPrefs *)sharedInstance
65 {
66     return _o_sharedMainInstance ? _o_sharedMainInstance : [[self alloc] init];
67 }
68
69 - (id)init
70 {
71     if( _o_sharedMainInstance ) {
72         [self dealloc];
73     }
74     else
75     {
76         _o_sharedMainInstance = [super init];
77         p_intf = VLCIntf;
78         o_empty_view = [[NSView alloc] init];
79     }
80
81     return _o_sharedMainInstance;
82 }
83
84 - (void)dealloc
85 {
86     [o_empty_view release];
87     [super dealloc];
88 }
89
90 - (void)awakeFromNib
91 {
92     p_intf = VLCIntf;
93     b_advanced = config_GetInt( p_intf, "advanced" );
94
95     [self initStrings];
96     [o_advanced_ckb setState: b_advanced];
97     [o_prefs_view setBorderType: NSGrooveBorder];
98     [o_prefs_view setHasVerticalScroller: YES];
99     [o_prefs_view setDrawsBackground: NO];
100     [o_prefs_view setDocumentView: o_empty_view];
101     [o_tree selectRow:0 byExtendingSelection:NO];
102 }
103
104 - (void)setTitle: (NSString *) o_title_name
105 {
106     [o_title setStringValue: o_title_name];
107 }
108
109 - (void)showPrefs
110 {
111     /* load our nib (if not already loaded) */
112     [NSBundle loadNibNamed:@"Preferences" owner:self];
113
114     [o_prefs_window center];
115     [o_prefs_window makeKeyAndOrderFront:self];
116 }
117
118 - (void)initStrings
119 {
120     [o_prefs_window setTitle: _NS("Preferences")];
121     [o_save_btn setTitle: _NS("Save")];
122     [o_cancel_btn setTitle: _NS("Cancel")];
123     [o_reset_btn setTitle: _NS("Reset All")];
124     [o_advanced_ckb setTitle: _NS("Advanced")];
125 }
126
127 - (IBAction)savePrefs: (id)sender
128 {
129     /* TODO: call savePrefs on Root item */
130     [[VLCTreeItem rootItem] applyChanges];
131     config_SaveConfigFile( p_intf, NULL );
132     [o_prefs_window orderOut:self];
133 }
134
135 - (IBAction)closePrefs: (id)sender
136 {
137     [o_prefs_window orderOut:self];
138 }
139
140 - (IBAction)resetAll: (id)sender
141 {
142     NSBeginInformationalAlertSheet(_NS("Reset Preferences"), _NS("Cancel"),
143         _NS("Continue"), nil, o_prefs_window, self,
144         @selector(sheetDidEnd: returnCode: contextInfo:), NULL, nil,
145         _NS("Beware this will reset the VLC media player preferences.\n"
146             "Are you sure you want to continue?") );
147 }
148
149 - (void)sheetDidEnd:(NSWindow *)o_sheet returnCode:(int)i_return
150     contextInfo:(void *)o_context
151 {
152     if( i_return == NSAlertAlternateReturn )
153     {
154         [o_prefs_view setDocumentView: o_empty_view];
155         config_ResetAll( p_intf );
156         [[VLCTreeItem rootItem] resetView];
157         [[o_tree itemAtRow:[o_tree selectedRow]]
158             showView:o_prefs_view advancedView:
159             ( [o_advanced_ckb state] == NSOnState ) ? VLC_TRUE : VLC_FALSE];
160     }
161 }
162
163 - (IBAction)advancedToggle: (id)sender
164 {
165     b_advanced = !b_advanced;
166     [o_advanced_ckb setState: b_advanced];
167     /* refresh the view of the current treeitem */
168     [[o_tree itemAtRow:[o_tree selectedRow]] showView:o_prefs_view advancedView:
169         ( [o_advanced_ckb state] == NSOnState ) ? VLC_TRUE : VLC_FALSE];
170 }
171
172 - (void)loadConfigTree
173 {
174 }
175
176 - (void)outlineViewSelectionIsChanging:(NSNotification *)o_notification
177 {
178 }
179
180 /* update the document view to the view of the selected tree item */
181 - (void)outlineViewSelectionDidChange:(NSNotification *)o_notification
182 {
183     [[o_tree itemAtRow:[o_tree selectedRow]] showView: o_prefs_view
184         advancedView:( [o_advanced_ckb state] == NSOnState ) ?
185         VLC_TRUE : VLC_FALSE];
186 }
187
188 @end
189
190 @implementation VLCPrefs (NSTableDataSource)
191
192 - (int)outlineView:(NSOutlineView *)outlineView numberOfChildrenOfItem:(id)item {
193     return (item == nil) ? [[VLCTreeItem rootItem] numberOfChildren] :
194                             [item numberOfChildren];
195 }
196
197 - (BOOL)outlineView:(NSOutlineView *)outlineView isItemExpandable:(id)item
198 {
199     return (item == nil) ? YES : ( ([item numberOfChildren] != -1) && 
200                                    ([item numberOfChildren] != 0));
201 }
202
203 - (id)outlineView:(NSOutlineView *)outlineView child:(int)index ofItem:(id)item {
204     return (item == nil) ? [[VLCTreeItem rootItem] childAtIndex:index] :
205                             (id)[item childAtIndex:index];
206 }
207
208 - (id)outlineView:(NSOutlineView *)outlineView
209     objectValueForTableColumn:(NSTableColumn *)tableColumn byItem:(id)item
210 {
211     return (item == nil) ? @"" : (id)[item getName];
212 }
213
214 @end
215
216 @implementation VLCTreeItem
217
218 static VLCTreeItem *o_root_item = nil;
219
220 #define IsALeafNode ((id)-1)
221
222 - (id)initWithName: (NSString *)o_item_name
223     withTitle: (NSString *)o_item_title
224     withHelp: (NSString *)o_item_help
225     ID: (int)i_id
226     parent:(VLCTreeItem *)o_parent_item
227     children:(NSMutableArray *)o_children_array
228     whithCategory: (int) i_category
229 {
230     self = [super init];
231
232     if( self != nil )
233     {
234         o_name = [o_item_name copy];
235         o_title= [o_item_title copy];
236         o_help= [o_item_help copy];
237         i_object_id = i_id;
238         o_parent = o_parent_item;
239         o_children = o_children_array;
240         i_object_category = i_category;
241         o_subviews = nil;
242     }
243     return( self );
244 }
245
246 + (VLCTreeItem *)rootItem
247 {
248    if (o_root_item == nil)
249         o_root_item = [[VLCTreeItem alloc] initWithName:@"main" withTitle:@"main" withHelp:@"" ID:0
250             parent:nil children:[[NSMutableArray alloc] initWithCapacity:10]
251             whithCategory: -1];
252    return o_root_item;
253 }
254
255 - (void)dealloc
256 {
257     if (o_children != IsALeafNode) [o_children release];
258     [o_name release];
259     [o_title release];
260     [o_help release];
261     [super dealloc];
262 }
263
264 /* Creates and returns the array of children
265  * Loads children incrementally */
266 - (NSArray *)children
267 {
268     if( o_children == IsALeafNode )
269         return o_children;
270     if( [ o_children count] == 0 )
271     {
272         intf_thread_t   *p_intf = VLCIntf;
273         vlc_list_t      *p_list;
274         module_t        *p_module = NULL;
275         module_config_t *p_item;
276         int             i_index;
277
278         /* List the modules */
279         p_list = vlc_list_find( p_intf, VLC_OBJECT_MODULE, FIND_ANYWHERE );
280         if( !p_list ) return nil;
281
282         if( [[self getName] isEqualToString: @"main"] )
283         {
284             /*
285             * Find the main module
286             */
287             for( i_index = 0; i_index < p_list->i_count; i_index++ )
288             {
289                 p_module = (module_t *)p_list->p_values[i_index].p_object;
290                 if( !strcmp( p_module->psz_object_name, "main" ) )
291                     break;
292             }
293             if( p_module == NULL )
294             {
295                 msg_Err( p_intf,
296                     "could not load the preferences" );
297                 return nil;
298             }
299             if( i_index < p_list->i_count )
300             {
301                 /* We found the main module */
302                 /* Enumerate config categories and store a reference so we can
303                  * generate their config panel them when it is asked by the user. */
304                 VLCTreeItem *p_last_category = NULL;
305                 p_item = p_module->p_config;
306                 o_children = [[NSMutableArray alloc] initWithCapacity:10];
307                 if( p_item ) do
308                 {
309                     NSString *o_child_name;
310                     NSString *o_child_title;
311                     NSString *o_child_help;
312                     switch( p_item->i_type )
313                     {
314                     case CONFIG_CATEGORY:
315                                     if( p_item->i_value == -1 ) break;
316
317                         o_child_name = [[VLCMain sharedInstance]
318                             localizedString: config_CategoryNameGet( p_item->i_value ) ];
319                         o_child_title = o_child_name;
320                         o_child_help = [[VLCMain sharedInstance]
321                             localizedString: config_CategoryHelpGet( p_item->i_value ) ];
322                         p_last_category = [VLCTreeItem alloc];
323                         [o_children addObject:[p_last_category
324                             initWithName: o_child_name
325                             withTitle: o_child_title
326                             withHelp: o_child_help
327                             ID: p_item->i_value
328                             parent:self
329                             children:[[NSMutableArray alloc]
330                                 initWithCapacity:10]
331                             whithCategory: p_item - p_module->p_config]];
332                         break;
333                     case CONFIG_SUBCATEGORY:
334                                     if( p_item->i_value == -1 ) break;
335
336                         if( p_item->i_value != SUBCAT_PLAYLIST_GENERAL &&
337                             p_item->i_value != SUBCAT_VIDEO_GENERAL &&
338                             p_item->i_value != SUBCAT_INPUT_GENERAL &&
339                             p_item->i_value != SUBCAT_INTERFACE_GENERAL &&
340                             p_item->i_value != SUBCAT_SOUT_GENERAL &&
341                             p_item->i_value != SUBCAT_ADVANCED_MISC &&
342                             p_item->i_value != SUBCAT_AUDIO_GENERAL )
343                         {
344                             o_child_name = [[VLCMain sharedInstance]
345                                 localizedString: config_CategoryNameGet( p_item->i_value ) ];
346                             o_child_title = o_child_name;
347                             o_child_help = [[VLCMain sharedInstance]
348                                 localizedString: config_CategoryHelpGet( p_item->i_value ) ];
349
350                             [p_last_category->o_children
351                                 addObject:[[VLCTreeItem alloc]
352                                 initWithName: o_child_name
353                                 withTitle: o_child_title
354                                 withHelp: o_child_help
355                                 ID: p_item->i_value
356                                 parent:p_last_category
357                                 children:[[NSMutableArray alloc]
358                                     initWithCapacity:10]
359                                 whithCategory: p_item - p_module->p_config]];
360                         }
361                         
362                         break;
363                     default:
364                         break;
365                     }
366                 } while( p_item->i_type != CONFIG_HINT_END && p_item++ );
367             }
368
369             /* Build a tree of the plugins */
370             /* Add the capabilities */
371             for( i_index = 0; i_index < p_list->i_count; i_index++ )
372             {
373                 p_module = (module_t *)p_list->p_values[i_index].p_object;
374
375                 /* Exclude the main module */
376                 if( !strcmp( p_module->psz_object_name, "main" ) )
377                     continue;
378
379                 /* Exclude empty plugins (submodules don't have config */
380                 /* options, they are stored in the parent module) */
381                 if( p_module->b_submodule )
382                     continue;
383                 else
384                     p_item = p_module->p_config;
385
386                 if( !p_item ) continue;
387                 int i_category = -1;
388                 int i_subcategory = -1;
389                 int i_options = 0;
390                 do
391                 {
392                     if( p_item->i_type == CONFIG_CATEGORY )
393                         i_category = p_item->i_value;
394                     else if( p_item->i_type == CONFIG_SUBCATEGORY )
395                         i_subcategory = p_item->i_value;
396
397                     if( p_item->i_type & CONFIG_ITEM )
398                         i_options ++;
399                     if( i_options > 0 && i_category >= 0 && i_subcategory >= 0 )
400                         break;
401                 } while( p_item->i_type != CONFIG_HINT_END && p_item++ );
402                 if( !i_options ) continue;
403
404                 /* Find the right category item */
405
406                 long cookie;
407                 vlc_bool_t b_found = VLC_FALSE;
408                 unsigned int i;
409                 VLCTreeItem* p_category_item, * p_subcategory_item;
410                 for (i = 0 ; i < [o_children count] ; i++)
411                 {
412                     p_category_item = [o_children objectAtIndex: i];
413                     if( p_category_item->i_object_id == i_category )
414                     {
415                         b_found = VLC_TRUE;
416                         break;
417                     }
418                 }
419                 if( !b_found ) continue;
420
421                 /* Find subcategory item */
422                 b_found = VLC_FALSE;
423                 cookie = -1;
424                 for (i = 0 ; i < [p_category_item->o_children count] ; i++)
425                 {
426                     p_subcategory_item = [p_category_item->o_children
427                                             objectAtIndex: i];
428                     if( p_subcategory_item->i_object_id == i_subcategory )
429                     {
430                         b_found = VLC_TRUE;
431                         break;
432                     }
433                 }
434                 if( !b_found )
435                     p_subcategory_item = p_category_item;
436
437                 [p_subcategory_item->o_children addObject:[[VLCTreeItem alloc]
438                     initWithName:[[VLCMain sharedInstance]
439                         localizedString: p_module->psz_shortname ?
440                         p_module->psz_shortname : p_module->psz_object_name ]
441                     withTitle:[[VLCMain sharedInstance]
442                         localizedString: p_module->psz_longname ?
443                         p_module->psz_longname : p_module->psz_object_name ]
444                     withHelp: @""
445                     ID: p_module->i_object_id
446                     parent:p_subcategory_item
447                     children:IsALeafNode
448                     whithCategory: -1]];
449                 }
450         }
451         vlc_list_release( p_list );
452     }
453     return o_children;
454 }
455
456 - (int)getObjectID
457 {
458     return i_object_id;
459 }
460
461 - (NSString *)getName
462 {
463     return o_name;
464 }
465
466 - (NSString *)getTitle
467 {
468     return o_title;
469 }
470
471 - (NSString *)getHelp
472 {
473     return o_help;
474 }
475
476 - (VLCTreeItem *)childAtIndex:(int)i_index
477 {
478     return [[self children] objectAtIndex:i_index];
479 }
480
481 - (int)numberOfChildren {
482     id i_tmp = [self children];
483     return (i_tmp == IsALeafNode) ? (-1) : (int)[i_tmp count];
484 }
485
486 - (BOOL)hasPrefs:(NSString *)o_module_name
487 {
488     intf_thread_t *p_intf = VLCIntf;
489     module_t *p_parser;
490     vlc_list_t *p_list;
491     char *psz_module_name;
492     int i_index;
493
494     psz_module_name = (char *)[o_module_name UTF8String];
495
496     /* look for module */
497     p_list = vlc_list_find( p_intf, VLC_OBJECT_MODULE, FIND_ANYWHERE );
498
499     for( i_index = 0; i_index < p_list->i_count; i_index++ )
500     {
501         p_parser = (module_t *)p_list->p_values[i_index].p_object ;
502
503         if( !strcmp( p_parser->psz_object_name, psz_module_name ) )
504         {
505             BOOL b_has_prefs = p_parser->i_config_items != 0;
506             vlc_list_release( p_list );
507             return( b_has_prefs );
508         }
509     }
510
511     vlc_list_release( p_list );
512
513     return( NO );
514 }
515
516 - (NSView *)showView:(NSScrollView *)o_prefs_view
517     advancedView:(vlc_bool_t) b_advanced
518 {
519     NSRect          s_vrc;
520     NSView          *o_view;
521
522     [[VLCPrefs sharedInstance] setTitle: [self getTitle]];
523     /* NSLog( [self getHelp] ); */ 
524     s_vrc = [[o_prefs_view contentView] bounds]; s_vrc.size.height -= 4;
525     o_view = [[VLCFlippedView alloc] initWithFrame: s_vrc];
526     [o_view setAutoresizingMask: NSViewWidthSizable | NSViewMinYMargin |
527                                     NSViewMaxYMargin];
528
529 /* Create all subviews if it isn't already done because we cannot use */
530 /* setHiden for MacOS < 10.3*/
531     if( o_subviews == nil )
532     {
533         intf_thread_t   *p_intf = VLCIntf;
534         vlc_list_t      *p_list;
535         module_t        *p_parser = NULL;
536         module_config_t *p_item;
537
538         o_subviews = [[NSMutableArray alloc] initWithCapacity:10];
539         /* Get a pointer to the module */
540         if( i_object_category == -1 )
541         {
542             p_parser = (module_t *) vlc_object_get( p_intf, i_object_id );
543             if( !p_parser || p_parser->i_object_type != VLC_OBJECT_MODULE )
544             {
545                 /* 0OOoo something went really bad */
546                 return nil;
547             }
548             p_item = p_parser->p_config;
549             int i = 0;
550
551             p_item = p_parser->p_config + 1;
552
553             do
554             {
555                 if( !p_item )
556                 {
557                     msg_Err( p_intf, "invalid preference item found" );
558                     break;
559                 }
560                 switch(p_item->i_type)
561                 {
562                 case CONFIG_SUBCATEGORY:
563                     break;
564                 case CONFIG_CATEGORY:
565                     break;
566                 case CONFIG_SECTION:
567                     break;
568                 case CONFIG_HINT_END:
569                     break;
570                 case CONFIG_HINT_USAGE:
571                     break;
572                 default:
573                 {
574                     VLCConfigControl *o_control = nil;
575                     o_control = [VLCConfigControl newControl:p_item
576                                                   withView:o_view];
577                     if( o_control != nil )
578                     {
579                         [o_control setAutoresizingMask: NSViewMaxYMargin |
580                             NSViewWidthSizable];
581                         [o_subviews addObject: o_control];
582                     }
583                 }
584                     break;
585                 }
586             } while( p_item++->i_type != CONFIG_HINT_END );
587
588             vlc_object_release( p_parser );
589         }
590         else
591         {
592             int i = 0;
593             int i_index;
594             p_list = vlc_list_find( p_intf, VLC_OBJECT_MODULE, FIND_ANYWHERE );
595             if( !p_list ) return o_view;
596
597             /*
598             * Find the main module
599             */
600             for( i_index = 0; i_index < p_list->i_count; i_index++ )
601             {
602                 p_parser = (module_t *)p_list->p_values[i_index].p_object;
603                 if( !strcmp( p_parser->psz_object_name, "main" ) )
604                     break;
605             }
606             if( p_parser == NULL )
607             {
608                 msg_Err( p_intf, "could not load preferences" );
609                 return o_view;
610             }
611             p_item = (p_parser->p_config + i_object_category);
612             if( ( p_item->i_type == CONFIG_CATEGORY ) &&
613               ( ( p_item->i_value == CAT_PLAYLIST )  ||
614                 ( p_item->i_value == CAT_AUDIO )  ||
615                 ( p_item->i_value == CAT_VIDEO ) ||
616                 ( p_item->i_value == CAT_INTERFACE ) ||
617                 ( p_item->i_value == CAT_INPUT ) ||
618                 ( p_item->i_value == CAT_SOUT ) ) )
619                 p_item++;
620
621             do
622             {
623                 p_item++;
624                 if( !p_item )
625                 {
626                     msg_Err( p_intf, "invalid preference item found" );
627                     break;
628                 }
629                 switch( p_item->i_type )
630                 {
631                 case CONFIG_SUBCATEGORY:
632                     break;
633                 case CONFIG_CATEGORY:
634                     break;
635                 case CONFIG_SECTION:
636                     break;
637                 case CONFIG_HINT_END:
638                     break;
639                 case CONFIG_HINT_USAGE:
640                     break;
641                 default:
642                 {
643                     VLCConfigControl *o_control = nil;
644                     o_control = [VLCConfigControl newControl:p_item
645                                                   withView:o_view];
646                     if( o_control != nil )
647                     {
648                         [o_control setAutoresizingMask: NSViewMaxYMargin |
649                                                         NSViewWidthSizable];
650                         [o_subviews addObject: o_control];
651                     }
652                     break;
653                 }
654                 }
655             } while ( ( p_item->i_type != CONFIG_HINT_END ) &&
656                       ( p_item->i_type != CONFIG_SUBCATEGORY ) );
657
658             vlc_list_release( p_list );
659         }
660     }
661
662     if( o_view != nil )
663     {
664         int i_lastItem = 0;
665         int i_yPos = -2;
666         int i_max_label = 0;
667         int i_show_advanced = 0;
668
669         NSEnumerator *enumerator = [o_subviews objectEnumerator];
670         VLCConfigControl *o_widget;
671         NSRect o_frame;
672         
673         while( ( o_widget = [enumerator nextObject] ) )
674             if( ( [o_widget isAdvanced] ) && (! b_advanced) )
675                 continue;
676             else if( i_max_label < [o_widget getLabelSize] )
677                 i_max_label = [o_widget getLabelSize];
678
679         enumerator = [o_subviews objectEnumerator];
680         while( ( o_widget = [enumerator nextObject] ) )
681         {
682             int i_widget;
683             if( ( [o_widget isAdvanced] ) && (! b_advanced) )
684             {
685                 i_show_advanced++;
686                 continue;
687             }
688
689             i_widget = [o_widget getViewType];
690             i_yPos += [VLCConfigControl calcVerticalMargin:i_widget
691                 lastItem:i_lastItem];
692             [o_widget setYPos:i_yPos];
693             o_frame = [o_widget frame];
694             o_frame.size.width = [o_view frame].size.width -
695                                     LEFTMARGIN - RIGHTMARGIN;
696             [o_widget setFrame:o_frame];
697             [o_widget alignWithXPosition: i_max_label];
698             i_yPos += [o_widget frame].size.height;
699             i_lastItem = i_widget;
700             [o_view addSubview:o_widget];
701          }
702         if( i_show_advanced != 0 )
703         {
704             /* We add the advanced notice... */
705             NSRect s_rc = [o_view frame];
706             NSTextField *o_label;
707             s_rc.size.height = 17;
708             s_rc.origin.x = LEFTMARGIN;
709             s_rc.origin.y = i_yPos += [VLCConfigControl
710                                         calcVerticalMargin:CONFIG_ITEM_STRING
711                                         lastItem:i_lastItem];
712             o_label = [[[NSTextField alloc] initWithFrame: s_rc] retain];
713             [o_label setDrawsBackground: NO];
714             [o_label setBordered: NO];
715             [o_label setEditable: NO];
716             [o_label setSelectable: NO];
717             [o_label setStringValue: _NS("Some options are hidden. " \
718                                 "Check \"Advanced\" to display them.")];
719             [o_label setFont:[NSFont systemFontOfSize:10]];
720             [o_label sizeToFit];
721             [o_view addSubview:o_label];
722             i_yPos += [o_label frame].size.height;
723         }
724         o_frame = [o_view frame];
725         o_frame.size.height = i_yPos;
726         [o_view setFrame:o_frame];
727         [o_prefs_view setDocumentView:o_view];
728
729     }
730     return o_view;
731 }
732
733 - (void)applyChanges
734 {
735     unsigned int i;
736     if( o_subviews != nil )
737         //Item has been shown
738         for( i = 0 ; i < [o_subviews count] ; i++ )
739             [[o_subviews objectAtIndex:i] applyChanges];
740
741     if( o_children != IsALeafNode )
742         for( i = 0 ; i < [o_children count] ; i++ )
743             [[o_children objectAtIndex:i] applyChanges];
744 }
745
746 - (void)resetView
747 {
748     unsigned int i;
749     if( o_subviews != nil )
750     {
751         //Item has been shown
752         [o_subviews release];
753         o_subviews = nil;
754     }
755
756     if( o_children != IsALeafNode )
757         for( i = 0 ; i < [o_children count] ; i++ )
758             [[o_children objectAtIndex:i] resetView];
759 }
760
761 @end
762
763
764 @implementation VLCFlippedView
765
766 - (BOOL)isFlipped
767 {
768     return( YES );
769 }
770
771 @end