/*****************************************************************************
* Config handling
*****************************************************************************/
static int vlclua_config_get( lua_State *L )
{
vlc_object_t * p_this = vlclua_get_this( L );
const char *psz_name = luaL_checkstring( L, 1 );
switch( config_GetType( p_this, psz_name ) )
{
case VLC_VAR_STRING:
{
char *psz = config_GetPsz( p_this, psz_name );
lua_pushstring( L, psz );
free( psz );
break;
}
case VLC_VAR_INTEGER:
lua_pushinteger( L, config_GetInt( p_this, psz_name ) );
break;
case VLC_VAR_BOOL:
lua_pushboolean( L, config_GetInt( p_this, psz_name ) );
break;
case VLC_VAR_FLOAT:
lua_pushnumber( L, config_GetFloat( p_this, psz_name ) );
break;
default:
return vlclua_error( L );
}
return 1;
}
/**
* Finds the value of a variable. If the specified object does not hold a
* variable with the specified name, try the parent object, and iterate until
* the top of the tree. If no match is found, the value is read from the
* configuration.
*/
int var_Inherit( vlc_object_t *p_this, const char *psz_name, int i_type,
vlc_value_t *p_val )
{
i_type &= VLC_VAR_CLASS;
for( vlc_object_t *obj = p_this; obj != NULL; obj = obj->obj.parent )
{
if( var_GetChecked( obj, psz_name, i_type, p_val ) == VLC_SUCCESS )
return VLC_SUCCESS;
}
/* else take value from config */
switch( i_type & VLC_VAR_CLASS )
{
case VLC_VAR_STRING:
p_val->psz_string = config_GetPsz( p_this, psz_name );
if( !p_val->psz_string ) p_val->psz_string = strdup("");
break;
case VLC_VAR_FLOAT:
p_val->f_float = config_GetFloat( p_this, psz_name );
break;
case VLC_VAR_INTEGER:
p_val->i_int = config_GetInt( p_this, psz_name );
break;
case VLC_VAR_BOOL:
p_val->b_bool = config_GetInt( p_this, psz_name );
break;
default:
vlc_assert_unreachable();
case VLC_VAR_ADDRESS:
return VLC_ENOOBJ;
}
return VLC_SUCCESS;
}
/**
* Finds the value of a variable. If the specified object does not hold a
* variable with the specified name, try the parent object, and iterate until
* the top of the tree. If no match is found, the value is read from the
* configuration.
*/
int var_Inherit( vlc_object_t *p_this, const char *psz_name, int i_type,
vlc_value_t *p_val )
{
#ifndef NDEBUG
if (p_this != VLC_OBJECT(p_this->p_libvlc)
&& unlikely(p_this->p_parent == NULL))
{
msg_Info (p_this, "%s(%s) on detached object", __func__, psz_name);
//vlc_backtrace ();
}
#endif
i_type &= VLC_VAR_CLASS;
for( vlc_object_t *obj = p_this; obj != NULL; obj = obj->p_parent )
{
if( var_GetChecked( obj, psz_name, i_type, p_val ) == VLC_SUCCESS )
return VLC_SUCCESS;
#ifndef NDEBUG
if (obj != p_this && obj != VLC_OBJECT(p_this->p_libvlc)
&& unlikely(obj->p_parent == NULL))
{
msg_Info (p_this, "%s(%s) on detached tree [%p] %s", __func__,
psz_name, obj, obj->psz_object_type);
//vlc_backtrace ();
}
#endif
}
/* else take value from config */
switch( i_type & VLC_VAR_CLASS )
{
case VLC_VAR_STRING:
p_val->psz_string = config_GetPsz( p_this, psz_name );
if( !p_val->psz_string ) p_val->psz_string = strdup("");
break;
case VLC_VAR_FLOAT:
p_val->f_float = config_GetFloat( p_this, psz_name );
break;
case VLC_VAR_INTEGER:
p_val->i_int = config_GetInt( p_this, psz_name );
break;
case VLC_VAR_BOOL:
p_val->b_bool = config_GetInt( p_this, psz_name );
break;
case VLC_VAR_ADDRESS:
return VLC_ENOOBJ;
default:
msg_Warn( p_this, "Could not inherit value for var %s "
"from config. Invalid Type", psz_name );
return VLC_ENOOBJ;
}
/*msg_Dbg( p_this, "Inherited value for var %s from config", psz_name );*/
return VLC_SUCCESS;
}
SoundWidget::SoundWidget( QWidget *_parent, intf_thread_t * _p_intf,
bool b_shiny, bool b_special )
: QWidget( _parent ), p_intf( _p_intf),
b_is_muted( false ), b_ignore_valuechanged( false )
{
/* We need a layout for this widget */
QHBoxLayout *layout = new QHBoxLayout( this );
layout->setSpacing( 0 ); layout->setMargin( 0 );
/* We need a Label for the pix */
volMuteLabel = new QLabel;
volMuteLabel->setPixmap( QPixmap( ":/toolbar/volume-medium" ) );
/* We might need a subLayout too */
QVBoxLayout *subLayout;
volMuteLabel->installEventFilter( this );
/* Normal View, click on icon mutes */
if( !b_special )
{
volumeMenu = NULL; subLayout = NULL;
volumeControlWidget = NULL;
/* And add the label */
layout->addWidget( volMuteLabel, 0, b_shiny? Qt::AlignBottom : Qt::AlignCenter );
}
else
{
/* Special view, click on button shows the slider */
b_shiny = false;
volumeControlWidget = new QFrame( this );
subLayout = new QVBoxLayout( volumeControlWidget );
subLayout->setContentsMargins( 4, 4, 4, 4 );
volumeMenu = new QMenu( this );
QWidgetAction *widgetAction = new QWidgetAction( volumeControlWidget );
widgetAction->setDefaultWidget( volumeControlWidget );
volumeMenu->addAction( widgetAction );
/* And add the label */
layout->addWidget( volMuteLabel );
}
/* Slider creation: shiny or clean */
if( b_shiny )
{
volumeSlider = new SoundSlider( this,
config_GetFloat( p_intf, "volume-step" ),
var_InheritString( p_intf, "qt-slider-colours" ),
var_InheritInteger( p_intf, "qt-max-volume") );
}
else
{
volumeSlider = new QSlider( NULL );
volumeSlider->setAttribute( Qt::WA_MacSmallSize);
volumeSlider->setOrientation( b_special ? Qt::Vertical
: Qt::Horizontal );
volumeSlider->setMaximum( 200 );
}
volumeSlider->setFocusPolicy( Qt::NoFocus );
if( b_special )
subLayout->addWidget( volumeSlider );
else
layout->addWidget( volumeSlider, 0, b_shiny? Qt::AlignBottom : Qt::AlignCenter );
/* Set the volume from the config */
float volume = playlist_VolumeGet( THEPL );
libUpdateVolume( (volume >= 0.f) ? volume : 1.f );
/* Sync mute status */
if( playlist_MuteGet( THEPL ) > 0 )
updateMuteStatus( true );
/* Volume control connection */
volumeSlider->setTracking( true );
CONNECT( volumeSlider, valueChanged( int ), this, valueChangedFilter( int ) );
CONNECT( this, valueReallyChanged( int ), this, userUpdateVolume( int ) );
CONNECT( THEMIM, volumeChanged( float ), this, libUpdateVolume( float ) );
CONNECT( THEMIM, soundMuteChanged( bool ), this, updateMuteStatus( bool ) );
}
/* Video Panel constructor */
wxPanel *ExtraPanel::VideoPanel( wxWindow *parent )
{
char *psz_filters;
wxPanel *panel = new wxPanel( parent, -1 );
wxBoxSizer *panel_sizer = new wxBoxSizer( wxHORIZONTAL );
/* Create static box to surround the adjust controls */
wxStaticBox *adjust_box =
new wxStaticBox( panel, -1, wxU(_("Adjust Image")) );
wxStaticBoxSizer *adjust_sizer =
new wxStaticBoxSizer( adjust_box, wxVERTICAL );
adjust_sizer->SetMinSize( -1, 50 );
/* Create flex grid */
wxFlexGridSizer *adjust_gridsizer =
new wxFlexGridSizer( 6, 2, 0, 0);
adjust_gridsizer->AddGrowableCol(1);
/* Create the adjust button */
wxCheckBox * adjust_check = new wxCheckBox( panel, Adjust_Event,
wxU(_("Enable")));
/* Create the restore to defaults button */
restoredefaults_button =
new wxButton( panel, RestoreDefaults_Event,
wxU(_("Restore Defaults")), wxDefaultPosition);
wxStaticText *hue_text = new wxStaticText( panel, -1,
wxU(_("Hue")) );
hue_slider = new wxSlider ( panel, Hue_Event, 0, 0,
360, wxDefaultPosition, wxDefaultSize );
wxStaticText *contrast_text = new wxStaticText( panel, -1,
wxU(_("Contrast")) );
contrast_slider = new wxSlider ( panel, Contrast_Event, 0, 0,
200, wxDefaultPosition, wxDefaultSize);
wxStaticText *brightness_text = new wxStaticText( panel, -1,
wxU(_("Brightness")) );
brightness_slider = new wxSlider ( panel, Brightness_Event, 0, 0,
200, wxDefaultPosition, wxDefaultSize) ;
wxStaticText *saturation_text = new wxStaticText( panel, -1,
wxU(_("Saturation")) );
saturation_slider = new wxSlider ( panel, Saturation_Event, 0, 0,
300, wxDefaultPosition, wxDefaultSize );
wxStaticText *gamma_text = new wxStaticText( panel, -1,
wxU(_("Gamma")) );
gamma_slider = new wxSlider ( panel, Gamma_Event, 0, 0,
100, wxDefaultPosition, wxDefaultSize );
adjust_gridsizer->Add( adjust_check, 1, wxEXPAND|wxALL, 2 );
adjust_gridsizer->Add( restoredefaults_button, 1, wxEXPAND|wxALL, 2 );
adjust_gridsizer->Add( hue_text, 1, wxEXPAND|wxALL, 2 );
adjust_gridsizer->Add( hue_slider, 1, wxEXPAND|wxALL, 2 );
adjust_gridsizer->Add( contrast_text, 1, wxEXPAND|wxALL, 2 );
adjust_gridsizer->Add( contrast_slider, 1, wxEXPAND|wxALL, 2 );
adjust_gridsizer->Add( brightness_text, 1, wxEXPAND|wxALL, 2 );
adjust_gridsizer->Add( brightness_slider, 1, wxEXPAND|wxALL, 2 );
adjust_gridsizer->Add( saturation_text, 1, wxEXPAND|wxALL, 2 );
adjust_gridsizer->Add( saturation_slider, 1, wxEXPAND|wxALL, 2 );
adjust_gridsizer->Add( gamma_text, 1, wxEXPAND|wxALL, 2 );
adjust_gridsizer->Add( gamma_slider, 1, wxEXPAND|wxALL, 2 );
adjust_sizer->Add( adjust_gridsizer, 1, wxEXPAND|wxALL, 2);
panel_sizer->Add( adjust_sizer , 1, wxTOP, 2 );
#if 0
/* Create sizer to surround the other controls */
wxBoxSizer *other_sizer = new wxBoxSizer( wxVERTICAL );
wxStaticBox *video_box =
new wxStaticBox( panel, -1, wxU(_("Video Options")) );
/* Create the sizer for the frame */
wxStaticBoxSizer *video_sizer =
new wxStaticBoxSizer( video_box, wxVERTICAL );
video_sizer->SetMinSize( -1, 50 );
static const wxString ratio_array[] =
{
wxT("4:3"),
wxT("16:9"),
};
wxBoxSizer *ratio_sizer = new wxBoxSizer( wxHORIZONTAL );
wxStaticText *ratio_text = new wxStaticText( panel, -1,
wxU(_("Aspect Ratio")) );
ratio_combo = new wxComboBox( panel, Ratio_Event, wxT(""),
wxDefaultPosition, wxSize( 80 , -1),
WXSIZEOF(ratio_array), ratio_array,
0 );
ratio_sizer->Add( ratio_text, 0, wxALL, 2 );
ratio_sizer->Add( ratio_combo, 0, wxALL, 2 );
ratio_sizer->Layout();
video_sizer->Add( ratio_sizer , 0 , wxALL , 2 );
video_sizer->Layout();
#endif
wxStaticBox *filter_box =
new wxStaticBox( panel, -1, wxU(_("Video Filters")) );
wxStaticBoxSizer *filter_sizer =
new wxStaticBoxSizer( filter_box, wxHORIZONTAL );
wxBoxSizer *t_col_sizer = new wxBoxSizer( wxVERTICAL );
for( int i = 0 ; vfilters[i].psz_filter != NULL ; i++ )
{
wxCheckBox *box = new wxCheckBox( panel, Filter0_Event + i,
wxU( _( vfilters[i].psz_name ) ) );
t_col_sizer->Add( box, 0, wxALL, 4 );
box->SetToolTip( wxU( _( vfilters[i].psz_help ) ) );
}
filter_sizer->Add( t_col_sizer );
filter_sizer->Add( new wxButton( panel, FiltersInfo_Event,
wxU(_("More info" ) ) ), 0, wxALL, 4 );
#if 0
other_sizer->Add( video_sizer, 0, wxALL | wxEXPAND , 0);
other_sizer->Add( filter_sizer, 0, wxALL | wxEXPAND , 0);
other_sizer->Layout();
panel_sizer->Add(other_sizer , 1 );
#endif
panel_sizer->Add( filter_sizer, 1, wxTOP|wxLEFT, 2 );
panel->SetSizerAndFit( panel_sizer );
/* Layout the whole panel */
panel_sizer->Layout();
panel_sizer->SetSizeHints( panel );
/* Write down initial values */
psz_filters = config_GetPsz( p_intf, "filter" );
if( psz_filters && strstr( psz_filters, "adjust" ) )
{
adjust_check->SetValue( 1 );
restoredefaults_button->Enable();
saturation_slider->Enable();
contrast_slider->Enable();
brightness_slider->Enable();
hue_slider->Enable();
gamma_slider->Enable();
}
else
{
adjust_check->SetValue( 0 );
restoredefaults_button->Disable();
saturation_slider->Disable();
contrast_slider->Disable();
brightness_slider->Disable();
hue_slider->Disable();
gamma_slider->Disable();
}
if( psz_filters ) free( psz_filters );
int i_value = config_GetInt( p_intf, "hue" );
if( i_value > 0 && i_value < 360 )
hue_slider->SetValue( i_value );
float f_value;
f_value = config_GetFloat( p_intf, "saturation" );
if( f_value > 0 && f_value < 5 )
saturation_slider->SetValue( (int)(100 * f_value) );
f_value = config_GetFloat( p_intf, "contrast" );
if( f_value > 0 && f_value < 4 )
contrast_slider->SetValue( (int)(100 * f_value) );
f_value = config_GetFloat( p_intf, "brightness" );
if( f_value > 0 && f_value < 2 )
brightness_slider->SetValue( (int)(100 * f_value) );
f_value = config_GetFloat( p_intf, "gamma" );
if( f_value > 0 && f_value < 10 )
gamma_slider->SetValue( (int)(10 * f_value) );
return panel;
}
MainInterface::MainInterface( intf_thread_t *_p_intf ) : QVLCMW( _p_intf )
{
/* Variables initialisation */
// need_components_update = false;
bgWidget = NULL;
videoWidget = NULL;
playlistWidget = NULL;
#ifndef HAVE_MAEMO
sysTray = NULL;
#endif
videoIsActive = false;
playlistVisible = false;
input_name = "";
fullscreenControls = NULL;
cryptedLabel = NULL;
controls = NULL;
inputC = NULL;
b_shouldHide = false;
bgWasVisible = false;
i_bg_height = 0;
/* Ask for privacy */
askForPrivacy();
/**
* Configuration and settings
* Pre-building of interface
**/
/* Main settings */
setFocusPolicy( Qt::StrongFocus );
setAcceptDrops( true );
setWindowRole( "vlc-main" );
setWindowIcon( QApplication::windowIcon() );
setWindowOpacity( config_GetFloat( p_intf, "qt-opacity" ) );
/* Set The Video In emebedded Mode or not */
videoEmbeddedFlag = config_GetInt( p_intf, "embedded-video" );
/* Does the interface resize to video size or the opposite */
b_keep_size = !config_GetInt( p_intf, "qt-video-autoresize" );
/* Are we in the enhanced always-video mode or not ? */
i_visualmode = config_GetInt( p_intf, "qt-display-mode" );
/* Do we want anoying popups or not */
notificationEnabled = (bool)config_GetInt( p_intf, "qt-notification" );
/* Set the other interface settings */
settings = getSettings();
settings->beginGroup( "MainWindow" );
/**
* Retrieve saved sizes for main window
* mainBasedSize = based window size for normal mode
* (no video, no background)
* mainVideoSize = window size with video (all modes)
**/
mainBasedSize = settings->value( "mainBasedSize", QSize( 350, 120 ) ).toSize();
mainVideoSize = settings->value( "mainVideoSize", QSize( 400, 300 ) ).toSize();
/**************
* Status Bar *
**************/
createStatusBar();
/**************************
* UI and Widgets design
**************************/
setVLCWindowsTitle();
createMainWidget( settings );
/************
* Menu Bar *
************/
QVLCMenu::createMenuBar( this, p_intf );
CONNECT( THEMIM->getIM(), voutListChanged( vout_thread_t **, int ),
this, destroyPopupMenu() );
#if 0
/* Create a Dock to get the playlist */
dockPL = new QDockWidget( qtr( "Playlist" ), this );
dockPL->setSizePolicy( QSizePolicy::Preferred,
QSizePolicy::Expanding );
dockPL->setFeatures( QDockWidget::AllDockWidgetFeatures );
dockPL->setAllowedAreas( Qt::LeftDockWidgetArea
| Qt::RightDockWidgetArea
| Qt::BottomDockWidgetArea );
dockPL->hide();
#endif
/*********************************
* Create the Systray Management *
*********************************/
initSystray();
/********************
* Input Manager *
********************/
MainInputManager::getInstance( p_intf );
/************************************************************
* Connect the input manager to the GUI elements it manages *
************************************************************/
/**
* Connects on nameChanged()
* Those connects are different because options can impeach them to trigger.
**/
/* Main Interface statusbar */
CONNECT( THEMIM->getIM(), nameChanged( const QString& ),
this, setName( const QString& ) );
/* and systray */
#ifndef HAVE_MAEMO
if( sysTray )
{
CONNECT( THEMIM->getIM(), nameChanged( const QString& ),
this, updateSystrayTooltipName( const QString& ) );
}
#endif
/* and title of the Main Interface*/
if( config_GetInt( p_intf, "qt-name-in-title" ) )
{
CONNECT( THEMIM->getIM(), nameChanged( const QString& ),
this, setVLCWindowsTitle( const QString& ) );
}
/*****************************************************************************
* Constructor.
*****************************************************************************/
SubsFileDialog::SubsFileDialog( intf_thread_t *_p_intf, wxWindow* _p_parent ):
wxDialog( _p_parent, -1, wxU(_("Subtitle options")),
wxDefaultPosition, wxDefaultSize, wxDEFAULT_FRAME_STYLE )
{
/* Initializations */
p_intf = _p_intf;
p_parent = _p_parent;
SetIcon( *p_intf->p_sys->p_icon );
/* Create a panel to put everything in */
wxPanel *panel = new wxPanel( this, -1 );
panel->SetAutoLayout( TRUE );
wxBoxSizer *main_sizer = new wxBoxSizer( wxVERTICAL );
wxBoxSizer *panel_sizer = new wxBoxSizer( wxVERTICAL );
/* Create the subtitles file textctrl */
wxBoxSizer *file_sizer_sizer = new wxBoxSizer( wxHORIZONTAL );
wxStaticBox *file_box = new wxStaticBox( panel, -1,
wxU(_("Subtitles file")) );
wxStaticBoxSizer *file_sizer = new wxStaticBoxSizer( file_box,
wxHORIZONTAL );
char *psz_subsfile = config_GetPsz( p_intf, "sub-file" );
if( !psz_subsfile ) psz_subsfile = strdup("");
file_combo = new wxComboBox( panel, -1, wxL2U(psz_subsfile),
wxPoint(20,25), wxSize(300, -1), 0, NULL );
if( psz_subsfile ) free( psz_subsfile );
wxButton *browse_button = new wxButton( panel, FileBrowse_Event,
wxU(_("Browse...")) );
file_sizer->Add( file_combo, 1, wxALL, 5 );
file_sizer->Add( browse_button, 0, wxALL, 5 );
file_sizer_sizer->Add( file_sizer, 1, wxEXPAND | wxALL, 5 );
panel_sizer->Add( file_sizer, 0, wxEXPAND | wxALL, 5 );
/* Subtitles encoding */
encoding_combo = NULL;
module_config_t *p_item =
config_FindConfig( VLC_OBJECT(p_intf), "subsdec-encoding" );
if( p_item )
{
wxBoxSizer *enc_sizer_sizer = new wxBoxSizer( wxHORIZONTAL );
wxStaticBox *enc_box = new wxStaticBox( panel, -1,
wxU(_("Subtitles encoding")) );
wxStaticBoxSizer *enc_sizer = new wxStaticBoxSizer( enc_box,
wxHORIZONTAL );
wxStaticText *label =
new wxStaticText(panel, -1, wxU(p_item->psz_text));
encoding_combo = new wxComboBox( panel, -1, wxU(p_item->psz_value),
wxDefaultPosition, wxDefaultSize,
0, NULL, wxCB_READONLY );
/* build a list of available options */
for( int i_index = 0; p_item->ppsz_list && p_item->ppsz_list[i_index];
i_index++ )
{
encoding_combo->Append( wxU(p_item->ppsz_list[i_index]) );
if( p_item->psz_value && !strcmp( p_item->psz_value,
p_item->ppsz_list[i_index] ) )
encoding_combo->SetSelection( i_index );
}
if( p_item->psz_value )
encoding_combo->SetValue( wxU(p_item->psz_value) );
encoding_combo->SetToolTip( wxU(p_item->psz_longtext) );
enc_sizer->Add( label, 0, wxALL | wxALIGN_CENTER, 5 );
enc_sizer->Add( encoding_combo, 0, wxEXPAND | wxALL | wxALIGN_CENTER, 5 );
enc_sizer_sizer->Add( enc_sizer, 1, wxEXPAND | wxALL, 5 );
panel_sizer->Add( enc_sizer, 0, wxEXPAND | wxALL, 5 );
}
/* Misc Subtitles options */
wxBoxSizer *misc_sizer_sizer = new wxBoxSizer( wxHORIZONTAL );
wxStaticBox *misc_box = new wxStaticBox( panel, -1,
wxU(_("Subtitles options")) );
wxStaticBoxSizer *misc_sizer = new wxStaticBoxSizer( misc_box,
wxVERTICAL );
wxFlexGridSizer *grid_sizer = new wxFlexGridSizer( 2, 1, 20 );
/* Font size */
p_item =
config_FindConfig( VLC_OBJECT(p_intf), "freetype-rel-fontsize" );
if( p_item )
{
wxBoxSizer *size_sizer = new wxBoxSizer( wxHORIZONTAL );
wxStaticText *label =
new wxStaticText(panel, -1, wxU(p_item->psz_text));
size_combo = new wxComboBox( panel, -1, wxT(""),
wxDefaultPosition, wxDefaultSize,
0, NULL, wxCB_READONLY );
/* build a list of available options */
for( int i_index = 0; i_index < p_item->i_list; i_index++ )
{
size_combo->Append( wxU(p_item->ppsz_list_text[i_index]),
(void *)p_item->pi_list[i_index] );
if( p_item->i_value == p_item->pi_list[i_index] )
{
size_combo->SetSelection( i_index );
size_combo->SetValue(wxU(p_item->ppsz_list_text[i_index]));
}
}
size_combo->SetToolTip( wxU(p_item->psz_longtext) );
size_sizer->Add( label, 0, wxRIGHT | wxALIGN_CENTER, 5 );
size_sizer->Add( size_combo, 0, wxLEFT | wxALIGN_CENTER, 5 );
grid_sizer->Add( size_sizer, 1, wxEXPAND | wxALL, 5 );
}
p_item =
config_FindConfig( VLC_OBJECT(p_intf), "subsdec-align" );
if( p_item )
{
wxBoxSizer *align_sizer = new wxBoxSizer( wxHORIZONTAL );
wxStaticText *label =
new wxStaticText(panel, -1, wxU(p_item->psz_text));
align_combo = new wxComboBox( panel, -1, wxT(""),
wxDefaultPosition, wxDefaultSize,
0, NULL, wxCB_READONLY );
/* build a list of available options */
for( int i_index = 0; i_index < p_item->i_list; i_index++ )
{
align_combo->Append( wxU(p_item->ppsz_list_text[i_index]),
(void *)p_item->pi_list[i_index] );
if( p_item->i_value == p_item->pi_list[i_index] )
{
align_combo->SetSelection( i_index );
align_combo->SetValue(wxU(p_item->ppsz_list_text[i_index]));
}
}
align_combo->SetToolTip( wxU(p_item->psz_longtext) );
align_sizer->Add( label, 0, wxRIGHT | wxALIGN_CENTER, 5 );
align_sizer->Add( align_combo, 0, wxLEFT | wxALIGN_CENTER, 5 );
grid_sizer->Add( align_sizer, 1, wxEXPAND | wxALL, 5 );
}
misc_sizer->Add( grid_sizer, 1, wxEXPAND | wxALL , 5 );
grid_sizer = new wxFlexGridSizer( 4, 1, 20 );
wxStaticText *label =
new wxStaticText(panel, -1, wxU(_("Frames per second")));
float f_fps = config_GetFloat( p_intf, "sub-fps" );
/* Outside the new wxSpinCtrl to avoid an internal error in gcc2.95 ! */
wxString format_fps(wxString::Format(wxT("%d"),(int)f_fps));
fps_spinctrl = new wxSpinCtrl( panel, -1, format_fps,
wxDefaultPosition, wxDefaultSize,
wxSP_ARROW_KEYS,
0, 16000, (int)f_fps );
fps_spinctrl->SetToolTip( wxU(_("Override frames per second. "
"It will only work with MicroDVD and SubRIP subtitles.")) );
grid_sizer->Add( label, 0, wxALIGN_CENTER, 5 );
grid_sizer->Add( fps_spinctrl, 0,wxALIGN_CENTER, 5 );
wxStaticText *label_delay =
new wxStaticText(panel, -1, wxU(_("Delay")));
int i_delay = config_GetInt( p_intf, "sub-delay" );
/* Outside the new wxSpinCtrl to avoid an internal error in gcc2.95 ! */
wxString format_delay(wxString::Format(wxT("%i"), i_delay ));
delay_spinctrl = new wxSpinCtrl( panel, -1, format_delay,
wxDefaultPosition, wxDefaultSize,
wxSP_ARROW_KEYS,
0, 16000, i_delay );
delay_spinctrl->SetToolTip( wxU(_("Set subtitle delay (in 1/10s)" ) ) );
grid_sizer->Add( label_delay , 0, wxALIGN_CENTER, 5 );
grid_sizer->Add( delay_spinctrl, 0, wxALIGN_CENTER, 5 );
misc_sizer->Add( grid_sizer, 0, wxALL, 5 );
misc_sizer_sizer->Add( misc_sizer, 1, wxEXPAND | wxALL, 5 );
panel_sizer->Add( misc_sizer, 0, wxEXPAND | wxALL, 5 );
/* Separation */
wxStaticLine *static_line = new wxStaticLine( panel, wxID_OK );
/* Create the buttons */
wxButton *ok_button = new wxButton( panel, wxID_OK, wxU(_("OK")) );
ok_button->SetDefault();
wxButton *cancel_button = new wxButton( panel, wxID_CANCEL,
wxU(_("Cancel")) );
/* Place everything in sizers */
wxBoxSizer *button_sizer = new wxBoxSizer( wxHORIZONTAL );
button_sizer->Add( ok_button, 0, wxALL, 5 );
button_sizer->Add( cancel_button, 0, wxALL, 5 );
button_sizer->Layout();
panel_sizer->Add( static_line, 0, wxEXPAND | wxALL, 5 );
panel_sizer->Add( button_sizer, 0, wxALIGN_LEFT | wxALIGN_BOTTOM |
wxALL, 5 );
panel_sizer->Layout();
panel->SetSizerAndFit( panel_sizer );
main_sizer->Add( panel, 1, wxGROW, 0 );
main_sizer->Layout();
SetSizerAndFit( main_sizer );
}
/*****************************************************************************
* InheritValue: try to inherit the value of this variable from the same one
* in our closest parent.
*****************************************************************************/
static int InheritValue( vlc_object_t *p_this, const char *psz_name,
vlc_value_t *p_val, int i_type )
{
int i_var;
variable_t *p_var;
/* No need to take the structure lock,
* we are only looking for our parents */
if( !p_this->p_parent )
{
switch( i_type & VLC_VAR_TYPE )
{
case VLC_VAR_FILE:
case VLC_VAR_DIRECTORY:
case VLC_VAR_STRING:
case VLC_VAR_MODULE:
p_val->psz_string = config_GetPsz( p_this, psz_name );
if( !p_val->psz_string ) p_val->psz_string = strdup("");
break;
case VLC_VAR_FLOAT:
p_val->f_float = config_GetFloat( p_this, psz_name );
break;
case VLC_VAR_INTEGER:
case VLC_VAR_HOTKEY:
p_val->i_int = config_GetInt( p_this, psz_name );
break;
case VLC_VAR_BOOL:
p_val->b_bool = config_GetInt( p_this, psz_name );
break;
case VLC_VAR_LIST:
{
char *psz_orig, *psz_var;
vlc_list_t *p_list = malloc(sizeof(vlc_list_t));
p_val->p_list = p_list;
p_list->i_count = 0;
psz_var = psz_orig = config_GetPsz( p_this, psz_name );
while( psz_var && *psz_var )
{
char *psz_item = psz_var;
vlc_value_t val;
while( *psz_var && *psz_var != ',' ) psz_var++;
if( *psz_var == ',' )
{
*psz_var = '\0';
psz_var++;
}
val.i_int = strtol( psz_item, NULL, 0 );
INSERT_ELEM( p_list->p_values, p_list->i_count,
p_list->i_count, val );
/* p_list->i_count is incremented twice by INSERT_ELEM */
p_list->i_count--;
INSERT_ELEM( p_list->pi_types, p_list->i_count,
p_list->i_count, VLC_VAR_INTEGER );
}
if( psz_orig ) free( psz_orig );
break;
}
default:
return VLC_ENOOBJ;
break;
}
return VLC_SUCCESS;
}
/* Look for the variable */
vlc_mutex_lock( &p_this->p_parent->var_lock );
i_var = Lookup( p_this->p_parent->p_vars, p_this->p_parent->i_vars,
psz_name );
if( i_var >= 0 )
{
/* We found it! */
p_var = &p_this->p_parent->p_vars[i_var];
/* Really get the variable */
*p_val = p_var->val;
/* Duplicate value if needed */
p_var->pf_dup( p_val );
vlc_mutex_unlock( &p_this->p_parent->var_lock );
return VLC_SUCCESS;
}
vlc_mutex_unlock( &p_this->p_parent->var_lock );
/* We're still not there */
return InheritValue( p_this->p_parent, psz_name, p_val, i_type );
}
void EvaluateRPN( intf_thread_t *p_intf, mvar_t *vars,
rpn_stack_t *st, char *exp )
{
intf_sys_t *p_sys = p_intf->p_sys;
while( exp != NULL && *exp != '\0' )
{
char *p, *s;
/* skip space */
while( *exp == ' ' )
{
exp++;
}
if( *exp == '\'' )
{
/* extract string */
p = FirstWord( exp, exp );
SSPush( st, exp );
exp = p;
continue;
}
/* extract token */
p = FirstWord( exp, exp );
s = exp;
if( p == NULL )
{
exp += strlen( exp );
}
else
{
exp = p;
}
if( *s == '\0' )
{
break;
}
/* 1. Integer function */
if( !strcmp( s, "!" ) )
{
SSPushN( st, ~SSPopN( st, vars ) );
}
else if( !strcmp( s, "^" ) )
{
SSPushN( st, SSPopN( st, vars ) ^ SSPopN( st, vars ) );
}
else if( !strcmp( s, "&" ) )
{
SSPushN( st, SSPopN( st, vars ) & SSPopN( st, vars ) );
}
else if( !strcmp( s, "|" ) )
{
SSPushN( st, SSPopN( st, vars ) | SSPopN( st, vars ) );
}
else if( !strcmp( s, "+" ) )
{
SSPushN( st, SSPopN( st, vars ) + SSPopN( st, vars ) );
}
else if( !strcmp( s, "-" ) )
{
int j = SSPopN( st, vars );
int i = SSPopN( st, vars );
SSPushN( st, i - j );
}
else if( !strcmp( s, "*" ) )
{
SSPushN( st, SSPopN( st, vars ) * SSPopN( st, vars ) );
}
else if( !strcmp( s, "/" ) )
{
int i, j;
j = SSPopN( st, vars );
i = SSPopN( st, vars );
SSPushN( st, j != 0 ? i / j : 0 );
}
else if( !strcmp( s, "%" ) )
{
int i, j;
j = SSPopN( st, vars );
i = SSPopN( st, vars );
SSPushN( st, j != 0 ? i % j : 0 );
}
/* 2. integer tests */
else if( !strcmp( s, "=" ) )
{
SSPushN( st, SSPopN( st, vars ) == SSPopN( st, vars ) ? -1 : 0 );
}
else if( !strcmp( s, "!=" ) )
{
SSPushN( st, SSPopN( st, vars ) != SSPopN( st, vars ) ? -1 : 0 );
}
else if( !strcmp( s, "<" ) )
{
int j = SSPopN( st, vars );
int i = SSPopN( st, vars );
SSPushN( st, i < j ? -1 : 0 );
}
else if( !strcmp( s, ">" ) )
{
int j = SSPopN( st, vars );
int i = SSPopN( st, vars );
SSPushN( st, i > j ? -1 : 0 );
}
else if( !strcmp( s, "<=" ) )
{
int j = SSPopN( st, vars );
int i = SSPopN( st, vars );
SSPushN( st, i <= j ? -1 : 0 );
}
else if( !strcmp( s, ">=" ) )
{
int j = SSPopN( st, vars );
int i = SSPopN( st, vars );
SSPushN( st, i >= j ? -1 : 0 );
}
/* 3. string functions */
else if( !strcmp( s, "strcat" ) )
{
char *s2 = SSPop( st );
char *s1 = SSPop( st );
char *str = malloc( strlen( s1 ) + strlen( s2 ) + 1 );
strcpy( str, s1 );
strcat( str, s2 );
SSPush( st, str );
free( s1 );
free( s2 );
free( str );
}
else if( !strcmp( s, "strcmp" ) )
{
char *s2 = SSPop( st );
char *s1 = SSPop( st );
SSPushN( st, strcmp( s1, s2 ) );
free( s1 );
free( s2 );
}
else if( !strcmp( s, "strncmp" ) )
{
int n = SSPopN( st, vars );
char *s2 = SSPop( st );
char *s1 = SSPop( st );
SSPushN( st, strncmp( s1, s2 , n ) );
free( s1 );
free( s2 );
}
else if( !strcmp( s, "strsub" ) )
{
int n = SSPopN( st, vars );
int m = SSPopN( st, vars );
int i_len;
char *s = SSPop( st );
char *str;
if( n >= m )
{
i_len = n - m + 1;
}
else
{
i_len = 0;
}
str = malloc( i_len + 1 );
memcpy( str, s + m - 1, i_len );
str[ i_len ] = '\0';
SSPush( st, str );
free( s );
free( str );
}
else if( !strcmp( s, "strlen" ) )
{
char *str = SSPop( st );
SSPushN( st, strlen( str ) );
free( str );
}
else if( !strcmp( s, "str_replace" ) )
{
char *psz_to = SSPop( st );
char *psz_from = SSPop( st );
char *psz_in = SSPop( st );
char *psz_in_current = psz_in;
char *psz_out = malloc( strlen(psz_in) * strlen(psz_to) + 1 );
char *psz_out_current = psz_out;
while( (p = strstr( psz_in_current, psz_from )) != NULL )
{
memcpy( psz_out_current, psz_in_current, p - psz_in_current );
psz_out_current += p - psz_in_current;
strcpy( psz_out_current, psz_to );
psz_out_current += strlen(psz_to);
psz_in_current = p + strlen(psz_from);
}
strcpy( psz_out_current, psz_in_current );
psz_out_current += strlen(psz_in_current);
*psz_out_current = '\0';
SSPush( st, psz_out );
free( psz_to );
free( psz_from );
free( psz_in );
free( psz_out );
}
else if( !strcmp( s, "url_extract" ) )
{
const char *url = mvar_GetValue( vars, "url_value" );
char *name = SSPop( st );
char *value = ExtractURIString( url, name );
if( value != NULL )
{
decode_URI( value );
SSPush( st, value );
free( value );
}
else
SSPush( st, "" );
free( name );
}
else if( !strcmp( s, "url_encode" ) )
{
char *url = SSPop( st );
char *value = vlc_UrlEncode( url );
free( url );
SSPush( st, value );
free( value );
}
else if( !strcmp( s, "xml_encode" )
|| !strcmp( s, "htmlspecialchars" ) )
{
char *url = SSPop( st );
char *value = convert_xml_special_chars( url );
free( url );
SSPush( st, value );
free( value );
}
else if( !strcmp( s, "addslashes" ) )
{
char *psz_src = SSPop( st );
char *psz_dest;
char *str = psz_src;
p = psz_dest = malloc( strlen( str ) * 2 + 1 );
while( *str != '\0' )
{
if( *str == '"' || *str == '\'' || *str == '\\' )
{
*p++ = '\\';
}
*p++ = *str;
str++;
}
*p = '\0';
SSPush( st, psz_dest );
free( psz_src );
free( psz_dest );
}
else if( !strcmp( s, "stripslashes" ) )
{
char *psz_src = SSPop( st );
char *psz_dest;
char *str = psz_src;
p = psz_dest = strdup( psz_src );
while( *str )
{
if( *str == '\\' && *(str + 1) )
{
str++;
}
*p++ = *str++;
}
*p = '\0';
SSPush( st, psz_dest );
free( psz_src );
free( psz_dest );
}
else if( !strcmp( s, "realpath" ) )
{
char *psz_src = SSPop( st );
char *psz_dir = RealPath( psz_src );
SSPush( st, psz_dir );
free( psz_src );
free( psz_dir );
}
/* 4. stack functions */
else if( !strcmp( s, "dup" ) )
{
char *str = SSPop( st );
SSPush( st, str );
SSPush( st, str );
free( str );
}
else if( !strcmp( s, "drop" ) )
{
char *str = SSPop( st );
free( str );
}
else if( !strcmp( s, "swap" ) )
{
char *s1 = SSPop( st );
char *s2 = SSPop( st );
SSPush( st, s1 );
SSPush( st, s2 );
free( s1 );
free( s2 );
}
else if( !strcmp( s, "flush" ) )
{
SSClean( st );
SSInit( st );
}
else if( !strcmp( s, "store" ) )
{
char *value = SSPop( st );
char *name = SSPop( st );
mvar_PushNewVar( vars, name, value );
free( name );
free( value );
}
else if( !strcmp( s, "value" ) )
{
char *name = SSPop( st );
const char *value = mvar_GetValue( vars, name );
SSPush( st, value );
free( name );
}
/* 5. player control */
else if( !strcmp( s, "vlc_play" ) )
{
int i_id = SSPopN( st, vars );
int i_ret;
playlist_Lock( p_sys->p_playlist );
i_ret = playlist_Control( p_sys->p_playlist, PLAYLIST_VIEWPLAY,
pl_Locked, NULL,
playlist_ItemGetById( p_sys->p_playlist,
i_id ) );
playlist_Unlock( p_sys->p_playlist );
msg_Dbg( p_intf, "requested playlist item: %i", i_id );
SSPushN( st, i_ret );
}
else if( !strcmp( s, "vlc_stop" ) )
{
playlist_Control( p_sys->p_playlist, PLAYLIST_STOP, pl_Unlocked );
msg_Dbg( p_intf, "requested playlist stop" );
}
else if( !strcmp( s, "vlc_pause" ) )
{
playlist_Control( p_sys->p_playlist, PLAYLIST_PAUSE, pl_Unlocked );
msg_Dbg( p_intf, "requested playlist pause" );
}
else if( !strcmp( s, "vlc_next" ) )
{
playlist_Control( p_sys->p_playlist, PLAYLIST_SKIP, pl_Unlocked, 1 );
msg_Dbg( p_intf, "requested playlist next" );
}
else if( !strcmp( s, "vlc_previous" ) )
{
playlist_Control( p_sys->p_playlist, PLAYLIST_SKIP, pl_Unlocked, -1 );
msg_Dbg( p_intf, "requested playlist previous" );
}
else if( !strcmp( s, "vlc_seek" ) )
{
char *psz_value = SSPop( st );
HandleSeek( p_intf, psz_value );
msg_Dbg( p_intf, "requested playlist seek: %s", psz_value );
free( psz_value );
}
else if( !strcmp( s, "vlc_var_type" )
|| !strcmp( s, "vlc_config_type" ) )
{
vlc_object_t *p_object;
const char *psz_type = NULL;
int i_type = 0;
if( !strcmp( s, "vlc_var_type" ) )
{
char *psz_object = SSPop( st );
char *psz_variable = SSPop( st );
bool b_need_release;
p_object = GetVLCObject( p_intf, psz_object, &b_need_release );
if( p_object != NULL )
i_type = var_Type( p_object, psz_variable );
free( psz_variable );
free( psz_object );
if( b_need_release && p_object != NULL )
vlc_object_release( p_object );
}
else
{
char *psz_variable = SSPop( st );
p_object = VLC_OBJECT(p_intf);
i_type = config_GetType( p_object, psz_variable );
free( psz_variable );
}
if( p_object != NULL )
{
switch( i_type & VLC_VAR_TYPE )
{
case VLC_VAR_BOOL:
psz_type = "VLC_VAR_BOOL";
break;
case VLC_VAR_INTEGER:
psz_type = "VLC_VAR_INTEGER";
break;
case VLC_VAR_HOTKEY:
psz_type = "VLC_VAR_HOTKEY";
break;
case VLC_VAR_STRING:
psz_type = "VLC_VAR_STRING";
break;
case VLC_VAR_MODULE:
psz_type = "VLC_VAR_MODULE";
break;
case VLC_VAR_FILE:
psz_type = "VLC_VAR_FILE";
break;
case VLC_VAR_DIRECTORY:
psz_type = "VLC_VAR_DIRECTORY";
break;
case VLC_VAR_VARIABLE:
psz_type = "VLC_VAR_VARIABLE";
break;
case VLC_VAR_FLOAT:
psz_type = "VLC_VAR_FLOAT";
break;
default:
psz_type = "UNDEFINED";
}
}
else
psz_type = "INVALID";
SSPush( st, psz_type );
}
else if( !strcmp( s, "vlc_var_set" ) )
{
char *psz_object = SSPop( st );
char *psz_variable = SSPop( st );
bool b_need_release;
vlc_object_t *p_object = GetVLCObject( p_intf, psz_object,
&b_need_release );
if( p_object != NULL )
{
bool b_error = false;
char *psz_value = NULL;
vlc_value_t val;
int i_type;
i_type = var_Type( p_object, psz_variable );
switch( i_type & VLC_VAR_TYPE )
{
case VLC_VAR_BOOL:
val.b_bool = SSPopN( st, vars );
msg_Dbg( p_intf, "requested %s var change: %s->%d",
psz_object, psz_variable, val.b_bool );
break;
case VLC_VAR_INTEGER:
case VLC_VAR_HOTKEY:
val.i_int = SSPopN( st, vars );
msg_Dbg( p_intf, "requested %s var change: %s->%d",
psz_object, psz_variable, val.i_int );
break;
case VLC_VAR_STRING:
case VLC_VAR_MODULE:
case VLC_VAR_FILE:
case VLC_VAR_DIRECTORY:
case VLC_VAR_VARIABLE:
val.psz_string = psz_value = SSPop( st );
msg_Dbg( p_intf, "requested %s var change: %s->%s",
psz_object, psz_variable, psz_value );
break;
case VLC_VAR_FLOAT:
psz_value = SSPop( st );
val.f_float = atof( psz_value );
msg_Dbg( p_intf, "requested %s var change: %s->%f",
psz_object, psz_variable, val.f_float );
break;
default:
SSPopN( st, vars );
msg_Warn( p_intf, "invalid %s variable type %d (%s)",
psz_object, i_type & VLC_VAR_TYPE, psz_variable );
b_error = true;
}
if( !b_error )
var_Set( p_object, psz_variable, val );
if( psz_value != NULL )
free( psz_value );
}
else
msg_Warn( p_intf, "vlc_var_set called without an object" );
free( psz_variable );
free( psz_object );
if( b_need_release && p_object != NULL )
vlc_object_release( p_object );
}
else if( !strcmp( s, "vlc_var_get" ) )
{
char *psz_object = SSPop( st );
char *psz_variable = SSPop( st );
bool b_need_release;
vlc_object_t *p_object = GetVLCObject( p_intf, psz_object,
&b_need_release );
if( p_object != NULL )
{
vlc_value_t val;
int i_type;
i_type = var_Type( p_object, psz_variable );
var_Get( p_object, psz_variable, &val );
switch( i_type & VLC_VAR_TYPE )
{
case VLC_VAR_BOOL:
SSPushN( st, val.b_bool );
break;
case VLC_VAR_INTEGER:
case VLC_VAR_HOTKEY:
SSPushN( st, val.i_int );
break;
case VLC_VAR_STRING:
case VLC_VAR_MODULE:
case VLC_VAR_FILE:
case VLC_VAR_DIRECTORY:
case VLC_VAR_VARIABLE:
SSPush( st, val.psz_string );
free( val.psz_string );
break;
case VLC_VAR_FLOAT:
{
char psz_value[20];
lldiv_t value = lldiv( val.f_float * 1000000, 1000000 );
snprintf( psz_value, sizeof(psz_value), "%lld.%06u",
value.quot, (unsigned int)value.rem );
SSPush( st, psz_value );
break;
}
default:
msg_Warn( p_intf, "invalid %s variable type %d (%s)",
psz_object, i_type & VLC_VAR_TYPE, psz_variable );
SSPush( st, "" );
}
}
else
{
msg_Warn( p_intf, "vlc_var_get called without an object" );
SSPush( st, "" );
}
free( psz_variable );
free( psz_object );
if( b_need_release && p_object != NULL )
vlc_object_release( p_object );
}
else if( !strcmp( s, "vlc_object_exists" ) )
{
char *psz_object = SSPop( st );
bool b_need_release;
vlc_object_t *p_object = GetVLCObject( p_intf, psz_object,
&b_need_release );
if( b_need_release && p_object != NULL )
vlc_object_release( p_object );
if( p_object != NULL )
SSPush( st, "1" );
else
SSPush( st, "0" );
}
else if( !strcmp( s, "vlc_config_set" ) )
{
char *psz_variable = SSPop( st );
int i_type = config_GetType( p_intf, psz_variable );
switch( i_type & VLC_VAR_TYPE )
{
case VLC_VAR_BOOL:
case VLC_VAR_INTEGER:
config_PutInt( p_intf, psz_variable, SSPopN( st, vars ) );
break;
case VLC_VAR_STRING:
case VLC_VAR_MODULE:
case VLC_VAR_FILE:
case VLC_VAR_DIRECTORY:
{
char *psz_string = SSPop( st );
config_PutPsz( p_intf, psz_variable, psz_string );
free( psz_string );
break;
}
case VLC_VAR_FLOAT:
{
char *psz_string = SSPop( st );
config_PutFloat( p_intf, psz_variable, atof(psz_string) );
free( psz_string );
break;
}
default:
msg_Warn( p_intf, "vlc_config_set called on unknown var (%s)",
psz_variable );
}
free( psz_variable );
}
else if( !strcmp( s, "vlc_config_get" ) )
{
char *psz_variable = SSPop( st );
int i_type = config_GetType( p_intf, psz_variable );
switch( i_type & VLC_VAR_TYPE )
{
case VLC_VAR_BOOL:
case VLC_VAR_INTEGER:
SSPushN( st, config_GetInt( p_intf, psz_variable ) );
break;
case VLC_VAR_STRING:
case VLC_VAR_MODULE:
case VLC_VAR_FILE:
case VLC_VAR_DIRECTORY:
{
char *psz_string = config_GetPsz( p_intf, psz_variable );
SSPush( st, psz_string );
free( psz_string );
break;
}
case VLC_VAR_FLOAT:
{
char psz_string[20];
lldiv_t value = lldiv( config_GetFloat( p_intf, psz_variable )
* 1000000, 1000000 );
snprintf( psz_string, sizeof(psz_string), "%lld.%06u",
value.quot, (unsigned int)value.rem );
SSPush( st, psz_string );
break;
}
default:
msg_Warn( p_intf, "vlc_config_get called on unknown var (%s)",
psz_variable );
SSPush( st, "" );
}
free( psz_variable );
}
else if( !strcmp( s, "vlc_config_save" ) )
{
char *psz_module = SSPop( st );
int i_result;
if( !*psz_module )
{
free( psz_module );
psz_module = NULL;
}
i_result = config_SaveConfigFile( p_intf, psz_module );
if( psz_module != NULL )
free( psz_module );
SSPushN( st, i_result );
}
else if( !strcmp( s, "vlc_config_reset" ) )
{
config_ResetAll( p_intf );
}
/* 6. playlist functions */
else if( !strcmp( s, "playlist_add" ) )
{
char *psz_name = SSPop( st );
char *mrl = SSPop( st );
input_item_t *p_input;
int i_ret;
p_input = MRLParse( p_intf, mrl, psz_name );
char *psz_uri = input_item_GetURI( p_input );
if( !p_input || !psz_uri || !*psz_uri )
{
i_ret = VLC_EGENERIC;
msg_Dbg( p_intf, "invalid requested mrl: %s", mrl );
}
else
{
i_ret = playlist_AddInput( p_sys->p_playlist, p_input,
PLAYLIST_APPEND, PLAYLIST_END, true,
pl_Unlocked );
if( i_ret == VLC_SUCCESS )
{
playlist_item_t *p_item;
msg_Dbg( p_intf, "requested mrl add: %s", mrl );
playlist_Lock( p_sys->p_playlist );
p_item = playlist_ItemGetByInput( p_sys->p_playlist,
p_input );
if( p_item )
i_ret = p_item->i_id;
playlist_Unlock( p_sys->p_playlist );
}
else
msg_Warn( p_intf, "adding mrl %s failed", mrl );
vlc_gc_decref( p_input );
}
free( psz_uri );
SSPushN( st, i_ret );
free( mrl );
free( psz_name );
}
else if( !strcmp( s, "playlist_empty" ) )
{
playlist_Clear( p_sys->p_playlist, pl_Unlocked );
msg_Dbg( p_intf, "requested playlist empty" );
}
else if( !strcmp( s, "playlist_delete" ) )
{
int i_id = SSPopN( st, vars );
playlist_Lock( p_sys->p_playlist );
playlist_item_t *p_item = playlist_ItemGetById( p_sys->p_playlist,
i_id );
if( p_item )
{
playlist_DeleteFromInput( p_sys->p_playlist,
p_item->p_input, pl_Locked );
msg_Dbg( p_intf, "requested playlist delete: %d", i_id );
}
else
{
msg_Dbg( p_intf, "couldn't find playlist item to delete (%d)",
i_id );
}
playlist_Unlock( p_sys->p_playlist );
}
else if( !strcmp( s, "playlist_move" ) )
{
/*int i_newpos =*/ SSPopN( st, vars );
/*int i_pos =*/ SSPopN( st, vars );
/* FIXME FIXME TODO TODO XXX XXX
do not release before fixing this
if ( i_pos < i_newpos )
{
playlist_Move( p_sys->p_playlist, i_pos, i_newpos + 1 );
}
else
{
playlist_Move( p_sys->p_playlist, i_pos, i_newpos );
}
msg_Dbg( p_intf, "requested to move playlist item %d to %d",
i_pos, i_newpos);
FIXME FIXME TODO TODO XXX XXX */
msg_Err( p_intf, "moving using indexes is obsolete. We need to update this function" );
}
else if( !strcmp( s, "playlist_sort" ) )
{
int i_order = SSPopN( st, vars );
int i_sort = SSPopN( st, vars );
i_order = i_order % 2;
i_sort = i_sort % 9;
/* FIXME FIXME TODO TODO XXX XXX
do not release before fixing this
playlist_RecursiveNodeSort( p_sys->p_playlist,
p_sys->p_playlist->p_general,
i_sort, i_order );
msg_Dbg( p_intf, "requested sort playlist by : %d in order : %d",
i_sort, i_order );
FIXME FIXME TODO TODO XXX XXX */
msg_Err( p_intf, "this needs to be fixed to use the new playlist framework" );
}
else if( !strcmp( s, "services_discovery_add" ) )
{
char *psz_sd = SSPop( st );
playlist_ServicesDiscoveryAdd( p_sys->p_playlist, psz_sd );
free( psz_sd );
}
else if( !strcmp( s, "services_discovery_remove" ) )
{
char *psz_sd = SSPop( st );
playlist_ServicesDiscoveryRemove( p_sys->p_playlist, psz_sd );
free( psz_sd );
}
else if( !strcmp( s, "services_discovery_is_loaded" ) )
{
char *psz_sd = SSPop( st );
SSPushN( st,
playlist_IsServicesDiscoveryLoaded( p_sys->p_playlist, psz_sd ) );
free( psz_sd );
}
else if( !strcmp( s, "vlc_volume_set" ) )
{
char *psz_vol = SSPop( st );
int i_value;
audio_volume_t i_volume;
aout_VolumeGet( p_intf, &i_volume );
if( psz_vol[0] == '+' )
{
i_value = atoi( psz_vol );
if( (i_volume + i_value) > AOUT_VOLUME_MAX )
aout_VolumeSet( p_intf, AOUT_VOLUME_MAX );
else
aout_VolumeSet( p_intf, i_volume + i_value );
}
else if( psz_vol[0] == '-' )
{
i_value = atoi( psz_vol );
if( (i_volume + i_value) < AOUT_VOLUME_MIN )
aout_VolumeSet( p_intf, AOUT_VOLUME_MIN );
else
aout_VolumeSet( p_intf, i_volume + i_value );
}
else if( strstr( psz_vol, "%") != NULL )
{
i_value = atoi( psz_vol );
if( i_value < 0 ) i_value = 0;
if( i_value > 400 ) i_value = 400;
aout_VolumeSet( p_intf, (i_value * (AOUT_VOLUME_MAX - AOUT_VOLUME_MIN))/400+AOUT_VOLUME_MIN);
}
else
{
i_value = atoi( psz_vol );
if( i_value > AOUT_VOLUME_MAX ) i_value = AOUT_VOLUME_MAX;
if( i_value < AOUT_VOLUME_MIN ) i_value = AOUT_VOLUME_MIN;
aout_VolumeSet( p_intf, i_value );
}
aout_VolumeGet( p_intf, &i_volume );
free( psz_vol );
}
else if( !strcmp( s, "vlc_get_meta" ) )
{
char *psz_meta = SSPop( st );
char *psz_val = NULL;
if( p_sys->p_input && input_GetItem(p_sys->p_input) )
{
#define p_item input_GetItem( p_sys->p_input )
if( !strcmp( psz_meta, "ARTIST" ) )
{
psz_val = input_item_GetArtist( p_item );
}
else if( !strcmp( psz_meta, "TITLE" ) )
{
psz_val = input_item_GetTitle( p_item );
if( !psz_val )
psz_val = input_item_GetName( p_item );
}
else if( !strcmp( psz_meta, "ALBUM" ) )
{
psz_val = input_item_GetAlbum( p_item );
}
else if( !strcmp( psz_meta, "GENRE" ) )
{
psz_val = input_item_GetGenre( p_item );
}
else if( !strcmp( psz_meta, "COPYRIGHT" ) )
{
psz_val = input_item_GetCopyright( p_item );
}
else if( !strcmp( psz_meta, "TRACK_NUMBER" ) )
{
psz_val = input_item_GetTrackNum( p_item );
}
else if( !strcmp( psz_meta, "DESCRIPTION" ) )
{
psz_val = input_item_GetDescription( p_item );
}
else if( !strcmp( psz_meta, "RATING" ) )
{
psz_val = input_item_GetRating( p_item );
}
else if( !strcmp( psz_meta, "DATE" ) )
{
psz_val = input_item_GetDate( p_item );
}
else if( !strcmp( psz_meta, "URL" ) )
{
psz_val = input_item_GetURL( p_item );
}
else if( !strcmp( psz_meta, "LANGUAGE" ) )
{
psz_val = input_item_GetLanguage( p_item );
}
else if( !strcmp( psz_meta, "NOW_PLAYING" ) )
{
psz_val = input_item_GetNowPlaying( p_item );
}
else if( !strcmp( psz_meta, "PUBLISHER" ) )
{
psz_val = input_item_GetPublisher( p_item );
}
else if( !strcmp( psz_meta, "ENCODED_BY" ) )
{
psz_val = input_item_GetEncodedBy( p_item );
}
else if( !strcmp( psz_meta, "ART_URL" ) )
{
psz_val = input_item_GetEncodedBy( p_item );
}
else if( !strcmp( psz_meta, "TRACK_ID" ) )
{
psz_val = input_item_GetTrackID( p_item );
}
#undef p_item
}
if( psz_val == NULL ) psz_val = strdup( "" );
SSPush( st, psz_val );
free( psz_meta );
free( psz_val );
}
#ifdef ENABLE_VLM
else if( !strcmp( s, "vlm_command" ) || !strcmp( s, "vlm_cmd" ) )
{
char *psz_elt;
char *psz_cmd = strdup( "" );
char *psz_error;
vlm_message_t *vlm_answer;
/* make sure that we have a vlm object */
if( p_intf->p_sys->p_vlm == NULL )
p_intf->p_sys->p_vlm = vlm_New( p_intf );
/* vlm command uses the ';' delimiter
* (else we can't know when to stop) */
while( strcmp( psz_elt = SSPop( st ), "" )
&& strcmp( psz_elt, ";" ) )
{
char* psz_buf;
if( asprintf( &psz_buf, "%s %s", psz_cmd, psz_elt ) == -1 )
psz_buf = NULL;
free( psz_cmd );
free( psz_elt );
psz_cmd = psz_buf;
}
msg_Dbg( p_intf, "executing vlm command: %s", psz_cmd );
vlm_ExecuteCommand( p_intf->p_sys->p_vlm, psz_cmd, &vlm_answer );
if( vlm_answer->psz_value == NULL )
{
psz_error = strdup( "" );
}
else
{
if( asprintf( &psz_error , "%s : %s" , vlm_answer->psz_name,
vlm_answer->psz_value ) == -1 )
psz_error = NULL;
}
mvar_AppendNewVar( vars, "vlm_error", psz_error );
/* this is kind of a duplicate but we need to have the message
* without the command name for the "export" command */
mvar_AppendNewVar( vars, "vlm_value", vlm_answer->psz_value );
vlm_MessageDelete( vlm_answer );
free( psz_cmd );
free( psz_error );
}
#endif /* ENABLE_VLM */
else if( !strcmp( s, "snapshot" ) )
{
if( p_sys->p_input )
{
vout_thread_t *p_vout = input_GetVout( p_sys->p_input );
if( p_vout )
{
var_TriggerCallback( p_vout, "video-snapshot" );
vlc_object_release( p_vout );
msg_Dbg( p_intf, "requested snapshot" );
}
}
break;
}
else
{
SSPush( st, s );
}
}
}
/*****************************************************************************
* Open:
*****************************************************************************/
static int Open( vlc_object_t *p_this )
{
aout_filter_t *p_filter = (aout_filter_t *)p_this;
aout_filter_sys_t *p_sys;
bool b_fit = true;
int i_samplerate;
if( p_filter->input.i_format != VLC_CODEC_FL32 ||
p_filter->output.i_format != VLC_CODEC_FL32 )
{
b_fit = false;
p_filter->input.i_format = VLC_CODEC_FL32;
p_filter->output.i_format = VLC_CODEC_FL32;
msg_Warn( p_filter, "bad input or output format" );
}
if ( !AOUT_FMTS_SIMILAR( &p_filter->input, &p_filter->output ) )
{
b_fit = false;
memcpy( &p_filter->output, &p_filter->input,
sizeof(audio_sample_format_t) );
msg_Warn( p_filter, "input and output formats are not similar" );
}
if ( ! b_fit )
{
return VLC_EGENERIC;
}
p_filter->pf_do_work = DoWork;
p_filter->b_in_place = true;
/* Allocate structure */
p_sys = p_filter->p_sys = malloc( sizeof( aout_filter_sys_t ) );
p_sys->f_lowf = config_GetFloat( p_this, "param-eq-lowf");
p_sys->f_lowgain = config_GetFloat( p_this, "param-eq-lowgain");
p_sys->f_highf = config_GetFloat( p_this, "param-eq-highf");
p_sys->f_highgain = config_GetFloat( p_this, "param-eq-highgain");
p_sys->f_f1 = config_GetFloat( p_this, "param-eq-f1");
p_sys->f_Q1 = config_GetFloat( p_this, "param-eq-q1");
p_sys->f_gain1 = config_GetFloat( p_this, "param-eq-gain1");
p_sys->f_f2 = config_GetFloat( p_this, "param-eq-f2");
p_sys->f_Q2 = config_GetFloat( p_this, "param-eq-q2");
p_sys->f_gain2 = config_GetFloat( p_this, "param-eq-gain2");
p_sys->f_f3 = config_GetFloat( p_this, "param-eq-f3");
p_sys->f_Q3 = config_GetFloat( p_this, "param-eq-q3");
p_sys->f_gain3 = config_GetFloat( p_this, "param-eq-gain3");
i_samplerate = p_filter->input.i_rate;
CalcPeakEQCoeffs(p_sys->f_f1, p_sys->f_Q1, p_sys->f_gain1,
i_samplerate, p_sys->coeffs+0*5);
CalcPeakEQCoeffs(p_sys->f_f2, p_sys->f_Q2, p_sys->f_gain2,
i_samplerate, p_sys->coeffs+1*5);
CalcPeakEQCoeffs(p_sys->f_f3, p_sys->f_Q3, p_sys->f_gain3,
i_samplerate, p_sys->coeffs+2*5);
CalcShelfEQCoeffs(p_sys->f_lowf, 1, p_sys->f_lowgain, 0,
i_samplerate, p_sys->coeffs+3*5);
CalcShelfEQCoeffs(p_sys->f_highf, 1, p_sys->f_highgain, 0,
i_samplerate, p_sys->coeffs+4*5);
p_sys->p_state = (float*)calloc( p_filter->input.i_channels*5*4,
sizeof(float) );
return VLC_SUCCESS;
}
BookmarksDialog::BookmarksDialog( intf_thread_t *_p_intf ):QVLCFrame( _p_intf )
{
setWindowFlags( Qt::Tool );
setWindowOpacity( config_GetFloat( p_intf, "qt-opacity" ) );
setWindowTitle( qtr( "Edit Bookmarks" ) );
setWindowRole( "vlc-bookmarks" );
QGridLayout *layout = new QGridLayout( this );
QPushButton *addButton = new QPushButton( qtr( "Create" ) );
addButton->setToolTip( qtr( "Create a new bookmark" ) );
QPushButton *delButton = new QPushButton( qtr( "Delete" ) );
delButton->setToolTip( qtr( "Delete the selected item" ) );
QPushButton *clearButton = new QPushButton( qtr( "Clear" ) );
clearButton->setToolTip( qtr( "Delete all the bookmarks" ) );
#if 0
QPushButton *extractButton = new QPushButton( qtr( "Extract" ) );
extractButton->setToolTip( qtr() );
#endif
QPushButton *closeButton = new QPushButton( qtr( "&Close" ) );
bookmarksList = new QTreeWidget( this );
bookmarksList->setRootIsDecorated( false );
bookmarksList->setAlternatingRowColors( true );
bookmarksList->setSelectionMode( QAbstractItemView::ExtendedSelection );
bookmarksList->setSelectionBehavior( QAbstractItemView::SelectRows );
bookmarksList->setEditTriggers( QAbstractItemView::SelectedClicked );
bookmarksList->setColumnCount( 3 );
bookmarksList->resize( sizeHint() );
QStringList headerLabels;
headerLabels << qtr( "Description" );
headerLabels << qtr( "Bytes" );
headerLabels << qtr( "Time" );
bookmarksList->setHeaderLabels( headerLabels );
layout->addWidget( addButton, 0, 0 );
layout->addWidget( delButton, 1, 0 );
layout->addWidget( clearButton, 2, 0 );
layout->addItem( new QSpacerItem( 20, 20, QSizePolicy::Expanding ), 4, 0 );
#if 0
layout->addWidget( extractButton, 5, 0 );
#endif
layout->addWidget( bookmarksList, 0, 1, 6, 2);
layout->setColumnStretch( 1, 1 );
layout->addWidget( closeButton, 7, 2 );
CONNECT( THEMIM->getIM(), bookmarksChanged(),
this, update() );
CONNECT( bookmarksList, activated( QModelIndex ), this,
activateItem( QModelIndex ) );
CONNECT( bookmarksList, itemChanged( QTreeWidgetItem*, int ),
this, edit( QTreeWidgetItem*, int ) );
BUTTONACT( addButton, add() );
BUTTONACT( delButton, del() );
BUTTONACT( clearButton, clear() );
#if 0
BUTTONACT( extractButton, extract() );
#endif
BUTTONACT( closeButton, close() );
readSettings( "Bookmarks", QSize( 435, 280 ) );
updateGeometry();
}
