git.sesse.net Git - vlc/blob - modules/gui/skins2/controls/ctrl_text.cpp

   1 /*****************************************************************************
   2  * ctrl_text.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 "ctrl_text.hpp"
  26 #include "../events/evt_generic.hpp"
  27 #include "../events/evt_mouse.hpp"
  28 #include "../src/generic_bitmap.hpp"
  29 #include "../src/generic_font.hpp"
  30 #include "../src/os_factory.hpp"
  31 #include "../src/os_graphics.hpp"
  32 #include "../src/os_timer.hpp"
  33 #include "../utils/position.hpp"
  34 #include "../utils/ustring.hpp"
  35 #include "../utils/var_text.hpp"
  36
  37
  38 #define MOVING_TEXT_STEP 1
  39 #define MOVING_TEXT_DELAY 30
  40 #define SEPARATOR_STRING "   "
  41
  42
  43 CtrlText::CtrlText( intf_thread_t *pIntf, VarText &rVariable,
  44                     const GenericFont &rFont, const UString &rHelp,
  45                     uint32_t color, VarBool *pVisible, VarBool *pFocus,
  46                     Scrolling_t scrollMode, Align_t alignment ):
  47     CtrlGeneric( pIntf, rHelp, pVisible ), m_pFocus( pFocus), m_fsm( pIntf ),
  48     m_rVariable( rVariable ), m_cmdToManual( this ),
  49     m_cmdManualMoving( this ), m_cmdManualStill( this ),
  50     m_cmdMove( this ), m_pEvt( NULL ), m_rFont( rFont ),
  51     m_color( color ), m_scrollMode( scrollMode ), m_alignment( alignment ),
  52     m_pImg( NULL ), m_pImgDouble( NULL ),
  53     m_pCurrImg( NULL ), m_xPos( 0 ), m_xOffset( 0 ),
  54     m_cmdUpdateText( this )
  55 {
  56     m_pTimer = OSFactory::instance( pIntf )->createOSTimer( m_cmdUpdateText );
  57
  58     // States
  59     m_fsm.addState( "still" );
  60     m_fsm.addState( "moving" );
  61     m_fsm.addState( "manual1" );
  62     m_fsm.addState( "manual2" );
  63     m_fsm.addState( "outStill" );
  64     m_fsm.addState( "outMoving" );
  65
  66     // Transitions
  67     m_fsm.addTransition( "still", "leave", "outStill" );
  68     m_fsm.addTransition( "outStill", "enter", "still" );
  69     if( m_scrollMode == kManual )
  70     {
  71         m_fsm.addTransition( "still", "mouse:left:down", "manual1",
  72                              &m_cmdToManual );
  73         m_fsm.addTransition( "manual1", "mouse:left:up", "still",
  74                              &m_cmdManualStill );
  75         m_fsm.addTransition( "manual1", "motion", "manual1", &m_cmdMove );
  76     }
  77     else if( m_scrollMode == kAutomatic )
  78     {
  79         m_fsm.addTransition( "still", "mouse:left:down", "manual1",
  80                              &m_cmdToManual );
  81         m_fsm.addTransition( "manual1", "mouse:left:up", "moving",
  82                              &m_cmdManualMoving );
  83         m_fsm.addTransition( "moving", "mouse:left:down", "manual2",
  84                              &m_cmdToManual );
  85         m_fsm.addTransition( "manual2", "mouse:left:up", "still",
  86                              &m_cmdManualStill );
  87         m_fsm.addTransition( "manual1", "motion", "manual1", &m_cmdMove );
  88         m_fsm.addTransition( "manual2", "motion", "manual2", &m_cmdMove );
  89         m_fsm.addTransition( "moving", "leave", "outMoving" );
  90         m_fsm.addTransition( "outMoving", "enter", "moving" );
  91     }
  92
  93     // Initial state
  94     m_fsm.setState( "outStill" );
  95
  96     // Observe the variable
  97     m_rVariable.addObserver( this );
  98
  99     // Set the text
 100     displayText( m_rVariable.get() );
 101 }
 102
 103
 104 CtrlText::~CtrlText()
 105 {
 106     m_rVariable.delObserver( this );
 107     delete m_pTimer;
 108     delete m_pImg;
 109     delete m_pImgDouble;
 110 }
 111
 112
 113 void CtrlText::handleEvent( EvtGeneric &rEvent )
 114 {
 115     // Save the event to use it in callbacks
 116     m_pEvt = &rEvent;
 117
 118     m_fsm.handleTransition( rEvent.getAsString() );
 119 }
 120
 121
 122 bool CtrlText::mouseOver( int x, int y ) const
 123 {
 124     if( !m_pFocus->get() )
 125         return false;
 126
 127     if( m_pCurrImg )
 128     {
 129         // We have 3 different ways of deciding when to return true here:
 130         //  1) the mouse is exactly over the text (so if you click between two
 131         //     letters, the text control doesn't catch the event)
 132         //  2) the mouse is over the rectangle of the control
 133         //  3) the mouse is over the rectangle of the visible text
 134         // I don't know which one is the best...
 135 #if 0
 136         return( x >= 0 && x < getPosition()->getWidth()
 137              && m_pCurrImg->hit( x - m_xPos, y ) );
 138 #endif
 139 #if 1
 140         return( x >= 0 && x < getPosition()->getWidth()
 141              && y >= 0 && y < getPosition()->getHeight() );
 142 #endif
 143 #if 0
 144         return( x >= 0 && x < getPosition()->getWidth()
 145              && y >= 0 && y < getPosition()->getHeight()
 146              && x < m_pCurrImg->getWidth() && x < m_pCurrImg->getHeight() );
 147 #endif
 148     }
 149     else
 150     {
 151         return false;
 152     }
 153 }
 154
 155
 156 void CtrlText::draw( OSGraphics &rImage, int xDest, int yDest, int w, int h )
 157 {
 158     rect clip( xDest, yDest, w, h );
 159     const Position *pPos = getPosition();
 160     if( m_pCurrImg )
 161     {
 162         // Compute the dimensions to draw
 163         int width = min( m_pCurrImg->getWidth() + m_xPos,
 164                          getPosition()->getWidth() );
 165         int height = min( m_pCurrImg->getHeight(), getPosition()->getHeight() );
 166         // Draw the current image
 167         if( width > 0 && height > 0 )
 168         {
 169             int offset = 0;
 170             if( m_alignment == kLeft )
 171             {
 172                 // We align to the left
 173                 offset = 0;
 174             }
 175             else if( m_alignment == kRight &&
 176                      width < getPosition()->getWidth() )
 177
 178             {
 179                 // The text is shorter than the width of the control, so we
 180                 // can align it to the right
 181                 offset = getPosition()->getWidth() - width;
 182             }
 183             else if( m_alignment == kCenter &&
 184                      width < getPosition()->getWidth() )
 185             {
 186                 // The text is shorter than the width of the control, so we
 187                 // can center it
 188                 offset = (getPosition()->getWidth() - width) / 2;
 189             }
 190             rect region( pPos->getLeft() + offset,
 191                          pPos->getTop(), width, height );
 192             rect inter;
 193             if( rect::intersect( region, clip, &inter ) )
 194                 rImage.drawBitmap( *m_pCurrImg, -m_xPos + inter.x - region.x,
 195                                    inter.y - region.y,
 196                                    inter.x, inter.y,
 197                                    inter.width, inter.height, true );
 198         }
 199     }
 200 }
 201
 202
 203 void CtrlText::setText( const UString &rText, uint32_t color )
 204 {
 205     // Change the color
 206     if( color != 0xFFFFFFFF )
 207     {
 208         m_color = color;
 209     }
 210
 211     // Change the text
 212     m_rVariable.set( rText );
 213 }
 214
 215
 216 void CtrlText::onUpdate( Subject<VarText> &rVariable, void* arg )
 217 {
 218     if( isVisible() )
 219     {
 220         displayText( m_rVariable.get() );
 221         notifyLayout( getPosition()->getWidth(), getPosition()->getHeight() );
 222     }
 223 }
 224
 225
 226 void CtrlText::onUpdate( Subject<VarBool> &rVariable, void *arg  )
 227 {
 228     // Visibility changed
 229     if( &rVariable == m_pVisible )
 230     {
 231         if( isVisible() )
 232         {
 233             displayText( m_rVariable.get() );
 234             notifyLayout( getPosition()->getWidth(), getPosition()->getHeight() );
 235         }
 236         else
 237         {
 238             notifyLayout();
 239         }
 240     }
 241 }
 242
 243
 244 void CtrlText::displayText( const UString &rText )
 245 {
 246     // Create the images ('normal' and 'double') from the text
 247     // 'Normal' image
 248     delete m_pImg;
 249     m_pImg = m_rFont.drawString( rText, m_color );
 250     if( !m_pImg )
 251     {
 252         return;
 253     }
 254     // 'Double' image
 255     const UString doubleStringWithSep = rText + SEPARATOR_STRING + rText;
 256     delete m_pImgDouble;
 257     m_pImgDouble = m_rFont.drawString( doubleStringWithSep, m_color );
 258
 259     // Update the current image used, as if the control size had changed
 260     onPositionChange();
 261
 262     if( m_alignment == kRight && getPosition() &&
 263         getPosition()->getWidth() < m_pImg->getWidth() )
 264     {
 265         m_xPos = getPosition()->getWidth() - m_pImg->getWidth();
 266     }
 267     else if( m_alignment == kCenter && getPosition() &&
 268              getPosition()->getWidth() < m_pImg->getWidth() )
 269     {
 270         m_xPos = (getPosition()->getWidth() - m_pImg->getWidth()) / 2;
 271     }
 272     else
 273     {
 274         m_xPos = 0;
 275     }
 276
 277     if( getPosition() )
 278     {
 279         // If the control was in the moving state, check if the scrolling is
 280         // still necessary
 281         const string &rState = m_fsm.getState();
 282         if( rState == "moving" || rState == "outMoving" )
 283         {
 284             if( m_pImg && m_pImg->getWidth() >= getPosition()->getWidth() )
 285             {
 286                 m_pCurrImg = m_pImgDouble;
 287                 m_pTimer->start( MOVING_TEXT_DELAY, false );
 288             }
 289             else
 290             {
 291                 m_pTimer->stop();
 292             }
 293         }
 294     }
 295 }
 296
 297
 298 void CtrlText::onPositionChange()
 299 {
 300     if( m_pImg && getPosition() )
 301     {
 302         if( m_pImg->getWidth() < getPosition()->getWidth() )
 303         {
 304             m_pCurrImg = m_pImg;
 305
 306             // When the control becomes wide enough for the text to display,
 307             // make sure to stop any scrolling effect
 308             m_pTimer->stop();
 309             m_xPos = 0;
 310         }
 311         else
 312         {
 313             m_pCurrImg = m_pImgDouble;
 314         }
 315     }
 316     else
 317     {
 318         // m_pImg is a better default value than m_pImgDouble, but anyway we
 319         // don't care because the control is never drawn without position :)
 320         m_pCurrImg = m_pImg;
 321     }
 322 }
 323
 324
 325 void CtrlText::onResize()
 326 {
 327     onPositionChange();
 328 }
 329
 330
 331 void CtrlText::CmdToManual::execute()
 332 {
 333     EvtMouse *pEvtMouse = (EvtMouse*)m_pParent->m_pEvt;
 334
 335     // Compute the offset
 336     m_pParent->m_xOffset = pEvtMouse->getXPos() - m_pParent->m_xPos;
 337
 338     m_pParent->m_pTimer->stop();
 339     m_pParent->captureMouse();
 340 }
 341
 342
 343 void CtrlText::CmdManualMoving::execute()
 344 {
 345     m_pParent->releaseMouse();
 346
 347     // Start the automatic movement, but only if the text is wider than the
 348     // control and if the control can scroll (either in manual or automatic
 349     // mode)
 350     if( m_pParent->m_pImg &&
 351         m_pParent->m_pImg->getWidth() >= m_pParent->getPosition()->getWidth() )
 352     {
 353         // The current image may have been set incorrectly in displayText(), so
 354         // set the correct value
 355         m_pParent->m_pCurrImg = m_pParent->m_pImgDouble;
 356
 357         m_pParent->m_pTimer->start( MOVING_TEXT_DELAY, false );
 358     }
 359 }
 360
 361
 362 void CtrlText::CmdManualStill::execute()
 363 {
 364     m_pParent->releaseMouse();
 365 }
 366
 367
 368 void CtrlText::CmdMove::execute()
 369 {
 370     EvtMouse *pEvtMouse = (EvtMouse*)m_pParent->m_pEvt;
 371
 372     // Do nothing if the text fits in the control
 373     if( m_pParent->m_pImg &&
 374         m_pParent->m_pImg->getWidth() >= m_pParent->getPosition()->getWidth() )
 375     {
 376         // The current image may have been set incorrectly in displayText(), so
 377         // we set the correct value
 378         m_pParent->m_pCurrImg = m_pParent->m_pImgDouble;
 379
 380         // Compute the new position of the left side, and make sure it is
 381         // in the correct range
 382         m_pParent->m_xPos = (pEvtMouse->getXPos() - m_pParent->m_xOffset);
 383         m_pParent->adjust( m_pParent->m_xPos );
 384
 385         m_pParent->notifyLayout( m_pParent->getPosition()->getWidth(),
 386                                  m_pParent->getPosition()->getHeight() );
 387     }
 388 }
 389
 390
 391 void CtrlText::CmdUpdateText::execute()
 392 {
 393     m_pParent->m_xPos -= MOVING_TEXT_STEP;
 394     m_pParent->adjust( m_pParent->m_xPos );
 395
 396     m_pParent->notifyLayout( m_pParent->getPosition()->getWidth(),
 397                              m_pParent->getPosition()->getHeight() );
 398 }
 399
 400
 401 void CtrlText::adjust( int &position )
 402 {
 403     // {m_pImgDouble->getWidth() - m_pImg->getWidth()} is the period of the
 404     // bitmap; remember that the string used to generate m_pImgDouble is of the
 405     // form: "foo  foo", the number of spaces being a parameter
 406     if( !m_pImg )
 407     {
 408         return;
 409     }
 410     position %= m_pImgDouble->getWidth() - m_pImg->getWidth();
 411     if( position > 0 )
 412     {
 413         position -= m_pImgDouble->getWidth() - m_pImg->getWidth();
 414     }
 415 }
 416