git.sesse.net Git - vlc/blob - modules/gui/skins2/parser/builder.cpp

   1 /*****************************************************************************
   2  * builder.cpp
   3  *****************************************************************************
   4  * Copyright (C) 2003 VideoLAN
   5  * $Id$
   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/top_window.hpp"
  33 #include "../src/anchor.hpp"
  34 #include "../src/bitmap_font.hpp"
  35 #include "../src/ft2_font.hpp"
  36 #include "../src/theme.hpp"
  37 #include "../controls/ctrl_button.hpp"
  38 #include "../controls/ctrl_checkbox.hpp"
  39 #include "../controls/ctrl_image.hpp"
  40 #include "../controls/ctrl_list.hpp"
  41 #include "../controls/ctrl_move.hpp"
  42 #include "../controls/ctrl_resize.hpp"
  43 #include "../controls/ctrl_slider.hpp"
  44 #include "../controls/ctrl_radialslider.hpp"
  45 #include "../controls/ctrl_text.hpp"
  46 #include "../controls/ctrl_video.hpp"
  47 #include "../utils/position.hpp"
  48 #include "../utils/var_bool.hpp"
  49 #include "../utils/var_text.hpp"
  50
  51 #include "vlc_image.h"
  52
  53
  54 Builder::Builder( intf_thread_t *pIntf, const BuilderData &rData ):
  55     SkinObject( pIntf ), m_rData( rData ), m_pTheme( NULL )
  56 {
  57     m_pImageHandler = image_HandlerCreate( pIntf );
  58 }
  59
  60 Builder::~Builder()
  61 {
  62     if( m_pImageHandler ) image_HandlerDelete( m_pImageHandler );
  63 }
  64
  65 CmdGeneric *Builder::parseAction( const string &rAction )
  66 {
  67     return Interpreter::instance( getIntf() )->parseAction( rAction, m_pTheme );
  68 }
  69
  70
  71 // Useful macro
  72 #define ADD_OBJECTS( type ) \
  73     list<BuilderData::type>::const_iterator it##type; \
  74     for( it##type = m_rData.m_list##type.begin(); \
  75          it##type != m_rData.m_list##type.end(); it##type++ ) \
  76     { \
  77         add##type( *it##type ); \
  78     }
  79
  80
  81 Theme *Builder::build()
  82 {
  83     m_pTheme = new Theme( getIntf() );
  84     if( m_pTheme == NULL )
  85     {
  86         return NULL;
  87     }
  88
  89     // Create everything from the data in the XML
  90     ADD_OBJECTS( Theme );
  91     ADD_OBJECTS( Bitmap );
  92     ADD_OBJECTS( BitmapFont );
  93     ADD_OBJECTS( Font );
  94     ADD_OBJECTS( Window );
  95     ADD_OBJECTS( Layout );
  96     ADD_OBJECTS( Anchor );
  97     ADD_OBJECTS( Button );
  98     ADD_OBJECTS( Checkbox );
  99     ADD_OBJECTS( Image );
 100     ADD_OBJECTS( Text );
 101     ADD_OBJECTS( RadialSlider );
 102     ADD_OBJECTS( Slider );
 103     ADD_OBJECTS( List );
 104     ADD_OBJECTS( Video );
 105
 106     return m_pTheme;
 107 }
 108
 109
 110 // Macro to get a bitmap by its ID in the builder
 111 #define GET_BMP( pBmp, id ) \
 112     if( id != "none" ) \
 113     { \
 114         pBmp = m_pTheme->getBitmapById(id); \
 115         if( pBmp == NULL ) \
 116         { \
 117             msg_Err( getIntf(), "unknown bitmap id: %s", id.c_str() ); \
 118             return; \
 119         } \
 120     }
 121
 122 void Builder::addTheme( const BuilderData::Theme &rData )
 123 {
 124     WindowManager &rManager = m_pTheme->getWindowManager();
 125     rManager.setMagnetValue( rData.m_magnet );
 126     rManager.setAlphaValue( rData.m_alpha );
 127     rManager.setMoveAlphaValue( rData.m_moveAlpha );
 128     GenericFont *pFont = getFont( rData.m_tooltipfont );
 129     if( pFont )
 130     {
 131         rManager.createTooltip( *pFont );
 132     }
 133     else
 134     {
 135         msg_Warn( getIntf(), "Invalid tooltip font: %s",
 136                   rData.m_tooltipfont.c_str() );
 137     }
 138 }
 139
 140
 141 void Builder::addBitmap( const BuilderData::Bitmap &rData )
 142 {
 143     GenericBitmap *pBmp =
 144         new PngBitmap( getIntf(), m_pImageHandler,
 145                        rData.m_fileName, rData.m_alphaColor );
 146     m_pTheme->m_bitmaps[rData.m_id] = GenericBitmapPtr( pBmp );
 147 }
 148
 149
 150 void Builder::addBitmapFont( const BuilderData::BitmapFont &rData )
 151 {
 152     GenericBitmap *pBmp =
 153         new PngBitmap( getIntf(), m_pImageHandler, rData.m_file, 0 );
 154     m_pTheme->m_bitmaps[rData.m_id] = GenericBitmapPtr( pBmp );
 155
 156     GenericFont *pFont = new BitmapFont( getIntf(), *pBmp, rData.m_type );
 157     if( pFont->init() )
 158     {
 159         m_pTheme->m_fonts[rData.m_id] = GenericFontPtr( pFont );
 160     }
 161     else
 162     {
 163         delete pFont;
 164     }
 165 }
 166
 167
 168 void Builder::addFont( const BuilderData::Font &rData )
 169 {
 170     GenericFont *pFont = new FT2Font( getIntf(), rData.m_fontFile,
 171                                       rData.m_size );
 172     if( pFont->init() )
 173     {
 174         m_pTheme->m_fonts[rData.m_id] = GenericFontPtr( pFont );
 175     }
 176     else
 177     {
 178         delete pFont;
 179     }
 180 }
 181
 182
 183 void Builder::addWindow( const BuilderData::Window &rData )
 184 {
 185     TopWindow *pWin =
 186         new TopWindow( getIntf(), rData.m_xPos, rData.m_yPos,
 187                            m_pTheme->getWindowManager(),
 188                            rData.m_dragDrop, rData.m_playOnDrop );
 189
 190     m_pTheme->m_windows[rData.m_id] = TopWindowPtr( pWin );
 191 }
 192
 193
 194 void Builder::addLayout( const BuilderData::Layout &rData )
 195 {
 196     TopWindow *pWin = m_pTheme->getWindowById(rData.m_windowId);
 197     if( pWin == NULL )
 198     {
 199         msg_Err( getIntf(), "unknown window id: %s", rData.m_windowId.c_str() );
 200         return;
 201     }
 202
 203     int minWidth = rData.m_minWidth != -1 ? rData.m_minWidth : rData.m_width;
 204     int maxWidth = rData.m_maxWidth != -1 ? rData.m_maxWidth : rData.m_width;
 205     int minHeight = rData.m_minHeight != -1 ? rData.m_minHeight :
 206                     rData.m_height;
 207     int maxHeight = rData.m_maxHeight != -1 ? rData.m_maxHeight :
 208                     rData.m_height;
 209     GenericLayout *pLayout = new GenericLayout( getIntf(), rData.m_width,
 210                                                 rData.m_height,
 211                                                 minWidth, maxWidth, minHeight,
 212                                                 maxHeight );
 213     m_pTheme->m_layouts[rData.m_id] = GenericLayoutPtr( pLayout );
 214
 215     // Attach the layout to its window
 216     m_pTheme->getWindowManager().addLayout( *pWin, *pLayout );
 217 }
 218
 219
 220 void Builder::addAnchor( const BuilderData::Anchor &rData )
 221 {
 222     GenericLayout *pLayout = m_pTheme->getLayoutById(rData.m_layoutId);
 223     if( pLayout == NULL )
 224     {
 225         msg_Err( getIntf(), "unknown layout id: %s", rData.m_layoutId.c_str() );
 226         return;
 227     }
 228
 229     Bezier *pCurve = getPoints( rData.m_points.c_str() );
 230     if( pCurve == NULL )
 231     {
 232         msg_Err( getIntf(), "Invalid format in tag points=\"%s\"",
 233                  rData.m_points.c_str() );
 234         return;
 235     }
 236     m_pTheme->m_curves.push_back( BezierPtr( pCurve ) );
 237
 238     Anchor *pAnc = new Anchor( getIntf(), rData.m_xPos, rData.m_yPos,
 239                                rData.m_range, rData.m_priority,
 240                                *pCurve, *pLayout );
 241     pLayout->addAnchor( pAnc );
 242 }
 243
 244
 245 void Builder::addButton( const BuilderData::Button &rData )
 246 {
 247     // Get the bitmaps of the button
 248     GenericBitmap *pBmpUp = NULL;
 249     GET_BMP( pBmpUp, rData.m_upId );
 250
 251     GenericBitmap *pBmpDown = pBmpUp;
 252     GET_BMP( pBmpDown, rData.m_downId );
 253
 254     GenericBitmap *pBmpOver = pBmpUp;
 255     GET_BMP( pBmpOver, rData.m_overId );
 256
 257     GenericLayout *pLayout = m_pTheme->getLayoutById(rData.m_layoutId);
 258     if( pLayout == NULL )
 259     {
 260         msg_Err( getIntf(), "unknown layout id: %s", rData.m_layoutId.c_str() );
 261         return;
 262     }
 263
 264     CmdGeneric *pCommand = parseAction( rData.m_actionId );
 265     if( pCommand == NULL )
 266     {
 267         msg_Err( getIntf(), "Invalid action: %s", rData.m_actionId.c_str() );
 268         return;
 269     }
 270
 271     // Get the visibility variable
 272     // XXX check when it is null
 273     Interpreter *pInterpreter = Interpreter::instance( getIntf() );
 274     VarBool *pVisible = pInterpreter->getVarBool( rData.m_visible, m_pTheme );
 275
 276     CtrlButton *pButton = new CtrlButton( getIntf(), *pBmpUp, *pBmpOver,
 277         *pBmpDown, *pCommand, UString( getIntf(), rData.m_tooltip.c_str() ),
 278         UString( getIntf(), rData.m_help.c_str() ), pVisible );
 279
 280     // Compute the position of the control
 281     // XXX (we suppose all the images have the same size...)
 282     const Position pos = makePosition( rData.m_leftTop, rData.m_rightBottom,
 283                                        rData.m_xPos, rData.m_yPos,
 284                                        pBmpUp->getWidth(),
 285                                        pBmpUp->getHeight(), *pLayout );
 286
 287     pLayout->addControl( pButton, pos, rData.m_layer );
 288
 289     m_pTheme->m_controls[rData.m_id] = CtrlGenericPtr( pButton );
 290 }
 291
 292
 293 void Builder::addCheckbox( const BuilderData::Checkbox &rData )
 294 {
 295     // Get the bitmaps of the checkbox
 296     GenericBitmap *pBmpUp1 = NULL;
 297     GET_BMP( pBmpUp1, rData.m_up1Id );
 298
 299     GenericBitmap *pBmpDown1 = pBmpUp1;
 300     GET_BMP( pBmpDown1, rData.m_down1Id );
 301
 302     GenericBitmap *pBmpOver1 = pBmpUp1;
 303     GET_BMP( pBmpOver1, rData.m_over1Id );
 304
 305     GenericBitmap *pBmpUp2 = NULL;
 306     GET_BMP( pBmpUp2, rData.m_up2Id );
 307
 308     GenericBitmap *pBmpDown2 = pBmpUp2;
 309     GET_BMP( pBmpDown2, rData.m_down2Id );
 310
 311     GenericBitmap *pBmpOver2 = pBmpUp2;
 312     GET_BMP( pBmpOver2, rData.m_over2Id );
 313
 314     GenericLayout *pLayout = m_pTheme->getLayoutById(rData.m_layoutId);
 315     if( pLayout == NULL )
 316     {
 317         msg_Err( getIntf(), "unknown layout id: %s", rData.m_layoutId.c_str() );
 318         return;
 319     }
 320
 321     CmdGeneric *pCommand1 = parseAction( rData.m_action1 );
 322     if( pCommand1 == NULL )
 323     {
 324         msg_Err( getIntf(), "Invalid action: %s", rData.m_action1.c_str() );
 325         return;
 326     }
 327
 328     CmdGeneric *pCommand2 = parseAction( rData.m_action2 );
 329     if( pCommand2 == NULL )
 330     {
 331         msg_Err( getIntf(), "Invalid action: %s", rData.m_action2.c_str() );
 332         return;
 333     }
 334
 335     // Get the state variable
 336     Interpreter *pInterpreter = Interpreter::instance( getIntf() );
 337     VarBool *pVar = pInterpreter->getVarBool( rData.m_state, m_pTheme );
 338     if( pVar == NULL )
 339     {
 340         // TODO: default state
 341         return;
 342     }
 343
 344     // Get the visibility variable
 345     // XXX check when it is null
 346     VarBool *pVisible = pInterpreter->getVarBool( rData.m_visible, m_pTheme );
 347
 348     // Create the control
 349     CtrlCheckbox *pCheckbox = new CtrlCheckbox( getIntf(), *pBmpUp1,
 350         *pBmpOver1, *pBmpDown1, *pBmpUp2, *pBmpOver2, *pBmpDown2, *pCommand1,
 351         *pCommand2, UString( getIntf(), rData.m_tooltip1.c_str() ),
 352         UString( getIntf(), rData.m_tooltip2.c_str() ), *pVar,
 353         UString( getIntf(), rData.m_help.c_str() ), pVisible );
 354
 355     // Compute the position of the control
 356     // XXX (we suppose all the images have the same size...)
 357     const Position pos = makePosition( rData.m_leftTop, rData.m_rightBottom,
 358                                        rData.m_xPos, rData.m_yPos,
 359                                        pBmpUp1->getWidth(),
 360                                        pBmpUp1->getHeight(), *pLayout );
 361
 362     pLayout->addControl( pCheckbox, pos, rData.m_layer );
 363
 364     m_pTheme->m_controls[rData.m_id] = CtrlGenericPtr( pCheckbox );
 365 }
 366
 367
 368 void Builder::addImage( const BuilderData::Image &rData )
 369 {
 370     GenericBitmap *pBmp = NULL;
 371     GET_BMP( pBmp, rData.m_bmpId );
 372
 373     GenericLayout *pLayout = m_pTheme->getLayoutById(rData.m_layoutId);
 374     if( pLayout == NULL )
 375     {
 376         msg_Err( getIntf(), "unknown layout id: %s", rData.m_layoutId.c_str() );
 377         return;
 378     }
 379
 380     TopWindow *pWindow = m_pTheme->getWindowById(rData.m_windowId);
 381     if( pWindow == NULL )
 382     {
 383         msg_Err( getIntf(), "unknown window id: %s", rData.m_windowId.c_str() );
 384         return;
 385     }
 386
 387     // Get the visibility variable
 388     // XXX check when it is null
 389     Interpreter *pInterpreter = Interpreter::instance( getIntf() );
 390     VarBool *pVisible = pInterpreter->getVarBool( rData.m_visible, m_pTheme );
 391
 392     CtrlImage::resize_t resizeMethod =
 393         (rData.m_resize == "scale" ? CtrlImage::kScale : CtrlImage::kMosaic);
 394     CtrlImage *pImage = new CtrlImage( getIntf(), *pBmp, resizeMethod,
 395         UString( getIntf(), rData.m_help.c_str() ), pVisible );
 396
 397     // Compute the position of the control
 398     const Position pos = makePosition( rData.m_leftTop, rData.m_rightBottom,
 399                                        rData.m_xPos,
 400                                        rData.m_yPos, pBmp->getWidth(),
 401                                        pBmp->getHeight(), *pLayout );
 402
 403     // XXX: test to be changed! XXX
 404     if( rData.m_actionId == "move" )
 405     {
 406         CtrlMove *pMove = new CtrlMove( getIntf(), m_pTheme->getWindowManager(),
 407              *pImage, *pWindow, UString( getIntf(), rData.m_help.c_str() ),
 408              NULL);
 409         pLayout->addControl( pMove, pos, rData.m_layer );
 410     }
 411     else if( rData.m_actionId == "resizeSE" )
 412     {
 413         CtrlResize *pResize = new CtrlResize( getIntf(), *pImage, *pLayout,
 414                 UString( getIntf(), rData.m_help.c_str() ), NULL );
 415         pLayout->addControl( pResize, pos, rData.m_layer );
 416     }
 417     else
 418     {
 419         pLayout->addControl( pImage, pos, rData.m_layer );
 420     }
 421
 422     m_pTheme->m_controls[rData.m_id] = CtrlGenericPtr( pImage );
 423 }
 424
 425
 426 void Builder::addText( const BuilderData::Text &rData )
 427 {
 428     GenericLayout *pLayout = m_pTheme->getLayoutById(rData.m_layoutId);
 429     if( pLayout == NULL )
 430     {
 431         msg_Err( getIntf(), "unknown layout id: %s", rData.m_layoutId.c_str() );
 432         return;
 433     }
 434
 435     GenericFont *pFont = getFont( rData.m_fontId );
 436     if( pFont == NULL )
 437     {
 438         msg_Err( getIntf(), "Unknown font id: %s", rData.m_fontId.c_str() );
 439         return;
 440     }
 441
 442     // Create a text variable
 443     VarText *pVar = new VarText( getIntf() );
 444     UString msg( getIntf(), rData.m_text.c_str() );
 445     pVar->set( msg );
 446     m_pTheme->m_vars.push_back( VariablePtr( pVar ) );
 447
 448     // Get the visibility variable
 449     // XXX check when it is null
 450     Interpreter *pInterpreter = Interpreter::instance( getIntf() );
 451     VarBool *pVisible = pInterpreter->getVarBool( rData.m_visible, m_pTheme );
 452
 453     CtrlText *pText = new CtrlText( getIntf(), *pVar, *pFont,
 454         UString( getIntf(), rData.m_help.c_str() ), rData.m_color, pVisible );
 455
 456     int height = pFont->getSize();
 457
 458     // Compute the position of the control
 459     const Position pos = makePosition( rData.m_leftTop, rData.m_rightBottom,
 460                                        rData.m_xPos, rData.m_yPos,
 461                                        rData.m_width, height,
 462                                        *pLayout );
 463
 464     pLayout->addControl( pText, pos, rData.m_layer );
 465
 466     m_pTheme->m_controls[rData.m_id] = CtrlGenericPtr( pText );
 467 }
 468
 469
 470 void Builder::addRadialSlider( const BuilderData::RadialSlider &rData )
 471 {
 472     // Get the bitmaps of the slider
 473     GenericBitmap *pSeq = NULL;
 474     GET_BMP( pSeq, rData.m_sequence );
 475
 476     GenericLayout *pLayout = m_pTheme->getLayoutById(rData.m_layoutId);
 477     if( pLayout == NULL )
 478     {
 479         msg_Err( getIntf(), "unknown layout id: %s", rData.m_layoutId.c_str() );
 480         return;
 481     }
 482
 483     // Get the variable associated to the slider
 484     Interpreter *pInterpreter = Interpreter::instance( getIntf() );
 485     VarPercent *pVar = pInterpreter->getVarPercent( rData.m_value, m_pTheme );
 486     if( pVar == NULL )
 487     {
 488         msg_Err( getIntf(), "Unknown slider value: %s", rData.m_value.c_str() );
 489         return;
 490     }
 491
 492     // Get the visibility variable
 493     // XXX check when it is null
 494     VarBool *pVisible = pInterpreter->getVarBool( rData.m_visible, m_pTheme );
 495
 496     // Create the control
 497     CtrlRadialSlider *pRadial =
 498         new CtrlRadialSlider( getIntf(), *pSeq, rData.m_nbImages, *pVar,
 499                               rData.m_minAngle, rData.m_maxAngle,
 500                               UString( getIntf(), rData.m_help.c_str() ),
 501                               pVisible );
 502
 503     // XXX: resizing is not supported
 504     // Compute the position of the control
 505     const Position pos =
 506         makePosition( rData.m_leftTop, rData.m_rightBottom, rData.m_xPos,
 507                       rData.m_yPos, pSeq->getWidth(),
 508                       pSeq->getHeight() / rData.m_nbImages, *pLayout );
 509
 510     pLayout->addControl( pRadial, pos, rData.m_layer );
 511
 512     m_pTheme->m_controls[rData.m_id] = CtrlGenericPtr( pRadial );
 513 }
 514
 515
 516 void Builder::addSlider( const BuilderData::Slider &rData )
 517 {
 518     // Get the bitmaps of the slider
 519     GenericBitmap *pBmpUp = NULL;
 520     GET_BMP( pBmpUp, rData.m_upId );
 521
 522     GenericBitmap *pBmpDown = pBmpUp;
 523     GET_BMP( pBmpDown, rData.m_downId );
 524
 525     GenericBitmap *pBmpOver = pBmpUp;
 526     GET_BMP( pBmpOver, rData.m_overId );
 527
 528     GenericLayout *pLayout = m_pTheme->getLayoutById(rData.m_layoutId);
 529     if( pLayout == NULL )
 530     {
 531         msg_Err( getIntf(), "unknown layout id: %s", rData.m_layoutId.c_str() );
 532         return;
 533     }
 534
 535     Bezier *pCurve = getPoints( rData.m_points.c_str() );
 536     if( pCurve == NULL )
 537     {
 538         msg_Err( getIntf(), "Invalid format in tag points=\"%s\"",
 539                  rData.m_points.c_str() );
 540         return;
 541     }
 542     m_pTheme->m_curves.push_back( BezierPtr( pCurve ) );
 543
 544     // Get the visibility variable
 545     // XXX check when it is null
 546     Interpreter *pInterpreter = Interpreter::instance( getIntf() );
 547     VarBool *pVisible = pInterpreter->getVarBool( rData.m_visible, m_pTheme );
 548
 549     // Get the variable associated to the slider
 550     VarPercent *pVar = pInterpreter->getVarPercent( rData.m_value, m_pTheme );
 551     if( pVar == NULL )
 552     {
 553         msg_Err( getIntf(), "Unknown slider value: %s", rData.m_value.c_str() );
 554         return;
 555     }
 556
 557     // Create the cursor and background controls
 558     CtrlSliderCursor *pCursor = new CtrlSliderCursor( getIntf(), *pBmpUp,
 559         *pBmpOver, *pBmpDown, *pCurve, *pVar, pVisible,
 560         UString( getIntf(), rData.m_tooltip.c_str() ),
 561         UString( getIntf(), rData.m_help.c_str() ) );
 562
 563     CtrlSliderBg *pBackground = new CtrlSliderBg( getIntf(), *pCursor,
 564         *pCurve, *pVar, rData.m_thickness, pVisible,
 565         UString( getIntf(), rData.m_help.c_str() ) );
 566
 567     // Compute the position of the control
 568     const Position pos = makePosition( rData.m_leftTop, rData.m_rightBottom,
 569                                        rData.m_xPos, rData.m_yPos,
 570                                        pCurve->getWidth(), pCurve->getHeight(),
 571                                        *pLayout );
 572
 573     pLayout->addControl( pBackground, pos, rData.m_layer );
 574     pLayout->addControl( pCursor, pos, rData.m_layer );
 575
 576     m_pTheme->m_controls[rData.m_id] = CtrlGenericPtr( pCursor );
 577     m_pTheme->m_controls[rData.m_id + "_bg"] = CtrlGenericPtr( pBackground );
 578 }
 579
 580
 581 void Builder::addList( const BuilderData::List &rData )
 582 {
 583     // Get the background bitmap, if any
 584     GenericBitmap *pBgBmp = NULL;
 585     GET_BMP( pBgBmp, rData.m_bgImageId );
 586
 587     GenericLayout *pLayout = m_pTheme->getLayoutById(rData.m_layoutId);
 588     if( pLayout == NULL )
 589     {
 590         msg_Err( getIntf(), "unknown layout id: %s", rData.m_layoutId.c_str() );
 591         return;
 592     }
 593
 594     GenericFont *pFont = getFont( rData.m_fontId );
 595     if( pFont == NULL )
 596     {
 597         msg_Err( getIntf(), "Unknown font id: %s", rData.m_fontId.c_str() );
 598         return;
 599     }
 600
 601     // Get the list variable
 602     Interpreter *pInterpreter = Interpreter::instance( getIntf() );
 603     VarList *pVar = pInterpreter->getVarList( rData.m_var, m_pTheme );
 604     if( pVar == NULL )
 605     {
 606         msg_Err( getIntf(), "No such list variable: %s", rData.m_var.c_str() );
 607         return;
 608     }
 609
 610     // Get the visibility variable
 611     // XXX check when it is null
 612     VarBool *pVisible = pInterpreter->getVarBool( rData.m_visible, m_pTheme );
 613
 614     // Create the list control
 615     CtrlList *pList = new CtrlList( getIntf(), *pVar, *pFont, pBgBmp,
 616        rData.m_fgColor, rData.m_playColor, rData.m_bgColor1,
 617        rData.m_bgColor2, rData.m_selColor,
 618        UString( getIntf(), rData.m_help.c_str() ), pVisible );
 619
 620     // Compute the position of the control
 621     const Position pos = makePosition( rData.m_leftTop, rData.m_rightBottom,
 622                                        rData.m_xPos, rData.m_yPos,
 623                                        rData.m_width, rData.m_height,
 624                                        *pLayout );
 625
 626     pLayout->addControl( pList, pos, rData.m_layer );
 627
 628     m_pTheme->m_controls[rData.m_id] = CtrlGenericPtr( pList );
 629 }
 630
 631
 632 void Builder::addVideo( const BuilderData::Video &rData )
 633 {
 634     GenericLayout *pLayout = m_pTheme->getLayoutById(rData.m_layoutId);
 635     if( pLayout == NULL )
 636     {
 637         msg_Err( getIntf(), "unknown layout id: %s", rData.m_layoutId.c_str() );
 638         return;
 639     }
 640
 641     // Get the visibility variable
 642     // XXX check when it is null
 643     Interpreter *pInterpreter = Interpreter::instance( getIntf() );
 644     VarBool *pVisible = pInterpreter->getVarBool( rData.m_visible, m_pTheme );
 645
 646     CtrlVideo *pVideo = new CtrlVideo( getIntf(),
 647         UString( getIntf(), rData.m_help.c_str() ), pVisible );
 648
 649     // Compute the position of the control
 650     const Position pos = makePosition( rData.m_leftTop, rData.m_rightBottom,
 651                                        rData.m_xPos, rData.m_yPos,
 652                                        rData.m_width, rData.m_height,
 653                                        *pLayout );
 654
 655     pLayout->addControl( pVideo, pos, rData.m_layer );
 656
 657     m_pTheme->m_controls[rData.m_id] = CtrlGenericPtr( pVideo );
 658 }
 659
 660
 661 const Position Builder::makePosition( const string &rLeftTop,
 662                                       const string &rRightBottom,
 663                                       int xPos, int yPos, int width,
 664                                       int height, const Box &rBox ) const
 665 {
 666     int left = 0, top = 0, right = 0, bottom = 0;
 667     Position::Ref_t refLeftTop = Position::kLeftTop;
 668     Position::Ref_t refRightBottom = Position::kLeftTop;
 669
 670     int boxWidth = rBox.getWidth();
 671     int boxHeight = rBox.getHeight();
 672
 673     // Position of the left top corner
 674     if( rLeftTop == "lefttop" )
 675     {
 676         left = xPos;
 677         top = yPos;
 678         refLeftTop = Position::kLeftTop;
 679     }
 680     else if( rLeftTop == "righttop" )
 681     {
 682         left = xPos - boxWidth + 1;
 683         top = yPos;
 684         refLeftTop = Position::kRightTop;
 685     }
 686     else if( rLeftTop == "leftbottom" )
 687     {
 688         left = xPos;
 689         top = yPos - boxHeight + 1;
 690         refLeftTop = Position::kLeftBottom;
 691     }
 692     else if( rLeftTop == "rightbottom" )
 693     {
 694         left = xPos - boxWidth + 1;
 695         top = yPos - boxHeight + 1;
 696         refLeftTop = Position::kRightBottom;
 697     }
 698
 699     // Position of the right bottom corner
 700     if( rRightBottom == "lefttop" )
 701     {
 702         right = xPos + width - 1;
 703         bottom = yPos + height - 1;
 704         refRightBottom = Position::kLeftTop;
 705     }
 706     else if( rRightBottom == "righttop" )
 707     {
 708         right = xPos + width - boxWidth;
 709         bottom = yPos + height - 1;
 710         refRightBottom = Position::kRightTop;
 711     }
 712     else if( rRightBottom == "leftbottom" )
 713     {
 714         right = xPos + width - 1;
 715         bottom = yPos + height - boxHeight;
 716         refRightBottom = Position::kLeftBottom;
 717     }
 718     else if( rRightBottom == "rightbottom" )
 719     {
 720         right = xPos + width - boxWidth;
 721         bottom = yPos + height - boxHeight;
 722         refRightBottom = Position::kRightBottom;
 723     }
 724
 725     return Position( left, top, right, bottom, rBox, refLeftTop,
 726                      refRightBottom );
 727 }
 728
 729
 730 GenericFont *Builder::getFont( const string &fontId )
 731 {
 732     GenericFont *pFont = m_pTheme->getFontById(fontId);
 733     if( !pFont && fontId == "defaultfont" )
 734     {
 735         // Get the resource path and try to load the default font
 736         OSFactory *pOSFactory = OSFactory::instance( getIntf() );
 737         const list<string> &resPath = pOSFactory->getResourcePath();
 738         const string &sep = pOSFactory->getDirSeparator();
 739
 740         list<string>::const_iterator it;
 741         for( it = resPath.begin(); it != resPath.end(); it++ )
 742         {
 743             string path = (*it) + sep + "fonts" + sep + "FreeSans.ttf";
 744             pFont = new FT2Font( getIntf(), path, 12 );
 745             if( pFont->init() )
 746             {
 747                 // Font loaded successfully
 748                 m_pTheme->m_fonts["defaultfont"] = GenericFontPtr( pFont );
 749                 break;
 750             }
 751             else
 752             {
 753                 delete pFont;
 754                 pFont = NULL;
 755             }
 756         }
 757         if( !pFont )
 758         {
 759             msg_Err( getIntf(), "Failed to open the default font" );
 760         }
 761     }
 762     return pFont;
 763 }
 764
 765
 766 Bezier *Builder::getPoints( const char *pTag ) const
 767 {
 768     vector<float> xBez, yBez;
 769     int x, y, n;
 770     while( 1 )
 771     {
 772         if( sscanf( pTag, "(%d,%d)%n", &x, &y, &n ) < 1 )
 773         {
 774             return NULL;
 775         }
 776 #if 0
 777         if( x < 0 || y < 0 )
 778         {
 779             msg_Err( getIntf(),
 780                      "Slider points cannot have negative coordinates!" );
 781             return NULL;
 782         }
 783 #endif
 784         xBez.push_back( x );
 785         yBez.push_back( y );
 786         pTag += n;
 787         if( *pTag == '\0' )
 788         {
 789             break;
 790         }
 791         if( *(pTag++) != ',' )
 792         {
 793             return NULL;
 794         }
 795     }
 796
 797     // Create the Bezier curve
 798     return new Bezier( getIntf(), xBez, yBez );
 799 }
 800