void Tooltip::CmdShow::execute()
{
if( m_pParent->m_pImage )
{
if( m_pParent->m_xPos == -1 )
{
// Get the mouse coordinates and the image size
OSFactory *pOsFactory = OSFactory::instance( m_pParent->getIntf() );
int x, y;
pOsFactory->getMousePos( x, y );
int scrWidth = pOsFactory->getScreenWidth();
int scrHeight = pOsFactory->getScreenHeight();
int w = m_pParent->m_pImage->getWidth();
int h = m_pParent->m_pImage->getHeight();
// Compute the position of the tooltip
x -= (w / 2 + 4);
y += (h + 5);
if( x + w > scrWidth )
x -= (x + w - scrWidth);
else if( x < 0 )
x = 0;
if( y + h > scrHeight )
y -= (2 * h + 20);
m_pParent->m_xPos = x;
m_pParent->m_yPos = y;
}
// Show the tooltip window
m_pParent->m_pOsTooltip->show( m_pParent->m_xPos, m_pParent->m_yPos,
*(m_pParent->m_pImage) );
}
}
void GenericLayout::resize( int width, int height )
{
// Update the window size
m_width = width;
m_height = height;
// Recreate a new image
if( m_pImage )
{
delete m_pImage;
OSFactory *pOsFactory = OSFactory::instance( getIntf() );
m_pImage = pOsFactory->createOSGraphics( width, height );
}
// Notify all the controls that the size has changed and redraw them
list<LayeredControl>::const_iterator iter;
for( iter = m_controlList.begin(); iter != m_controlList.end(); iter++ )
{
iter->m_pControl->onResize();
}
// Resize and refresh the associated window
TopWindow *pWindow = getWindow();
if( pWindow )
{
// Resize the window
pWindow->resize( width, height );
refreshAll();
// Change the shape of the window and redraw it
pWindow->updateShape();
refreshAll();
}
}
CtrlButton::CtrlButton( intf_thread_t *pIntf, const GenericBitmap &rBmpUp,
const GenericBitmap &rBmpOver,
const GenericBitmap &rBmpDown, CmdGeneric &rCommand,
const UString &rTooltip, const UString &rHelp,
VarBool *pVisible ):
CtrlGeneric( pIntf, rHelp, pVisible ), m_fsm( pIntf ),
m_rCommand( rCommand ), m_tooltip( rTooltip ),
m_cmdUpOverDownOver( this, &transUpOverDownOver ),
m_cmdDownOverUpOver( this, &transDownOverUpOver ),
m_cmdDownOverDown( this, &transDownOverDown ),
m_cmdDownDownOver( this, &transDownDownOver ),
m_cmdUpOverUp( this, &transUpOverUp ),
m_cmdUpUpOver( this, &transUpUpOver ),
m_cmdDownUp( this, &transDownUp ),
m_cmdUpHidden( this, &transUpHidden ),
m_cmdHiddenUp( this, &transHiddenUp )
{
// Build the images of the button
OSFactory *pOsFactory = OSFactory::instance( pIntf );
m_pImgUp = pOsFactory->createOSGraphics( rBmpUp.getWidth(),
rBmpUp.getHeight() );
m_pImgUp->drawBitmap( rBmpUp, 0, 0 );
m_pImgDown = pOsFactory->createOSGraphics( rBmpDown.getWidth(),
rBmpDown.getHeight() );
m_pImgDown->drawBitmap( rBmpDown, 0, 0 );
m_pImgOver = pOsFactory->createOSGraphics( rBmpOver.getWidth(),
rBmpOver.getHeight() );
m_pImgOver->drawBitmap( rBmpOver, 0, 0 );
// States
m_fsm.addState( "up" );
m_fsm.addState( "down" );
m_fsm.addState( "upOver" );
m_fsm.addState( "downOver" );
m_fsm.addState( "hidden" );
// Transitions
m_fsm.addTransition( "upOver", "mouse:left:down", "downOver",
&m_cmdUpOverDownOver );
m_fsm.addTransition( "upOver", "mouse:left:dblclick", "downOver",
&m_cmdUpOverDownOver );
m_fsm.addTransition( "downOver", "mouse:left:up", "upOver",
&m_cmdDownOverUpOver );
m_fsm.addTransition( "downOver", "leave", "down", &m_cmdDownOverDown );
m_fsm.addTransition( "down", "enter", "downOver", &m_cmdDownDownOver );
m_fsm.addTransition( "upOver", "leave", "up", &m_cmdUpOverUp );
m_fsm.addTransition( "up", "enter", "upOver", &m_cmdUpUpOver );
m_fsm.addTransition( "down", "mouse:left:up", "up", &m_cmdDownUp );
// XXX: It would be easy to use a "ANY" initial state to handle these
// four lines in only one. But till now it isn't worthwhile...
m_fsm.addTransition( "up", "special:hide", "hidden", &m_cmdUpHidden );
m_fsm.addTransition( "down", "special:hide", "hidden", &m_cmdUpHidden );
m_fsm.addTransition( "upOver", "special:hide", "hidden", &m_cmdUpHidden );
m_fsm.addTransition( "downOver", "special:hide", "hidden", &m_cmdUpHidden );
m_fsm.addTransition( "hidden", "special:show", "up", &m_cmdHiddenUp );
// Initial state
m_fsm.setState( "up" );
m_pImg = m_pImgUp;
}
GenericWindow::GenericWindow( intf_thread_t *pIntf, int left, int top,
bool dragDrop, bool playOnDrop,
GenericWindow *pParent, WindowType_t type ):
SkinObject( pIntf ), m_type( type ), m_left( left ), m_top( top ),
m_width( 0 ), m_height( 0 ), m_pVarVisible( NULL )
{
// Get the OSFactory
OSFactory *pOsFactory = OSFactory::instance( getIntf() );
// Get the parent OSWindow, if any
OSWindow *pOSParent = NULL;
if( pParent )
{
pOSParent = pParent->m_pOsWindow;
}
// Create an OSWindow to handle OS specific processing
m_pOsWindow = pOsFactory->createOSWindow( *this, dragDrop, playOnDrop,
pOSParent, type );
// Create the visibility variable and register it in the manager
m_pVarVisible = new VarBoolImpl( pIntf );
VarManager::instance( pIntf )->registerVar( VariablePtr( m_pVarVisible ) );
// Observe the visibility variable
m_pVarVisible->addObserver( this );
}
CtrlRadialSlider::CtrlRadialSlider( intf_thread_t *pIntf,
const GenericBitmap &rBmpSeq, int numImg,
VarPercent &rVariable, float minAngle,
float maxAngle, const UString &rHelp,
VarBool *pVisible ):
CtrlGeneric( pIntf, rHelp, pVisible ), m_fsm( pIntf ), m_numImg( numImg ),
m_rVariable( rVariable ), m_minAngle( minAngle ), m_maxAngle( maxAngle ),
m_cmdUpDown( this ), m_cmdDownUp( this ),
m_cmdMove( this )
{
// Build the images of the sequence
OSFactory *pOsFactory = OSFactory::instance( getIntf() );
m_pImgSeq = pOsFactory->createOSGraphics( rBmpSeq.getWidth(),
rBmpSeq.getHeight() );
m_pImgSeq->drawBitmap( rBmpSeq, 0, 0 );
m_width = rBmpSeq.getWidth();
m_height = rBmpSeq.getHeight() / numImg;
// States
m_fsm.addState( "up" );
m_fsm.addState( "down" );
// Transitions
m_fsm.addTransition( "up", "mouse:left:down", "down", &m_cmdUpDown );
m_fsm.addTransition( "down", "mouse:left:up", "up", &m_cmdDownUp );
m_fsm.addTransition( "down", "motion", "down", &m_cmdMove );
// Initial state
m_fsm.setState( "up" );
// Observe the variable
m_rVariable.addObserver( this );
}
ThemeRepository::ThemeRepository( intf_thread_t *pIntf ): SkinObject( pIntf )
{
vlc_value_t val, text;
// Create a variable to add items in wxwindows popup menu
var_Create( pIntf, "intf-skins", VLC_VAR_STRING |
VLC_VAR_HASCHOICE | VLC_VAR_ISCOMMAND );
text.psz_string = _("Select skin");
var_Change( pIntf, "intf-skins", VLC_VAR_SETTEXT, &text, NULL );
// Scan vlt files in the resource path
OSFactory *pOsFactory = OSFactory::instance( pIntf );
list<string> resPath = pOsFactory->getResourcePath();
list<string>::const_iterator it;
for( it = resPath.begin(); it != resPath.end(); it++ )
{
parseDirectory( *it );
}
// Set the callback
var_AddCallback( pIntf, "intf-skins", changeSkin, this );
// variable for opening a dialog box to change skins
var_Create( pIntf, "intf-skins-interactive", VLC_VAR_VOID |
VLC_VAR_ISCOMMAND );
text.psz_string = _("Open skin ...");
var_Change( pIntf, "intf-skins-interactive", VLC_VAR_SETTEXT, &text, NULL );
// Set the callback
var_AddCallback( pIntf, "intf-skins-interactive", changeSkin, this );
}
void SkinParser::getRefDimensions( int &rWidth, int &rHeight, bool toScreen )
{
if( toScreen )
{
OSFactory *pOsFactory = OSFactory::instance( getIntf() );
rWidth = pOsFactory->getScreenWidth();
rHeight = pOsFactory->getScreenHeight();
return;
}
string panelId = m_panelStack.back();
if( panelId != "none" )
{
list<BuilderData::Panel>::const_iterator it;
for( it = m_pData->m_listPanel.begin();
it != m_pData->m_listPanel.end(); ++it )
{
if( it->m_id == panelId )
{
rWidth = it->m_width;
rHeight = it->m_height;
return;
}
}
}
else
{
const BuilderData::Layout layout = m_pData->m_listLayout.back();
rWidth = layout.m_width;
rHeight = layout.m_height;
return;
}
msg_Err( getIntf(), "failure to retrieve parent panel or layout" );
}
void VoutManager::configureFullscreen( VoutWindow& rWindow )
{
int numScr = var_InheritInteger( getIntf(), "qt-fullscreen-screennumber" );
int x0 = m_pVoutMainWindow->getTop();
int y0 = m_pVoutMainWindow->getLeft();
int x, y, w, h;
if( numScr >= 0 )
{
// select screen requested by user
OSFactory *pOsFactory = OSFactory::instance( getIntf() );
pOsFactory->getMonitorInfo( numScr, &x, &y, &w, &h );
}
else
{
// select screen where display is already occurring
rWindow.getMonitorInfo( &x, &y, &w, &h );
}
if( x != x0 || y != y0 )
{
// move and resize fullscreen
m_pVoutMainWindow->move( x, y );
m_pVoutMainWindow->resize( w, h );
// ensure the fs controller is also moved
if( m_pFscWindow )
{
m_pFscWindow->moveTo( x, y, w, h );
}
}
}
void CmdExitLoop::execute()
{
// Get the instance of OSFactory
OSFactory *pOsFactory = OSFactory::instance( getIntf() );
// Exit the main OS loop
pOsFactory->getOSLoop()->exit();
}
void VoutManager::hideMouseWnd( vout_window_t *pWnd, bool hide )
{
msg_Dbg( pWnd, "hide mouse (%i) received from vout thread", hide );
OSFactory *pOsFactory = OSFactory::instance( getIntf() );
if( hide )
pOsFactory->changeCursor( OSFactory::kNoCursor );
else
pOsFactory->changeCursor( OSFactory::kDefaultArrow );
}
Popup::Popup( intf_thread_t *pIntf, WindowManager &rWindowManager )
: SkinObject( pIntf ), m_rWindowManager( rWindowManager )
{
// Get the OSFactory
OSFactory *pOsFactory = OSFactory::instance( getIntf() );
// Create an OSPopup to handle OS specific processing
m_pOsPopup = pOsFactory->createOSPopup();
}
CtrlSliderCursor::CtrlSliderCursor( intf_thread_t *pIntf,
const GenericBitmap &rBmpUp,
const GenericBitmap &rBmpOver,
const GenericBitmap &rBmpDown,
const Bezier &rCurve,
VarPercent &rVariable,
VarBool *pVisible,
const UString &rTooltip,
const UString &rHelp ):
CtrlGeneric( pIntf, rHelp, pVisible ), m_fsm( pIntf ),
m_rVariable( rVariable ), m_tooltip( rTooltip ),
m_width( rCurve.getWidth() ), m_height( rCurve.getHeight() ),
m_cmdOverDown( this, &transOverDown ),
m_cmdDownOver( this, &transDownOver ), m_cmdOverUp( this, &transOverUp ),
m_cmdUpOver( this, &transUpOver ), m_cmdMove( this, &transMove ),
m_cmdScroll( this, &transScroll ),
m_lastPercentage( 0 ), m_xOffset( 0 ), m_yOffset( 0 ),
m_pEvt( NULL ), m_rCurve( rCurve )
{
// Build the images of the cursor
OSFactory *pOsFactory = OSFactory::instance( getIntf() );
m_pImgUp = pOsFactory->createOSGraphics( rBmpUp.getWidth(),
rBmpUp.getHeight() );
m_pImgUp->drawBitmap( rBmpUp, 0, 0 );
m_pImgDown = pOsFactory->createOSGraphics( rBmpDown.getWidth(),
rBmpDown.getHeight() );
m_pImgDown->drawBitmap( rBmpDown, 0, 0 );
m_pImgOver = pOsFactory->createOSGraphics( rBmpOver.getWidth(),
rBmpOver.getHeight() );
m_pImgOver->drawBitmap( rBmpOver, 0, 0 );
// States
m_fsm.addState( "up" );
m_fsm.addState( "over" );
m_fsm.addState( "down" );
// Transitions
m_fsm.addTransition( "over", "mouse:left:down", "down",
&m_cmdOverDown );
m_fsm.addTransition( "down", "mouse:left:up", "over",
&m_cmdDownOver );
m_fsm.addTransition( "over", "leave", "up", &m_cmdOverUp );
m_fsm.addTransition( "up", "enter", "over", &m_cmdUpOver );
m_fsm.addTransition( "down", "motion", "down", &m_cmdMove );
m_fsm.addTransition( "over", "scroll", "over", &m_cmdScroll );
// Initial state
m_fsm.setState( "up" );
m_pImg = m_pImgUp;
// Observe the position variable
m_rVariable.addObserver( this );
// Initial position of the cursor
m_lastPercentage = m_rVariable.get();
}
Tooltip::Tooltip( intf_thread_t *pIntf, const GenericFont &rFont, int delay ):
SkinObject( pIntf ), m_rFont( rFont ), m_delay( delay ), m_pImage( NULL ),
m_xPos( -1 ), m_yPos( -1 ), m_cmdShow( this )
{
OSFactory *pOsFactory = OSFactory::instance( pIntf );
m_pTimer = pOsFactory->createOSTimer( m_cmdShow );
m_pOsTooltip = pOsFactory->createOSTooltip();
// Observe the tooltip text variable
VarManager::instance( pIntf )->getTooltipText().addObserver( this );
}
void CtrlResize::changeCursor( WindowManager::Direction_t direction ) const
{
OSFactory *pOsFactory = OSFactory::instance( getIntf() );
if( direction == WindowManager::kResizeSE )
pOsFactory->changeCursor( OSFactory::kResizeNWSE );
else if( direction == WindowManager::kResizeS )
pOsFactory->changeCursor( OSFactory::kResizeNS );
else if( direction == WindowManager::kResizeE )
pOsFactory->changeCursor( OSFactory::kResizeWE );
else if( direction == WindowManager::kNone )
pOsFactory->changeCursor( OSFactory::kDefaultArrow );
}
CtrlImage::CtrlImage( intf_thread_t *pIntf, const GenericBitmap &rBitmap,
CmdGeneric &rCommand, resize_t resizeMethod,
const UString &rHelp, VarBool *pVisible ):
CtrlFlat( pIntf, rHelp, pVisible ), m_rBitmap( rBitmap ),
m_rCommand( rCommand ), m_resizeMethod( resizeMethod )
{
OSFactory *pOsFactory = OSFactory::instance( pIntf );
// Create an initial unscaled image in the buffer
m_pImage = pOsFactory->createOSGraphics( rBitmap.getWidth(),
rBitmap.getHeight() );
m_pImage->drawBitmap( m_rBitmap );
}
string ThemeLoader::fixDirSeparators( const string &rPath )
{
OSFactory *pOsFactory = OSFactory::instance( getIntf() );
const string &sep = pOsFactory->getDirSeparator();
string::size_type p = rPath.find( "/", 0 );
string newPath = rPath;
while( p != string::npos )
{
newPath = newPath.replace( p, 1, sep );
p = newPath.find( "/", p + 1 );
}
return newPath;
}
AsyncQueue::AsyncQueue( intf_thread_t *pIntf ): SkinObject( pIntf ),
m_cmdFlush( this )
{
// Initialize the mutex
vlc_mutex_init( &m_lock );
// Create a timer
OSFactory *pOsFactory = OSFactory::instance( pIntf );
m_pTimer = pOsFactory->createOSTimer( m_cmdFlush );
// Flush the queue every 10 ms
m_pTimer->start( 10, false );
}
void VlcProc::manage()
{
// Did the user request to quit vlc ?
if( !vlc_object_alive( getIntf() ) )
{
// Get the instance of OSFactory
OSFactory *pOsFactory = OSFactory::instance( getIntf() );
// Exit the main OS loop
pOsFactory->getOSLoop()->exit();
return;
}
}
void XMLParser::LoadCatalog()
{
// Get the resource path and look for the DTD
OSFactory *pOSFactory = OSFactory::instance( getIntf() );
const list<string> &resPath = pOSFactory->getResourcePath();
const string &sep = pOSFactory->getDirSeparator();
list<string>::const_iterator it;
#ifdef HAVE_SYS_STAT_H
struct stat statBuf;
// Try to load the catalog first (needed at least on win32 where
// we don't have a default catalog)
for( it = resPath.begin(); it != resPath.end(); ++it )
{
string catalog_path = (*it) + sep + "skin.catalog";
if( !stat( catalog_path.c_str(), &statBuf ) )
{
msg_Dbg( getIntf(), "Using catalog %s", catalog_path.c_str() );
xml_CatalogLoad( m_pXML, catalog_path.c_str() );
break;
}
}
if( it == resPath.end() )
{
// Ok, try the default one
xml_CatalogLoad( m_pXML, NULL );
}
for( it = resPath.begin(); it != resPath.end(); ++it )
{
string path = (*it) + sep + "skin.dtd";
if( !stat( path.c_str(), &statBuf ) )
{
// DTD found
msg_Dbg( getIntf(), "using DTD %s", path.c_str() );
// Add an entry in the default catalog
xml_CatalogAdd( m_pXML, "public",
"-//VideoLAN//DTD VLC Skins V"
SKINS_DTD_VERSION "//EN", path.c_str() );
break;
}
}
if( it == resPath.end() )
{
msg_Err( getIntf(), "cannot find the skins DTD");
}
#endif
}
MacOSXWindow::MacOSXWindow( intf_thread_t *pIntf, GenericWindow &rWindow,
bool dragDrop, bool playOnDrop,
MacOSXWindow *pParentWindow ):
OSWindow( pIntf ), m_pParent( pParentWindow ), m_dragDrop( dragDrop )
{
// Create the window
Rect rect;
SetRect( &rect, 0, 0, 0, 0 );
CreateNewWindow( kDocumentWindowClass, kWindowNoShadowAttribute |
kWindowNoTitleBarAttribute, &rect, &m_win );
// Create the event handler for this window
OSFactory *pOSFactory = OSFactory::instance( getIntf() );
((MacOSXLoop*)pOSFactory->getOSLoop())->registerWindow( rWindow, m_win );
}
const string Stream::getAsStringName() const
{
string fullName = getAsStringFullName();
// XXX: This should be done in VLC core, not here...
// Remove path information if any
OSFactory *pFactory = OSFactory::instance( getIntf() );
string::size_type pos = fullName.rfind( pFactory->getDirSeparator() );
if( pos != string::npos )
{
fullName = fullName.substr( pos + 1, fullName.size() - pos + 1 );
}
return fullName;
}
void CtrlImage::draw( OSGraphics &rImage, int xDest, int yDest )
{
const Position *pPos = getPosition();
if( pPos )
{
int width = pPos->getWidth();
int height = pPos->getHeight();
if( m_resizeMethod == kScale )
{
// Use scaling method
if( width > 0 && height > 0 )
{
if( width != m_pImage->getWidth() ||
height != m_pImage->getHeight() )
{
OSFactory *pOsFactory = OSFactory::instance( getIntf() );
// Rescale the image with the actual size of the control
ScaledBitmap bmp( getIntf(), m_rBitmap, width, height );
SKINS_DELETE( m_pImage );
m_pImage = pOsFactory->createOSGraphics( width, height );
m_pImage->drawBitmap( bmp, 0, 0 );
}
rImage.drawGraphics( *m_pImage, 0, 0, xDest, yDest );
}
}
else
{
// Use mosaic method
while( width > 0 )
{
int curWidth = __MIN( width, m_pImage->getWidth() );
height = pPos->getHeight();
int curYDest = yDest;
while( height > 0 )
{
int curHeight = __MIN( height, m_pImage->getHeight() );
rImage.drawGraphics( *m_pImage, 0, 0, xDest, curYDest,
curWidth, curHeight );
curYDest += curHeight;
height -= m_pImage->getHeight();
}
xDest += curWidth;
width -= m_pImage->getWidth();
}
}
}
}
AnimBitmap::AnimBitmap( intf_thread_t *pIntf, const GenericBitmap &rBitmap ):
SkinObject( pIntf ), m_pImage( NULL ), m_curFrame( 0 ), m_pTimer( NULL ),
m_cmdNextFrame( this ), m_rBitmap( rBitmap )
{
// Build the graphics
OSFactory *pOsFactory = OSFactory::instance( pIntf );
m_pImage = pOsFactory->createOSGraphics( rBitmap.getWidth(),
rBitmap.getHeight() );
m_pImage->drawBitmap( rBitmap, 0, 0 );
m_nbFrames = rBitmap.getNbFrames();
m_frameRate = rBitmap.getFrameRate();
// Create the timer
m_pTimer = pOsFactory->createOSTimer( m_cmdNextFrame );
}
VoutManager::VoutManager( intf_thread_t *pIntf ): SkinObject( pIntf ),
m_pCtrlVideoVec(), m_pCtrlVideoVecBackup(), m_SavedWndVec(),
m_pVoutMainWindow( NULL ), m_pFscWindow( NULL )
{
m_pVoutMainWindow = new VoutMainWindow( getIntf() );
OSFactory *pOsFactory = OSFactory::instance( getIntf() );
int width = pOsFactory->getScreenWidth();
int height = pOsFactory->getScreenHeight();
m_pVoutMainWindow->move( 0, 0 );
m_pVoutMainWindow->resize( width, height );
VarBool &rFullscreen = VlcProc::instance( getIntf() )->getFullscreenVar();
rFullscreen.addObserver( this );
}
void VoutWindow::resize( int width, int height )
{
// Get the OSFactory
OSFactory *pOsFactory = OSFactory::instance( getIntf() );
// Recreate the image
if( m_pImage )
{
delete m_pImage;
}
m_pImage = pOsFactory->createOSGraphics( width, height );
// Draw a black rectangle
m_pImage->fillRect( 0, 0, width, height, 0 );
// Resize the window
GenericWindow::resize( width, height );
}
GenericLayout::GenericLayout( intf_thread_t *pIntf, int width, int height,
int minWidth, int maxWidth, int minHeight,
int maxHeight ):
SkinObject( pIntf ), m_pWindow( NULL ), m_width( width ),
m_height( height ), m_minWidth( minWidth ), m_maxWidth( maxWidth ),
m_minHeight( minHeight ), m_maxHeight( maxHeight ), m_pVideoControl( NULL ),
m_visible( false ), m_pVarActive( NULL )
{
// Get the OSFactory
OSFactory *pOsFactory = OSFactory::instance( getIntf() );
// Create the graphics buffer
m_pImage = pOsFactory->createOSGraphics( width, height );
// Create the "active layout" variable and register it in the manager
m_pVarActive = new VarBoolImpl( pIntf );
VarManager::instance( pIntf )->registerVar( VariablePtr( m_pVarActive ) );
}
const OSGraphics *GenericBitmap::getGraphics() const
{
if( m_pGraphics )
return m_pGraphics;
OSFactory *pOsFactory = OSFactory::instance( getIntf() );
int width = getWidth();
int height = getHeight();
if( width > 0 && height > 0 )
{
m_pGraphics = pOsFactory->createOSGraphics( width, height );
m_pGraphics->drawBitmap( *this, 0, 0 );
return m_pGraphics;
}
msg_Err( getIntf(), "failed to create a graphics, please report" );
return NULL;
}
string ThemeLoader::getFilePath( const string &rFullPath )
{
OSFactory *pOsFactory = OSFactory::instance( getIntf() );
const string &sep = pOsFactory->getDirSeparator();
// Find the last separator ('/' or '\')
string::size_type p = rFullPath.rfind( sep, rFullPath.size() );
string basePath;
if( p != string::npos )
{
if( p < rFullPath.size() - 1)
{
basePath = rFullPath.substr( 0, p );
}
else
{
basePath = rFullPath;
}
}
return basePath;
}
VoutWindow::VoutWindow( intf_thread_t *pIntf, vout_window_t* pWnd,
int width, int height, GenericWindow* pParent ) :
GenericWindow( pIntf, 0, 0, false, false, pParent,
GenericWindow::VoutWindow ),
m_pWnd( pWnd ), original_width( width ), original_height( height ),
m_pCtrlVideo( NULL ), m_pParentWindow( pParent ),
mouse_hide_timeout( var_InheritInteger( pWnd, "mouse-hide-timeout" ) ),
m_cmdHideMouse( this )
{
OSFactory *pOsFactory = OSFactory::instance( pIntf );
if( m_pWnd )
{
vlc_object_hold( m_pWnd );
updateWindowConfiguration( m_pWnd );
m_pTimer = pOsFactory->createOSTimer( m_cmdHideMouse );
}
}
const int SkinParser::getRefHeight( bool toScreen )
{
if( toScreen )
{
OSFactory *pOsFactory = OSFactory::instance( getIntf() );
return pOsFactory->getScreenHeight();
}
string panelId = m_panelStack.back();
if( panelId != "none" )
{
const BuilderData::Panel panel = m_pData->m_listPanel.back();
return panel.m_height;
}
else
{
const BuilderData::Layout layout = m_pData->m_listLayout.back();
return layout.m_height;
}
}
