string review by Christophe Mutricy aka xtophe
[vlc.git] / modules / gui / skins2 / parser / builder.cpp
1 /*****************************************************************************
2  * builder.cpp
3  *****************************************************************************
4  * Copyright (C) 2003 VideoLAN
5  * $Id: builder.cpp,v 1.4 2004/01/25 17:20:18 kuehne Exp $
6  *
7  * Authors: Cyril Deguet     <asmax@via.ecp.fr>
8  *          Olivier Teulière <ipkiss@via.ecp.fr>
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., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
23  *****************************************************************************/
24
25 #include <string.h>
26 #include "builder.hpp"
27 #include "builder_data.hpp"
28 #include "interpreter.hpp"
29 #include "../src/png_bitmap.hpp"
30 #include "../src/os_factory.hpp"
31 #include "../src/generic_bitmap.hpp"
32 #include "../src/generic_window.hpp"
33 #include "../src/anchor.hpp"
34 #include "../src/ft2_font.hpp"
35 #include "../src/theme.hpp"
36 #include "../controls/ctrl_button.hpp"
37 #include "../controls/ctrl_checkbox.hpp"
38 #include "../controls/ctrl_image.hpp"
39 #include "../controls/ctrl_list.hpp"
40 #include "../controls/ctrl_move.hpp"
41 #include "../controls/ctrl_resize.hpp"
42 #include "../controls/ctrl_slider.hpp"
43 #include "../controls/ctrl_radialslider.hpp"
44 #include "../controls/ctrl_text.hpp"
45 #include "../utils/position.hpp"
46 #include "../utils/var_bool.hpp"
47 #include "../utils/var_text.hpp"
48
49
50 Builder::Builder( intf_thread_t *pIntf, const BuilderData &rData):
51     SkinObject( pIntf ), m_rData( rData ), m_pTheme( NULL )
52 {
53 }
54
55
56 CmdGeneric *Builder::parseAction( const string &rAction )
57 {
58     return Interpreter::instance( getIntf() )->parseAction( rAction, m_pTheme );
59 }
60
61
62 // Useful macro
63 #define ADD_OBJECTS( type ) \
64     list<BuilderData::type>::const_iterator it##type; \
65     for( it##type = m_rData.m_list##type.begin(); \
66          it##type != m_rData.m_list##type.end(); it##type++ ) \
67     { \
68         add##type( *it##type ); \
69     }
70
71
72 Theme *Builder::build()
73 {
74     m_pTheme = new Theme( getIntf() );
75     if( m_pTheme == NULL )
76     {
77         return NULL;
78     }
79
80     // Create everything from the data in the XML
81     ADD_OBJECTS( Theme );
82     ADD_OBJECTS( Bitmap );
83     ADD_OBJECTS( Font );
84     ADD_OBJECTS( Window );
85     ADD_OBJECTS( Layout );
86     ADD_OBJECTS( Anchor );
87     ADD_OBJECTS( Button );
88     ADD_OBJECTS( Checkbox );
89     ADD_OBJECTS( Image );
90     ADD_OBJECTS( Text );
91     ADD_OBJECTS( RadialSlider );
92     ADD_OBJECTS( Slider );
93     ADD_OBJECTS( List );
94
95     return m_pTheme;
96 }
97
98
99 // Macro to get a bitmap by its ID in the builder
100 #define GET_BMP( pBmp, id ) \
101     if( id != "none" ) \
102     { \
103         pBmp = m_pTheme->m_bitmaps[id].get(); \
104         if( pBmp == NULL ) \
105         { \
106             msg_Err( getIntf(), "unknown bitmap id: %s", id.c_str() ); \
107             return; \
108         } \
109     }
110
111 void Builder::addTheme( const BuilderData::Theme &rData )
112 {
113     m_pTheme->getWindowManager().setMagnetValue( rData.m_magnet );
114     m_pTheme->getWindowManager().setAlphaValue( rData.m_alpha );
115     m_pTheme->getWindowManager().setMoveAlphaValue( rData.m_moveAlpha );
116 }
117
118
119 void Builder::addBitmap( const BuilderData::Bitmap &rData )
120 {
121     GenericBitmap *pBmp = new PngBitmap( getIntf(), rData.m_fileName,
122                                          rData.m_alphaColor );
123     m_pTheme->m_bitmaps[rData.m_id] = GenericBitmapPtr( pBmp );
124 }
125
126
127 void Builder::addFont( const BuilderData::Font &rData )
128 {
129     GenericFont *pFont = new FT2Font( getIntf(), rData.m_fontName,
130                                       rData.m_size );
131     pFont->init();
132     m_pTheme->m_fonts[rData.m_id] = GenericFontPtr( pFont );
133 }
134
135
136 void Builder::addWindow( const BuilderData::Window &rData )
137 {
138     // XXX:  font to fix
139     GenericFont *pFont = new FT2Font( getIntf(), "FreeSans.ttf", 12 );
140     pFont->init();
141     GenericWindow *pWin =
142         new GenericWindow( getIntf(), rData.m_xPos, rData.m_yPos,
143                            m_pTheme->getWindowManager(), *pFont,
144                            rData.m_dragDrop, rData.m_playOnDrop );
145
146     m_pTheme->m_windows[uniqueId( rData.m_id) ] = GenericWindowPtr( pWin );
147 }
148
149
150 void Builder::addLayout( const BuilderData::Layout &rData )
151 {
152     GenericWindow *pWin = m_pTheme->m_windows[rData.m_windowId].get();
153     if( pWin == NULL )
154     {
155         msg_Err( getIntf(), "unknown window id: %s", rData.m_windowId.c_str() );
156         return;
157     }
158
159     int minWidth = rData.m_minWidth != -1 ? rData.m_minWidth : rData.m_width;
160     int maxWidth = rData.m_maxWidth != -1 ? rData.m_maxWidth : rData.m_width;
161     int minHeight = rData.m_minHeight != -1 ? rData.m_minHeight :
162                     rData.m_height;
163     int maxHeight = rData.m_maxHeight != -1 ? rData.m_maxHeight :
164                     rData.m_height;
165     GenericLayout *pLayout = new GenericLayout( getIntf(), rData.m_width,
166                                                 rData.m_height,
167                                                 minWidth, maxWidth, minHeight,
168                                                 maxHeight );
169     m_pTheme->m_layouts[uniqueId( rData.m_id) ] = GenericLayoutPtr( pLayout );
170
171     // Attach the layout to its window
172     pWin->setActiveLayout( pLayout );
173 }
174
175
176 void Builder::addAnchor( const BuilderData::Anchor &rData )
177 {
178     GenericWindow *pWin = m_pTheme->m_windows[rData.m_windowId].get();
179     if( pWin == NULL )
180     {
181         msg_Err( getIntf(), "unknown window id: %s", rData.m_windowId.c_str() );
182         return;
183     }
184
185     Anchor *pAnc = new Anchor( getIntf(), rData.m_xPos, rData.m_yPos,
186                                rData.m_range, rData.m_priority, *pWin );
187     pWin->addAnchor( pAnc );
188 }
189
190
191 void Builder::addButton( const BuilderData::Button &rData )
192 {
193     // Get the bitmaps of the button
194     GenericBitmap *pBmpUp = NULL;
195     GET_BMP( pBmpUp, rData.m_upId );
196
197     GenericBitmap *pBmpDown = pBmpUp;
198     GET_BMP( pBmpDown, rData.m_downId );
199
200     GenericBitmap *pBmpOver = pBmpUp;
201     GET_BMP( pBmpOver, rData.m_overId );
202
203     GenericLayout *pLayout = m_pTheme->m_layouts[rData.m_layoutId].get();
204     if( pLayout == NULL )
205     {
206         msg_Err( getIntf(), "unknown layout id: %s", rData.m_layoutId.c_str() );
207         return;
208     }
209
210     CmdGeneric *pCommand = parseAction( rData.m_actionId );
211     if( pCommand == NULL )
212     {
213         msg_Err( getIntf(), "Invalid action: %s", rData.m_actionId.c_str() );
214         return;
215     }
216
217     CtrlButton *pButton = new CtrlButton( getIntf(), *pBmpUp, *pBmpOver,
218         *pBmpDown, *pCommand, UString( getIntf(), rData.m_tooltip.c_str() ),
219         UString( getIntf(), rData.m_help.c_str() ) );
220
221     // Compute the position of the control
222     // XXX (we suppose all the images have the same size...)
223     const Position pos = makePosition( rData.m_leftTop, rData.m_rightBottom,
224                                        rData.m_xPos, rData.m_yPos,
225                                        pBmpUp->getWidth(),
226                                        pBmpUp->getHeight(), *pLayout );
227
228     pLayout->addControl( pButton, pos, rData.m_layer );
229
230     m_pTheme->m_controls[uniqueId( rData.m_id) ] = CtrlGenericPtr( pButton );
231 }
232
233
234 void Builder::addCheckbox( const BuilderData::Checkbox &rData )
235 {
236     // Get the bitmaps of the checkbox
237     GenericBitmap *pBmpUp1 = NULL;
238     GET_BMP( pBmpUp1, rData.m_up1Id );
239
240     GenericBitmap *pBmpDown1 = pBmpUp1;
241     GET_BMP( pBmpDown1, rData.m_down1Id );
242
243     GenericBitmap *pBmpOver1 = pBmpUp1;
244     GET_BMP( pBmpOver1, rData.m_over1Id );
245
246     GenericBitmap *pBmpUp2 = NULL;
247     GET_BMP( pBmpUp2, rData.m_up2Id );
248
249     GenericBitmap *pBmpDown2 = pBmpUp2;
250     GET_BMP( pBmpDown2, rData.m_down2Id );
251
252     GenericBitmap *pBmpOver2 = pBmpUp2;
253     GET_BMP( pBmpOver2, rData.m_over2Id );
254
255     GenericLayout *pLayout = m_pTheme->m_layouts[rData.m_layoutId].get();
256     if( pLayout == NULL )
257     {
258         msg_Err( getIntf(), "unknown layout id: %s", rData.m_layoutId.c_str() );
259         return;
260     }
261
262     CmdGeneric *pCommand1 = parseAction( rData.m_action1 );
263     if( pCommand1 == NULL )
264     {
265         msg_Err( getIntf(), "Invalid action: %s", rData.m_action1.c_str() );
266         return;
267     }
268
269     CmdGeneric *pCommand2 = parseAction( rData.m_action2 );
270     if( pCommand2 == NULL )
271     {
272         msg_Err( getIntf(), "Invalid action: %s", rData.m_action2.c_str() );
273         return;
274     }
275
276     // Get the state variable
277     Interpreter *pInterpreter = Interpreter::instance( getIntf() );
278     VarBool *pVar = pInterpreter->getVarBool( rData.m_state, m_pTheme );
279     if( pVar == NULL )
280     {
281         // TODO: default state
282         return;
283     }
284
285     // Create the control
286     CtrlCheckbox *pCheckbox = new CtrlCheckbox( getIntf(), *pBmpUp1,
287         *pBmpOver1, *pBmpDown1, *pBmpUp2, *pBmpOver2, *pBmpDown2, *pCommand1,
288         *pCommand2, UString( getIntf(), rData.m_tooltip1.c_str() ),
289         UString( getIntf(), rData.m_tooltip2.c_str() ), *pVar,
290         UString( getIntf(), rData.m_help.c_str() ) );
291
292     // Compute the position of the control
293     // XXX (we suppose all the images have the same size...)
294     const Position pos = makePosition( rData.m_leftTop, rData.m_rightBottom,
295                                        rData.m_xPos, rData.m_yPos,
296                                        pBmpUp1->getWidth(),
297                                        pBmpUp1->getHeight(), *pLayout );
298
299     pLayout->addControl( pCheckbox, pos, rData.m_layer );
300
301     m_pTheme->m_controls[uniqueId( rData.m_id) ] = CtrlGenericPtr( pCheckbox );
302 }
303
304
305 void Builder::addImage( const BuilderData::Image &rData )
306 {
307     GenericBitmap *pBmp = NULL;
308     GET_BMP( pBmp, rData.m_bmpId );
309
310     GenericLayout *pLayout = m_pTheme->m_layouts[rData.m_layoutId].get();
311     if( pLayout == NULL )
312     {
313         msg_Err( getIntf(), "unknown layout id: %s", rData.m_layoutId.c_str() );
314         return;
315     }
316
317     GenericWindow *pWindow = m_pTheme->m_windows[rData.m_windowId].get();
318     if( pWindow == NULL )
319     {
320         msg_Err( getIntf(), "unknown window id: %s", rData.m_windowId.c_str() );
321         return;
322     }
323
324     CtrlImage *pImage = new CtrlImage( getIntf(), *pBmp,
325                                 UString( getIntf(), rData.m_help.c_str() ) );
326
327     // Compute the position of the control
328     const Position pos = makePosition( rData.m_leftTop, rData.m_rightBottom,
329                                        rData.m_xPos,
330                                        rData.m_yPos, pBmp->getWidth(),
331                                        pBmp->getHeight(), *pLayout );
332
333     // XXX: test to be changed! XXX
334     if( rData.m_onclickId == "move" )
335     {
336         CtrlMove *pMove = new CtrlMove( getIntf(), m_pTheme->getWindowManager(),
337              *pImage, *pWindow, UString( getIntf(), rData.m_help.c_str() ) );
338         pLayout->addControl( pMove, pos, rData.m_layer );
339     }
340     else if( rData.m_onclickId == "resize" )
341     {
342         CtrlResize *pResize = new CtrlResize( getIntf(), *pImage, *pLayout,
343                 UString( getIntf(), rData.m_help.c_str() ) );
344         pLayout->addControl( pResize, pos, rData.m_layer );
345     }
346     else
347     {
348         pLayout->addControl( pImage, pos, rData.m_layer );
349     }
350
351     m_pTheme->m_controls[uniqueId( rData.m_id) ] = CtrlGenericPtr( pImage );
352 }
353
354
355 void Builder::addText( const BuilderData::Text &rData )
356 {
357     GenericLayout *pLayout = m_pTheme->m_layouts[rData.m_layoutId].get();
358     if( pLayout == NULL )
359     {
360         msg_Err( getIntf(), "unknown layout id: %s", rData.m_layoutId.c_str() );
361         return;
362     }
363
364     GenericFont *pFont = m_pTheme->m_fonts[rData.m_fontId].get();
365     if( pFont == NULL )
366     {
367         msg_Err( getIntf(), "Unknown font id: %s", rData.m_fontId.c_str() );
368         return;
369     }
370
371     // Create a text variable
372     VarText *pVar = new VarText( getIntf() );
373     UString msg( getIntf(), rData.m_text.c_str() );
374     pVar->set( msg );
375     m_pTheme->m_vars.push_back( VariablePtr( pVar ) );
376
377     CtrlText *pText = new CtrlText( getIntf(), *pVar, *pFont,
378             UString( getIntf(), rData.m_help.c_str() ) );
379
380     int height = pFont->getSize();
381
382     pLayout->addControl( pText, Position( rData.m_xPos, rData.m_yPos,
383                                           rData.m_xPos + rData.m_width,
384                                           rData.m_yPos + height, *pLayout ),
385                          rData.m_layer );
386
387     m_pTheme->m_controls[uniqueId( rData.m_id) ] = CtrlGenericPtr( pText );
388 }
389
390
391 void Builder::addRadialSlider( const BuilderData::RadialSlider &rData )
392 {
393     // Get the bitmaps of the slider
394     GenericBitmap *pSeq = NULL;
395     GET_BMP( pSeq, rData.m_sequence );
396
397     GenericLayout *pLayout = m_pTheme->m_layouts[rData.m_layoutId].get();
398     if( pLayout == NULL )
399     {
400         msg_Err( getIntf(), "unknown layout id: %s", rData.m_layoutId.c_str() );
401         return;
402     }
403
404     // Get the variable associated to the slider
405     Interpreter *pInterpreter = Interpreter::instance( getIntf() );
406     VarPercent *pVar = pInterpreter->getVarPercent( rData.m_value, m_pTheme );
407     if( pVar == NULL )
408     {
409         msg_Err( getIntf(), "Unknown slider value: %s", rData.m_value.c_str() );
410         return;
411     }
412
413     // Create the control
414     CtrlRadialSlider *pRadial =
415         new CtrlRadialSlider( getIntf(), *pSeq, rData.m_nbImages, *pVar,
416                               rData.m_minAngle, rData.m_maxAngle,
417                               UString( getIntf(), rData.m_help.c_str() ) );
418
419     // XXX: resizing is not supported
420     // Compute the position of the control
421     const Position pos =
422         makePosition( rData.m_leftTop, rData.m_rightBottom, rData.m_xPos,
423                       rData.m_yPos, pSeq->getWidth(),
424                       pSeq->getHeight() / rData.m_nbImages, *pLayout );
425
426     pLayout->addControl( pRadial, pos, rData.m_layer );
427
428     m_pTheme->m_controls[uniqueId( rData.m_id) ] = CtrlGenericPtr( pRadial );
429 }
430
431
432 void Builder::addSlider( const BuilderData::Slider &rData )
433 {
434     // Get the bitmaps of the slider
435     GenericBitmap *pBmpUp = NULL;
436     GET_BMP( pBmpUp, rData.m_upId );
437
438     GenericBitmap *pBmpDown = pBmpUp;
439     GET_BMP( pBmpDown, rData.m_downId );
440
441     GenericBitmap *pBmpOver = pBmpUp;
442     GET_BMP( pBmpOver, rData.m_overId );
443
444     GenericLayout *pLayout = m_pTheme->m_layouts[rData.m_layoutId].get();
445     if( pLayout == NULL )
446     {
447         msg_Err( getIntf(), "unknown layout id: %s", rData.m_layoutId.c_str() );
448         return;
449     }
450
451     // XXX: memory leak!
452     Bezier *pCurve = getPoints( rData.m_points.c_str() );
453     if( pCurve == NULL )
454     {
455         msg_Err( getIntf(), "Invalid format in tag points=\"%s\"",
456                  rData.m_points.c_str() );
457         return;
458     }
459
460     // Get the visibility variable
461     // XXX check when it is null
462     Interpreter *pInterpreter = Interpreter::instance( getIntf() );
463     VarBool *pVisible = pInterpreter->getVarBool( rData.m_visible, m_pTheme );
464
465     // Get the variable associated to the slider
466     VarPercent *pVar = pInterpreter->getVarPercent( rData.m_value, m_pTheme );
467     if( pVar == NULL )
468     {
469         msg_Err( getIntf(), "Unknown slider value: %s", rData.m_value.c_str() );
470         return;
471     }
472
473     // Create the cursor and background controls
474     CtrlSliderCursor *pCursor = new CtrlSliderCursor( getIntf(), *pBmpUp,
475         *pBmpOver, *pBmpDown, *pCurve, *pVar, pVisible,
476         UString( getIntf(), rData.m_tooltip.c_str() ),
477         UString( getIntf(), rData.m_help.c_str() ) );
478
479     CtrlSliderBg *pBackground = new CtrlSliderBg( getIntf(), *pCursor,
480         *pCurve, *pVar, rData.m_thickness, pVisible,
481         UString( getIntf(), rData.m_help.c_str() ) );
482
483     // Compute the position of the control
484     const Position pos = makePosition( rData.m_leftTop, rData.m_rightBottom,
485                                        rData.m_xPos, rData.m_yPos,
486                                        pCurve->getWidth(), pCurve->getHeight(),
487                                        *pLayout );
488
489     pLayout->addControl( pBackground, pos, rData.m_layer );
490     pLayout->addControl( pCursor, pos, rData.m_layer );
491
492     string newId = uniqueId( rData.m_id );
493     m_pTheme->m_controls[newId] = CtrlGenericPtr( pCursor );
494     m_pTheme->m_controls[newId + "_bg"] = CtrlGenericPtr( pBackground );
495 }
496
497
498 void Builder::addList( const BuilderData::List &rData )
499 {
500     GenericLayout *pLayout = m_pTheme->m_layouts[rData.m_layoutId].get();
501     if( pLayout == NULL )
502     {
503         msg_Err( getIntf(), "unknown layout id: %s", rData.m_layoutId.c_str() );
504         return;
505     }
506
507     GenericFont *pFont = m_pTheme->m_fonts[rData.m_fontId].get();
508     if( pFont == NULL )
509     {
510         msg_Err( getIntf(), "Unknown font id: %s", rData.m_fontId.c_str() );
511         return;
512     }
513
514     // Get the list variable
515     Interpreter *pInterpreter = Interpreter::instance( getIntf() );
516     VarList *pVar = pInterpreter->getVarList( rData.m_var, m_pTheme );
517     if( pVar == NULL )
518     {
519         msg_Err( getIntf(), "No such list variable: %s", rData.m_var.c_str() );
520         return;
521     }
522
523     // Create the list control
524     CtrlList *pList = new CtrlList( getIntf(), *pVar, *pFont,
525        rData.m_fgColor, rData.m_playColor, rData.m_bgColor1,
526        rData.m_bgColor2, rData.m_selColor,
527        UString( getIntf(), rData.m_help.c_str() ) );
528
529     // Compute the position of the control
530     const Position pos = makePosition( rData.m_leftTop, rData.m_rightBottom,
531                                        rData.m_xPos, rData.m_yPos,
532                                        rData.m_width, rData.m_height,
533                                        *pLayout );
534
535     pLayout->addControl( pList, pos, rData.m_layer );
536
537     m_pTheme->m_controls[uniqueId( rData.m_id) ] = CtrlGenericPtr( pList );
538 }
539
540
541 const string Builder::generateId() const
542 {
543     static int i = 1;
544
545     const string base = "_ReservedId_";
546     char genId[base.size() + 4];
547     snprintf( genId, base.size() + 4, "%s%i", base.c_str(), i );
548     i++;
549     return genId;
550 }
551
552
553 const string Builder::uniqueId( const string &id )
554 {
555     string newId;
556
557     if( m_idSet.find( id ) != m_idSet.end() )
558     {
559         // The id was already used
560         if( id != "none" )
561         {
562             msg_Warn( getIntf(), "Non unique id: %s", id.c_str() );
563         }
564         newId = generateId();
565     }
566     else
567     {
568         // OK, this is a new id
569         newId = id;
570     }
571
572     // Add the id to the set
573     m_idSet.insert( newId );
574
575     return newId;
576 }
577
578
579
580 const Position Builder::makePosition( const string &rLeftTop,
581                                       const string &rRightBottom,
582                                       int xPos, int yPos, int width,
583                                       int height, const Box &rBox ) const
584 {
585     int left = 0, top = 0, right = 0, bottom = 0;
586     Position::Ref_t refLeftTop = Position::kLeftTop;
587     Position::Ref_t refRightBottom = Position::kLeftTop;
588
589     int boxWidth = rBox.getWidth();
590     int boxHeight = rBox.getHeight();
591
592     // Position of the left top corner
593     if( rLeftTop == "lefttop" )
594     {
595         left = xPos;
596         top = yPos;
597         refLeftTop = Position::kLeftTop;
598     }
599     else if( rLeftTop == "righttop" )
600     {
601         left = xPos - boxWidth + 1;
602         top = yPos;
603         refLeftTop = Position::kRightTop;
604     }
605     else if( rLeftTop == "leftbottom" )
606     {
607         left = xPos;
608         top = yPos - boxHeight + 1;
609         refLeftTop = Position::kLeftBottom;
610     }
611     else if( rLeftTop == "rightbottom" )
612     {
613         left = xPos - boxWidth + 1;
614         top = yPos - boxHeight + 1;
615         refLeftTop = Position::kRightBottom;
616     }
617
618     // Position of the right bottom corner
619     if( rRightBottom == "lefttop" )
620     {
621         right = xPos + width - 1;
622         bottom = yPos + height - 1;
623         refRightBottom = Position::kLeftTop;
624     }
625     else if( rRightBottom == "righttop" )
626     {
627         right = xPos + width - boxWidth;
628         bottom = yPos + height - 1;
629         refRightBottom = Position::kRightTop;
630     }
631     else if( rRightBottom == "leftbottom" )
632     {
633         right = xPos + width - 1;
634         bottom = yPos + height - boxHeight;
635         refRightBottom = Position::kLeftBottom;
636     }
637     else if( rRightBottom == "rightbottom" )
638     {
639         right = xPos + width - boxWidth;
640         bottom = yPos + height - boxHeight;
641         refRightBottom = Position::kRightBottom;
642     }
643
644     return Position( left, top, right, bottom, rBox, refLeftTop,
645                      refRightBottom );
646 }
647
648
649 Bezier *Builder::getPoints( const char *pTag ) const
650 {
651     vector<float> xBez, yBez;
652     int x, y, n;
653     while( 1 )
654     {
655         if( sscanf( pTag, "(%d,%d)%n", &x, &y, &n ) < 2 )
656         {
657             return NULL;
658         }
659         if( x < 0 || y < 0 )
660         {
661             msg_Err( getIntf(),
662                      "Slider points cannot have negative coordinates!" );
663             return NULL;
664         }
665         xBez.push_back( x );
666         yBez.push_back( y );
667         pTag += n;
668         if( *pTag == '\0' )
669         {
670             break;
671         }
672         if( *(pTag++) != ',' )
673         {
674             return NULL;
675         }
676     }
677
678     // Create the Bezier curve
679     return new Bezier( getIntf(), xBez, yBez );
680 }
681