modules/gui/skins2/src/generic_layout.cpp

   1 /*****************************************************************************
   2  * generic_layout.cpp
   3  *****************************************************************************
   4  * Copyright (C) 2003 the VideoLAN team
   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., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  23  *****************************************************************************/
  24
  25 #include "generic_layout.hpp"
  26 #include "top_window.hpp"
  27 #include "os_factory.hpp"
  28 #include "os_graphics.hpp"
  29 #include "var_manager.hpp"
  30 #include "anchor.hpp"
  31 #include "../controls/ctrl_generic.hpp"
  32 #include "../controls/ctrl_video.hpp"
  33 #include "../utils/var_bool.hpp"
  34 #include <set>
  35
  36
  37 GenericLayout::GenericLayout( intf_thread_t *pIntf, int width, int height,
  38                               int minWidth, int maxWidth, int minHeight,
  39                               int maxHeight ):
  40     SkinObject( pIntf ), m_pWindow( NULL ),
  41     m_original_width( width ), m_original_height( height ),
  42     m_rect( 0, 0, width, height ),
  43     m_minWidth( minWidth ), m_maxWidth( maxWidth ),
  44     m_minHeight( minHeight ), m_maxHeight( maxHeight ), m_pVideoCtrlSet(),
  45     m_visible( false ), m_pVarActive( NULL )
  46 {
  47     // Get the OSFactory
  48     OSFactory *pOsFactory = OSFactory::instance( getIntf() );
  49     // Create the graphics buffer
  50     m_pImage = pOsFactory->createOSGraphics( width, height );
  51
  52     // Create the "active layout" variable and register it in the manager
  53     m_pVarActive = new VarBoolImpl( pIntf );
  54     VarManager::instance( pIntf )->registerVar( VariablePtr( m_pVarActive ) );
  55 }
  56
  57
  58 GenericLayout::~GenericLayout()
  59 {
  60     delete m_pImage;
  61
  62     list<Anchor*>::const_iterator it;
  63     for( it = m_anchorList.begin(); it != m_anchorList.end(); ++it )
  64     {
  65         delete *it;
  66     }
  67
  68     list<LayeredControl>::const_iterator iter;
  69     for( iter = m_controlList.begin(); iter != m_controlList.end(); ++iter )
  70     {
  71         CtrlGeneric *pCtrl = (*iter).m_pControl;
  72         pCtrl->unsetLayout();
  73     }
  74
  75 }
  76
  77
  78 void GenericLayout::setWindow( TopWindow *pWindow )
  79 {
  80     m_pWindow = pWindow;
  81 }
  82
  83
  84 void GenericLayout::onControlCapture( const CtrlGeneric &rCtrl )
  85 {
  86     // Just forward the request to the window
  87     TopWindow *pWindow = getWindow();
  88     if( pWindow )
  89     {
  90         pWindow->onControlCapture( rCtrl );
  91     }
  92 }
  93
  94
  95 void GenericLayout::onControlRelease( const CtrlGeneric &rCtrl )
  96 {
  97     // Just forward the request to the window
  98     TopWindow *pWindow = getWindow();
  99     if( pWindow )
 100     {
 101         pWindow->onControlRelease( rCtrl );
 102     }
 103 }
 104
 105
 106 void GenericLayout::addControl( CtrlGeneric *pControl,
 107                                 const Position &rPosition, int layer )
 108 {
 109     if( pControl )
 110     {
 111         // Associate this layout to the control
 112         pControl->setLayout( this, rPosition );
 113
 114         // Add the control in the list.
 115         // This list must remain sorted by layer order
 116         list<LayeredControl>::iterator it;
 117         for( it = m_controlList.begin(); it != m_controlList.end(); ++it )
 118         {
 119             if( layer < (*it).m_layer )
 120             {
 121                 m_controlList.insert( it, LayeredControl( pControl, layer ) );
 122                 break;
 123             }
 124         }
 125         // If this control is in front of all the previous ones
 126         if( it == m_controlList.end() )
 127         {
 128             m_controlList.push_back( LayeredControl( pControl, layer ) );
 129         }
 130
 131         // Check if it is a video control
 132         if( pControl->getType() == "video" )
 133         {
 134             m_pVideoCtrlSet.insert( (CtrlVideo*)pControl );
 135         }
 136     }
 137     else
 138     {
 139         msg_Dbg( getIntf(), "adding NULL control in the layout" );
 140     }
 141 }
 142
 143
 144 const list<LayeredControl> &GenericLayout::getControlList() const
 145 {
 146     return m_controlList;
 147 }
 148
 149
 150 void GenericLayout::onControlUpdate( const CtrlGeneric &rCtrl,
 151                                      int width, int height,
 152                                      int xOffSet, int yOffSet )
 153 {
 154     // Do nothing if the layout or control is hidden
 155     if( !m_visible )
 156         return;
 157
 158     const Position *pPos = rCtrl.getPosition();
 159     if( width > 0 && height > 0 )
 160     {
 161         // make sure region is within the layout
 162         rect region( pPos->getLeft() + xOffSet,
 163                      pPos->getTop() + yOffSet,
 164                      width, height );
 165         rect layout( 0, 0, m_rect.getWidth(), m_rect.getHeight() );
 166         rect inter;
 167         if( rect::intersect( layout, region, &inter ) )
 168         {
 169             refreshRect( inter.x, inter.y, inter.width, inter.height );
 170         }
 171     }
 172 }
 173
 174
 175 void GenericLayout::resize( int width, int height )
 176 {
 177     // Update the window size
 178     m_rect = SkinsRect( 0, 0 , width, height );
 179
 180     // Recreate a new image
 181     if( m_pImage )
 182     {
 183         delete m_pImage;
 184         OSFactory *pOsFactory = OSFactory::instance( getIntf() );
 185         m_pImage = pOsFactory->createOSGraphics( width, height );
 186     }
 187
 188     // Notify all the controls that the size has changed and redraw them
 189     list<LayeredControl>::const_iterator iter;
 190     for( iter = m_controlList.begin(); iter != m_controlList.end(); ++iter )
 191     {
 192         iter->m_pControl->onResize();
 193     }
 194
 195     // Resize and refresh the associated window
 196     TopWindow *pWindow = getWindow();
 197     if( pWindow )
 198     {
 199         // Resize the window
 200         pWindow->resize( width, height );
 201         // Change the shape of the window and redraw it
 202         refreshAll();
 203     }
 204 }
 205
 206
 207 void GenericLayout::refreshAll()
 208 {
 209     refreshRect( 0, 0, m_rect.getWidth(), m_rect.getHeight() );
 210 }
 211
 212
 213 void GenericLayout::refreshRect( int x, int y, int width, int height )
 214 {
 215     // Do nothing if the layout is hidden
 216     if( !m_visible )
 217         return;
 218
 219     // update the transparency global mask
 220     m_pImage->clear( x, y, width, height );
 221
 222     // Draw all the controls of the layout
 223     list<LayeredControl>::const_iterator iter;
 224     for( iter = m_controlList.begin(); iter != m_controlList.end(); ++iter )
 225     {
 226         CtrlGeneric *pCtrl = (*iter).m_pControl;
 227         if( pCtrl->isVisible() )
 228         {
 229             pCtrl->draw( *m_pImage, x, y, width, height );
 230         }
 231     }
 232
 233     // Refresh the associated window
 234     TopWindow *pWindow = getWindow();
 235     if( pWindow )
 236     {
 237         // first apply new shape to the window
 238         pWindow->updateShape();
 239
 240         pWindow->invalidateRect( x, y, width, height );
 241     }
 242 }
 243
 244
 245 const list<Anchor*>& GenericLayout::getAnchorList() const
 246 {
 247     return m_anchorList;
 248 }
 249
 250
 251 void GenericLayout::addAnchor( Anchor *pAnchor )
 252 {
 253     m_anchorList.push_back( pAnchor );
 254 }
 255
 256
 257 void GenericLayout::onShow()
 258 {
 259     m_visible = true;
 260
 261     refreshAll();
 262 }
 263
 264
 265 void GenericLayout::onHide()
 266 {
 267     m_visible = false;
 268 }
 269