<?xml version="1.0" encoding="iso-8859-1"?>
<!DOCTYPE html
PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
<head>
<title>Qt 4.6: mediaplayer.cpp Example File (demos/qmediaplayer/mediaplayer.cpp)</title>
<link href="classic.css" rel="stylesheet" type="text/css" />
</head>
<body>
<table border="0" cellpadding="0" cellspacing="0" width="100%">
<tr>
<td align="left" valign="top" width="32"><a href="http://qt.nokia.com/"><img src="images/qt-logo.png" align="left" border="0" /></a></td>
<td width="1"> </td><td class="postheader" valign="center"><a href="index.html"><font color="#004faf">Home</font></a> · <a href="classes.html"><font color="#004faf">All Classes</font></a> · <a href="functions.html"><font color="#004faf">All Functions</font></a> · <a href="overviews.html"><font color="#004faf">Overviews</font></a></td></tr></table><h1 class="title">mediaplayer.cpp Example File<br /><span class="small-subtitle">demos/qmediaplayer/mediaplayer.cpp</span>
</h1>
<pre><span class="comment"> /****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the demonstration applications of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial Usage
** Licensees holding valid Qt Commercial licenses may use this file in
** accordance with the Qt Commercial License Agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Nokia.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights. These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
** If you have questions regarding the use of this file, please contact
** Nokia at qt-info@nokia.com.
** $QT_END_LICENSE$
**
***************************************************************************/</span>
#include <QtGui>
#define SLIDER_RANGE 8
#include "mediaplayer.h"
#include "ui_settings.h"
MediaVideoWidget::MediaVideoWidget(MediaPlayer *player, QWidget *parent) :
Phonon::VideoWidget(parent), m_player(player), m_action(this)
{
m_action.setCheckable(true);
m_action.setChecked(false);
m_action.setShortcut(QKeySequence( Qt::AltModifier + Qt::Key_Return));
m_action.setShortcutContext(Qt::WindowShortcut);
connect(&m_action, SIGNAL(toggled(bool)), SLOT(setFullScreen(bool)));
addAction(&m_action);
setAcceptDrops(true);
}
void MediaVideoWidget::setFullScreen(bool enabled)
{
Phonon::VideoWidget::setFullScreen(enabled);
emit fullScreenChanged(enabled);
}
void MediaVideoWidget::mouseDoubleClickEvent(QMouseEvent *e)
{
Phonon::VideoWidget::mouseDoubleClickEvent(e);
setFullScreen(!isFullScreen());
}
void MediaVideoWidget::keyPressEvent(QKeyEvent *e)
{
if(!e->modifiers()) {
<span class="comment">// On non-QWERTY Symbian key-based devices, there is no space key.</span>
<span class="comment">// The zero key typically is marked with a space character.</span>
if (e->key() == Qt::Key_Space || e->key() == Qt::Key_0) {
m_player->playPause();
e->accept();
return;
}
<span class="comment">// On Symbian devices, there is no key which maps to Qt::Key_Escape</span>
<span class="comment">// On devices which lack a backspace key (i.e. non-QWERTY devices),</span>
<span class="comment">// the 'C' key maps to Qt::Key_Backspace</span>
else if (e->key() == Qt::Key_Escape || e->key() == Qt::Key_Backspace) {
setFullScreen(false);
e->accept();
return;
}
}
Phonon::VideoWidget::keyPressEvent(e);
}
bool MediaVideoWidget::event(QEvent *e)
{
switch(e->type())
{
case QEvent::Close:
<span class="comment">//we just ignore the cose events on the video widget</span>
<span class="comment">//this prevents ALT+F4 from having an effect in fullscreen mode</span>
e->ignore();
return true;
case QEvent::MouseMove:
#ifndef QT_NO_CURSOR
unsetCursor();
#endif
<span class="comment">//fall through</span>
case QEvent::WindowStateChange:
{
<span class="comment">//we just update the state of the checkbox, in case it wasn't already</span>
m_action.setChecked(windowState() & Qt::WindowFullScreen);
const Qt::WindowFlags flags = m_player->windowFlags();
if (windowState() & Qt::WindowFullScreen) {
m_timer.start(1000, this);
} else {
m_timer.stop();
#ifndef QT_NO_CURSOR
unsetCursor();
#endif
}
}
break;
default:
break;
}
return Phonon::VideoWidget::event(e);
}
void MediaVideoWidget::timerEvent(QTimerEvent *e)
{
if (e->timerId() == m_timer.timerId()) {
<span class="comment">//let's store the cursor shape</span>
#ifndef QT_NO_CURSOR
setCursor(Qt::BlankCursor);
#endif
}
Phonon::VideoWidget::timerEvent(e);
}
void MediaVideoWidget::dropEvent(QDropEvent *e)
{
m_player->handleDrop(e);
}
void MediaVideoWidget::dragEnterEvent(QDragEnterEvent *e) {
if (e->mimeData()->hasUrls())
e->acceptProposedAction();
}
MediaPlayer::MediaPlayer(const QString &filePath,
const bool hasSmallScreen) :
playButton(0), nextEffect(0), settingsDialog(0), ui(0),
m_AudioOutput(Phonon::VideoCategory),
m_videoWidget(new MediaVideoWidget(this)),
m_hasSmallScreen(hasSmallScreen)
{
setWindowTitle(tr("Media Player"));
setContextMenuPolicy(Qt::CustomContextMenu);
m_videoWidget->setContextMenuPolicy(Qt::CustomContextMenu);
QSize buttonSize(34, 28);
QPushButton *openButton = new QPushButton(this);
openButton->setIcon(style()->standardIcon(QStyle::SP_DialogOpenButton));
QPalette bpal;
QColor arrowcolor = bpal.buttonText().color();
if (arrowcolor == Qt::black)
arrowcolor = QColor(80, 80, 80);
bpal.setBrush(QPalette::ButtonText, arrowcolor);
openButton->setPalette(bpal);
rewindButton = new QPushButton(this);
rewindButton->setIcon(style()->standardIcon(QStyle::SP_MediaSkipBackward));
forwardButton = new QPushButton(this);
forwardButton->setIcon(style()->standardIcon(QStyle::SP_MediaSkipForward));
forwardButton->setEnabled(false);
playButton = new QPushButton(this);
playIcon = style()->standardIcon(QStyle::SP_MediaPlay);
pauseIcon = style()->standardIcon(QStyle::SP_MediaPause);
playButton->setIcon(playIcon);
slider = new Phonon::SeekSlider(this);
slider->setMediaObject(&m_MediaObject);
volume = new Phonon::VolumeSlider(&m_AudioOutput);
QVBoxLayout *vLayout = new QVBoxLayout(this);
vLayout->setContentsMargins(8, 8, 8, 8);
QHBoxLayout *layout = new QHBoxLayout();
info = new QLabel(this);
info->setMinimumHeight(70);
info->setAcceptDrops(false);
info->setMargin(2);
info->setFrameStyle(QFrame::StyledPanel | QFrame::Sunken);
info->setLineWidth(2);
info->setAutoFillBackground(true);
QPalette palette;
palette.setBrush(QPalette::WindowText, Qt::white);
#ifndef Q_WS_MAC
openButton->setMinimumSize(54, buttonSize.height());
rewindButton->setMinimumSize(buttonSize);
forwardButton->setMinimumSize(buttonSize);
playButton->setMinimumSize(buttonSize);
#endif
info->setStyleSheet("border-image:url(:/images/screen.png) ; border-width:3px");
info->setPalette(palette);
info->setText(tr("<center>No media</center>"));
volume->setFixedWidth(120);
layout->addWidget(openButton);
layout->addWidget(rewindButton);
layout->addWidget(playButton);
layout->addWidget(forwardButton);
layout->addStretch();
layout->addWidget(volume);
vLayout->addWidget(info);
initVideoWindow();
vLayout->addWidget(&m_videoWindow);
QVBoxLayout *buttonPanelLayout = new QVBoxLayout();
m_videoWindow.hide();
buttonPanelLayout->addLayout(layout);
timeLabel = new QLabel(this);
progressLabel = new QLabel(this);
QWidget *sliderPanel = new QWidget(this);
QHBoxLayout *sliderLayout = new QHBoxLayout();
sliderLayout->addWidget(slider);
sliderLayout->addWidget(timeLabel);
sliderLayout->addWidget(progressLabel);
sliderLayout->setContentsMargins(0, 0, 0, 0);
sliderPanel->setLayout(sliderLayout);
buttonPanelLayout->addWidget(sliderPanel);
buttonPanelLayout->setContentsMargins(0, 0, 0, 0);
#ifdef Q_OS_MAC
layout->setSpacing(4);
buttonPanelLayout->setSpacing(0);
info->setMinimumHeight(100);
info->setFont(QFont("verdana", 15));
<span class="comment">// QStyle *flatButtonStyle = new QWindowsStyle;</span>
openButton->setFocusPolicy(Qt::NoFocus);
<span class="comment">// openButton->setStyle(flatButtonStyle);</span>
<span class="comment">// playButton->setStyle(flatButtonStyle);</span>
<span class="comment">// rewindButton->setStyle(flatButtonStyle);</span>
<span class="comment">// forwardButton->setStyle(flatButtonStyle);</span>
#endif
QWidget *buttonPanelWidget = new QWidget(this);
buttonPanelWidget->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed);
buttonPanelWidget->setLayout(buttonPanelLayout);
vLayout->addWidget(buttonPanelWidget);
QHBoxLayout *labelLayout = new QHBoxLayout();
vLayout->addLayout(labelLayout);
setLayout(vLayout);
<span class="comment">// Create menu bar:</span>
fileMenu = new QMenu(this);
QAction *openFileAction = fileMenu->addAction(tr("Open &File..."));
QAction *openUrlAction = fileMenu->addAction(tr("Open &Location..."));
QAction *const openLinkAction = fileMenu->addAction(tr("Open &RAM File..."));
connect(openLinkAction, SIGNAL(triggered(bool)), this, SLOT(openRamFile()));
fileMenu->addSeparator();
QMenu *aspectMenu = fileMenu->addMenu(tr("&Aspect ratio"));
QActionGroup *aspectGroup = new QActionGroup(aspectMenu);
connect(aspectGroup, SIGNAL(triggered(QAction*)), this, SLOT(aspectChanged(QAction*)));
aspectGroup->setExclusive(true);
QAction *aspectActionAuto = aspectMenu->addAction(tr("Auto"));
aspectActionAuto->setCheckable(true);
aspectActionAuto->setChecked(true);
aspectGroup->addAction(aspectActionAuto);
QAction *aspectActionScale = aspectMenu->addAction(tr("Scale"));
aspectActionScale->setCheckable(true);
aspectGroup->addAction(aspectActionScale);
QAction *aspectAction16_9 = aspectMenu->addAction(tr("16/9"));
aspectAction16_9->setCheckable(true);
aspectGroup->addAction(aspectAction16_9);
QAction *aspectAction4_3 = aspectMenu->addAction(tr("4/3"));
aspectAction4_3->setCheckable(true);
aspectGroup->addAction(aspectAction4_3);
QMenu *scaleMenu = fileMenu->addMenu(tr("&Scale mode"));
QActionGroup *scaleGroup = new QActionGroup(scaleMenu);
connect(scaleGroup, SIGNAL(triggered(QAction*)), this, SLOT(scaleChanged(QAction*)));
scaleGroup->setExclusive(true);
QAction *scaleActionFit = scaleMenu->addAction(tr("Fit in view"));
scaleActionFit->setCheckable(true);
scaleActionFit->setChecked(true);
scaleGroup->addAction(scaleActionFit);
QAction *scaleActionCrop = scaleMenu->addAction(tr("Scale and crop"));
scaleActionCrop->setCheckable(true);
scaleGroup->addAction(scaleActionCrop);
m_fullScreenAction = fileMenu->addAction(tr("Full screen video"));
m_fullScreenAction->setCheckable(true);
m_fullScreenAction->setEnabled(false); <span class="comment">// enabled by hasVideoChanged</span>
bool b = connect(m_fullScreenAction, SIGNAL(toggled(bool)), m_videoWidget, SLOT(setFullScreen(bool)));
Q_ASSERT(b);
b = connect(m_videoWidget, SIGNAL(fullScreenChanged(bool)), m_fullScreenAction, SLOT(setChecked(bool)));
Q_ASSERT(b);
fileMenu->addSeparator();
QAction *settingsAction = fileMenu->addAction(tr("&Settings..."));
<span class="comment">// Setup signal connections:</span>
connect(rewindButton, SIGNAL(clicked()), this, SLOT(rewind()));
<span class="comment">//connect(openButton, SIGNAL(clicked()), this, SLOT(openFile()));</span>
openButton->setMenu(fileMenu);
connect(playButton, SIGNAL(clicked()), this, SLOT(playPause()));
connect(forwardButton, SIGNAL(clicked()), this, SLOT(forward()));
<span class="comment">//connect(openButton, SIGNAL(clicked()), this, SLOT(openFile()));</span>
connect(settingsAction, SIGNAL(triggered(bool)), this, SLOT(showSettingsDialog()));
connect(openUrlAction, SIGNAL(triggered(bool)), this, SLOT(openUrl()));
connect(openFileAction, SIGNAL(triggered(bool)), this, SLOT(openFile()));
connect(m_videoWidget, SIGNAL(customContextMenuRequested(const QPoint &)), SLOT(showContextMenu(const QPoint &)));
connect(this, SIGNAL(customContextMenuRequested(const QPoint &)), SLOT(showContextMenu(const QPoint &)));
connect(&m_MediaObject, SIGNAL(metaDataChanged()), this, SLOT(updateInfo()));
connect(&m_MediaObject, SIGNAL(totalTimeChanged(qint64)), this, SLOT(updateTime()));
connect(&m_MediaObject, SIGNAL(tick(qint64)), this, SLOT(updateTime()));
connect(&m_MediaObject, SIGNAL(finished()), this, SLOT(finished()));
connect(&m_MediaObject, SIGNAL(stateChanged(Phonon::State,Phonon::State)), this, SLOT(stateChanged(Phonon::State,Phonon::State)));
connect(&m_MediaObject, SIGNAL(bufferStatus(int)), this, SLOT(bufferStatus(int)));
connect(&m_MediaObject, SIGNAL(hasVideoChanged(bool)), this, SLOT(hasVideoChanged(bool)));
rewindButton->setEnabled(false);
playButton->setEnabled(false);
setAcceptDrops(true);
m_audioOutputPath = Phonon::createPath(&m_MediaObject, &m_AudioOutput);
Phonon::createPath(&m_MediaObject, m_videoWidget);
if (!filePath.isEmpty())
setFile(filePath);
resize(minimumSizeHint());
}
void MediaPlayer::stateChanged(Phonon::State newstate, Phonon::State oldstate)
{
Q_UNUSED(oldstate);
if (oldstate == Phonon::LoadingState) {
QRect videoHintRect = QRect(QPoint(0, 0), m_videoWindow.sizeHint());
QRect newVideoRect = QApplication::desktop()->screenGeometry().intersected(videoHintRect);
if (!m_hasSmallScreen) {
if (m_MediaObject.hasVideo()) {
<span class="comment">// Flush event que so that sizeHint takes the</span>
<span class="comment">// recently shown/hidden m_videoWindow into account:</span>
qApp->processEvents();
resize(sizeHint());
} else
resize(minimumSize());
}
}
switch (newstate) {
case Phonon::ErrorState:
if (m_MediaObject.errorType() == Phonon::FatalError) {
playButton->setEnabled(false);
rewindButton->setEnabled(false);
} else {
m_MediaObject.pause();
}
QMessageBox::warning(this, "Phonon Mediaplayer", m_MediaObject.errorString(), QMessageBox::Close);
break;
case Phonon::StoppedState:
m_videoWidget->setFullScreen(false);
<span class="comment">// Fall through</span>
case Phonon::PausedState:
playButton->setIcon(playIcon);
if (m_MediaObject.currentSource().type() != Phonon::MediaSource::Invalid){
playButton->setEnabled(true);
rewindButton->setEnabled(true);
} else {
playButton->setEnabled(false);
rewindButton->setEnabled(false);
}
break;
case Phonon::PlayingState:
playButton->setEnabled(true);
playButton->setIcon(pauseIcon);
if (m_MediaObject.hasVideo())
m_videoWindow.show();
<span class="comment">// Fall through</span>
case Phonon::BufferingState:
rewindButton->setEnabled(true);
break;
case Phonon::LoadingState:
rewindButton->setEnabled(false);
break;
}
}
void MediaPlayer::initSettingsDialog()
{
settingsDialog = new QDialog(this);
ui = new Ui_settings();
ui->setupUi(settingsDialog);
connect(ui->brightnessSlider, SIGNAL(valueChanged(int)), this, SLOT(setBrightness(int)));
connect(ui->hueSlider, SIGNAL(valueChanged(int)), this, SLOT(setHue(int)));
connect(ui->saturationSlider, SIGNAL(valueChanged(int)), this, SLOT(setSaturation(int)));
connect(ui->contrastSlider , SIGNAL(valueChanged(int)), this, SLOT(setContrast(int)));
connect(ui->aspectCombo, SIGNAL(currentIndexChanged(int)), this, SLOT(setAspect(int)));
connect(ui->scalemodeCombo, SIGNAL(currentIndexChanged(int)), this, SLOT(setScale(int)));
ui->brightnessSlider->setValue(int(m_videoWidget->brightness() * SLIDER_RANGE));
ui->hueSlider->setValue(int(m_videoWidget->hue() * SLIDER_RANGE));
ui->saturationSlider->setValue(int(m_videoWidget->saturation() * SLIDER_RANGE));
ui->contrastSlider->setValue(int(m_videoWidget->contrast() * SLIDER_RANGE));
ui->aspectCombo->setCurrentIndex(m_videoWidget->aspectRatio());
ui->scalemodeCombo->setCurrentIndex(m_videoWidget->scaleMode());
connect(ui->effectButton, SIGNAL(clicked()), this, SLOT(configureEffect()));
#ifdef Q_WS_X11
<span class="comment">//Cross fading is not currently implemented in the GStreamer backend</span>
ui->crossFadeSlider->setVisible(false);
ui->crossFadeLabel->setVisible(false);
ui->crossFadeLabel1->setVisible(false);
ui->crossFadeLabel2->setVisible(false);
ui->crossFadeLabel3->setVisible(false);
#endif
ui->crossFadeSlider->setValue((int)(2 * m_MediaObject.transitionTime() / 1000.0f));
<span class="comment">// Insert audio devices:</span>
QList<Phonon::AudioOutputDevice> devices = Phonon::BackendCapabilities::availableAudioOutputDevices();
for (int i=0; i<devices.size(); i++){
QString itemText = devices[i].name();
if (!devices[i].description().isEmpty()) {
itemText += QString::fromLatin1(" (%1)").arg(devices[i].description());
}
ui->deviceCombo->addItem(itemText);
if (devices[i] == m_AudioOutput.outputDevice())
ui->deviceCombo->setCurrentIndex(i);
}
<span class="comment">// Insert audio effects:</span>
ui->audioEffectsCombo->addItem(tr("<no effect>"));
QList<Phonon::Effect *> currEffects = m_audioOutputPath.effects();
Phonon::Effect *currEffect = currEffects.size() ? currEffects[0] : 0;
QList<Phonon::EffectDescription> availableEffects = Phonon::BackendCapabilities::availableAudioEffects();
for (int i=0; i<availableEffects.size(); i++){
ui->audioEffectsCombo->addItem(availableEffects[i].name());
if (currEffect && availableEffects[i] == currEffect->description())
ui->audioEffectsCombo->setCurrentIndex(i+1);
}
connect(ui->audioEffectsCombo, SIGNAL(currentIndexChanged(int)), this, SLOT(effectChanged()));
}
void MediaPlayer::effectChanged()
{
int currentIndex = ui->audioEffectsCombo->currentIndex();
if (currentIndex) {
QList<Phonon::EffectDescription> availableEffects = Phonon::BackendCapabilities::availableAudioEffects();
Phonon::EffectDescription chosenEffect = availableEffects[currentIndex - 1];
QList<Phonon::Effect *> currEffects = m_audioOutputPath.effects();
Phonon::Effect *currentEffect = currEffects.size() ? currEffects[0] : 0;
<span class="comment">// Deleting the running effect will stop playback, it is deleted when removed from path</span>
if (nextEffect && !(currentEffect && (currentEffect->description().name() == nextEffect->description().name())))
delete nextEffect;
nextEffect = new Phonon::Effect(chosenEffect);
}
ui->effectButton->setEnabled(currentIndex);
}
void MediaPlayer::showSettingsDialog()
{
const bool hasPausedForDialog = playPauseForDialog();
if (!settingsDialog)
initSettingsDialog();
float oldBrightness = m_videoWidget->brightness();
float oldHue = m_videoWidget->hue();
float oldSaturation = m_videoWidget->saturation();
float oldContrast = m_videoWidget->contrast();
Phonon::VideoWidget::AspectRatio oldAspect = m_videoWidget->aspectRatio();
Phonon::VideoWidget::ScaleMode oldScale = m_videoWidget->scaleMode();
int currentEffect = ui->audioEffectsCombo->currentIndex();
settingsDialog->exec();
if (settingsDialog->result() == QDialog::Accepted){
m_MediaObject.setTransitionTime((int)(1000 * float(ui->crossFadeSlider->value()) / 2.0f));
QList<Phonon::AudioOutputDevice> devices = Phonon::BackendCapabilities::availableAudioOutputDevices();
m_AudioOutput.setOutputDevice(devices[ui->deviceCombo->currentIndex()]);
QList<Phonon::Effect *> currEffects = m_audioOutputPath.effects();
QList<Phonon::EffectDescription> availableEffects = Phonon::BackendCapabilities::availableAudioEffects();
if (ui->audioEffectsCombo->currentIndex() > 0){
Phonon::Effect *currentEffect = currEffects.size() ? currEffects[0] : 0;
if (!currentEffect || currentEffect->description() != nextEffect->description()){
foreach(Phonon::Effect *effect, currEffects) {
m_audioOutputPath.removeEffect(effect);
delete effect;
}
m_audioOutputPath.insertEffect(nextEffect);
}
} else {
foreach(Phonon::Effect *effect, currEffects) {
m_audioOutputPath.removeEffect(effect);
delete effect;
nextEffect = 0;
}
}
} else {
<span class="comment">// Restore previous settings</span>
m_videoWidget->setBrightness(oldBrightness);
m_videoWidget->setSaturation(oldSaturation);
m_videoWidget->setHue(oldHue);
m_videoWidget->setContrast(oldContrast);
m_videoWidget->setAspectRatio(oldAspect);
m_videoWidget->setScaleMode(oldScale);
ui->audioEffectsCombo->setCurrentIndex(currentEffect);
}
if (hasPausedForDialog)
m_MediaObject.play();
}
void MediaPlayer::initVideoWindow()
{
QVBoxLayout *videoLayout = new QVBoxLayout();
videoLayout->addWidget(m_videoWidget);
videoLayout->setContentsMargins(0, 0, 0, 0);
m_videoWindow.setLayout(videoLayout);
m_videoWindow.setMinimumSize(100, 100);
}
void MediaPlayer::configureEffect()
{
if (!nextEffect)
return;
QList<Phonon::Effect *> currEffects = m_audioOutputPath.effects();
const QList<Phonon::EffectDescription> availableEffects = Phonon::BackendCapabilities::availableAudioEffects();
if (ui->audioEffectsCombo->currentIndex() > 0) {
Phonon::EffectDescription chosenEffect = availableEffects[ui->audioEffectsCombo->currentIndex() - 1];
QDialog effectDialog;
effectDialog.setWindowTitle(tr("Configure effect"));
QVBoxLayout *topLayout = new QVBoxLayout(&effectDialog);
QLabel *description = new QLabel("<b>Description:</b><br>" + chosenEffect.description(), &effectDialog);
description->setWordWrap(true);
topLayout->addWidget(description);
QScrollArea *scrollArea = new QScrollArea(&effectDialog);
topLayout->addWidget(scrollArea);
QVariantList savedParamValues;
foreach(Phonon::EffectParameter param, nextEffect->parameters()) {
savedParamValues << nextEffect->parameterValue(param);
}
QWidget *scrollWidget = new Phonon::EffectWidget(nextEffect);
scrollWidget->setMinimumWidth(320);
scrollWidget->setContentsMargins(10, 10, 10,10);
scrollArea->setWidget(scrollWidget);
QDialogButtonBox *bbox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel, Qt::Horizontal, &effectDialog);
connect(bbox->button(QDialogButtonBox::Ok), SIGNAL(clicked()), &effectDialog, SLOT(accept()));
connect(bbox->button(QDialogButtonBox::Cancel), SIGNAL(clicked()), &effectDialog, SLOT(reject()));
topLayout->addWidget(bbox);
effectDialog.exec();
if (effectDialog.result() != QDialog::Accepted) {
<span class="comment">//we need to restore the paramaters values</span>
int currentIndex = 0;
foreach(Phonon::EffectParameter param, nextEffect->parameters()) {
nextEffect->setParameterValue(param, savedParamValues.at(currentIndex++));
}
}
}
}
void MediaPlayer::handleDrop(QDropEvent *e)
{
QList<QUrl> urls = e->mimeData()->urls();
if (e->proposedAction() == Qt::MoveAction){
<span class="comment">// Just add to the queue:</span>
for (int i=0; i<urls.size(); i++)
m_MediaObject.enqueue(Phonon::MediaSource(urls[i].toLocalFile()));
} else {
<span class="comment">// Create new queue:</span>
m_MediaObject.clearQueue();
if (urls.size() > 0) {
QString fileName = urls[0].toLocalFile();
QDir dir(fileName);
if (dir.exists()) {
dir.setFilter(QDir::Files);
QStringList entries = dir.entryList();
if (entries.size() > 0) {
setFile(fileName + QDir::separator() + entries[0]);
for (int i=1; i< entries.size(); ++i)
m_MediaObject.enqueue(fileName + QDir::separator() + entries[i]);
}
} else {
setFile(fileName);
for (int i=1; i<urls.size(); i++)
m_MediaObject.enqueue(Phonon::MediaSource(urls[i].toLocalFile()));
}
}
}
forwardButton->setEnabled(m_MediaObject.queue().size() > 0);
m_MediaObject.play();
}
void MediaPlayer::dropEvent(QDropEvent *e)
{
if (e->mimeData()->hasUrls() && e->proposedAction() != Qt::LinkAction) {
e->acceptProposedAction();
handleDrop(e);
} else {
e->ignore();
}
}
void MediaPlayer::dragEnterEvent(QDragEnterEvent *e)
{
dragMoveEvent(e);
}
void MediaPlayer::dragMoveEvent(QDragMoveEvent *e)
{
if (e->mimeData()->hasUrls()) {
if (e->proposedAction() == Qt::CopyAction || e->proposedAction() == Qt::MoveAction){
e->acceptProposedAction();
}
}
}
void MediaPlayer::playPause()
{
if (m_MediaObject.state() == Phonon::PlayingState)
m_MediaObject.pause();
else {
if (m_MediaObject.currentTime() == m_MediaObject.totalTime())
m_MediaObject.seek(0);
m_MediaObject.play();
}
}
void MediaPlayer::setFile(const QString &fileName)
{
setWindowTitle(fileName.right(fileName.length() - fileName.lastIndexOf('/') - 1));
m_MediaObject.setCurrentSource(Phonon::MediaSource(fileName));
m_MediaObject.play();
}
void MediaPlayer::setLocation(const QString& location)
{
setWindowTitle(location.right(location.length() - location.lastIndexOf('/') - 1));
m_MediaObject.setCurrentSource(Phonon::MediaSource(QUrl::fromEncoded(location.toUtf8())));
m_MediaObject.play();
}
bool MediaPlayer::playPauseForDialog()
{
<span class="comment">// If we're running on a small screen, we want to pause the video when</span>
<span class="comment">// popping up dialogs. We neither want to tamper with the state if the</span>
<span class="comment">// user has paused.</span>
if (m_hasSmallScreen && m_MediaObject.hasVideo()) {
if (Phonon::PlayingState == m_MediaObject.state()) {
m_MediaObject.pause();
return true;
}
}
return false;
}
void MediaPlayer::openFile()
{
const bool hasPausedForDialog = playPauseForDialog();
QStringList fileNames = QFileDialog::getOpenFileNames(this, QString(),
QDesktopServices::storageLocation(QDesktopServices::MusicLocation));
if (hasPausedForDialog)
m_MediaObject.play();
m_MediaObject.clearQueue();
if (fileNames.size() > 0) {
QString fileName = fileNames[0];
setFile(fileName);
for (int i=1; i<fileNames.size(); i++)
m_MediaObject.enqueue(Phonon::MediaSource(fileNames[i]));
}
forwardButton->setEnabled(m_MediaObject.queue().size() > 0);
}
void MediaPlayer::bufferStatus(int percent)
{
if (percent == 0 || percent == 100)
progressLabel->setText(QString());
else {
QString str = QString::fromLatin1("(%1%)").arg(percent);
progressLabel->setText(str);
}
}
void MediaPlayer::setSaturation(int val)
{
m_videoWidget->setSaturation(val / qreal(SLIDER_RANGE));
}
void MediaPlayer::setHue(int val)
{
m_videoWidget->setHue(val / qreal(SLIDER_RANGE));
}
void MediaPlayer::setAspect(int val)
{
m_videoWidget->setAspectRatio(Phonon::VideoWidget::AspectRatio(val));
}
void MediaPlayer::setScale(int val)
{
m_videoWidget->setScaleMode(Phonon::VideoWidget::ScaleMode(val));
}
void MediaPlayer::setBrightness(int val)
{
m_videoWidget->setBrightness(val / qreal(SLIDER_RANGE));
}
void MediaPlayer::setContrast(int val)
{
m_videoWidget->setContrast(val / qreal(SLIDER_RANGE));
}
void MediaPlayer::updateInfo()
{
int maxLength = 30;
QString font = "<font color=#ffeeaa>";
QString fontmono = "<font family=\"monospace,courier new\" color=#ffeeaa>";
QMap <QString, QString> metaData = m_MediaObject.metaData();
QString trackArtist = metaData.value("ARTIST");
if (trackArtist.length() > maxLength)
trackArtist = trackArtist.left(maxLength) + "...";
QString trackTitle = metaData.value("TITLE");
int trackBitrate = metaData.value("BITRATE").toInt();
QString fileName;
if (m_MediaObject.currentSource().type() == Phonon::MediaSource::Url) {
fileName = m_MediaObject.currentSource().url().toString();
} else {
fileName = m_MediaObject.currentSource().fileName();
fileName = fileName.right(fileName.length() - fileName.lastIndexOf('/') - 1);
if (fileName.length() > maxLength)
fileName = fileName.left(maxLength) + "...";
}
QString title;
if (!trackTitle.isEmpty()) {
if (trackTitle.length() > maxLength)
trackTitle = trackTitle.left(maxLength) + "...";
title = "Title: " + font + trackTitle + "<br></font>";
} else if (!fileName.isEmpty()) {
if (fileName.length() > maxLength)
fileName = fileName.left(maxLength) + "...";
title = font + fileName + "</font>";
if (m_MediaObject.currentSource().type() == Phonon::MediaSource::Url) {
title.prepend("Url: ");
} else {
title.prepend("File: ");
}
}
QString artist;
if (!trackArtist.isEmpty())
artist = "Artist: " + font + trackArtist + "</font>";
QString bitrate;
if (trackBitrate != 0)
bitrate = "<br>Bitrate: " + font + QString::number(trackBitrate/1000) + "kbit</font>";
info->setText(title + artist + bitrate);
}
void MediaPlayer::updateTime()
{
long len = m_MediaObject.totalTime();
long pos = m_MediaObject.currentTime();
QString timeString;
if (pos || len)
{
int sec = pos/1000;
int min = sec/60;
int hour = min/60;
int msec = pos;
QTime playTime(hour%60, min%60, sec%60, msec%1000);
sec = len / 1000;
min = sec / 60;
hour = min / 60;
msec = len;
QTime stopTime(hour%60, min%60, sec%60, msec%1000);
QString timeFormat = "m:ss";
if (hour > 0)
timeFormat = "h:mm:ss";
timeString = playTime.toString(timeFormat);
if (len)
timeString += " / " + stopTime.toString(timeFormat);
}
timeLabel->setText(timeString);
}
void MediaPlayer::rewind()
{
m_MediaObject.seek(0);
}
void MediaPlayer::forward()
{
QList<Phonon::MediaSource> queue = m_MediaObject.queue();
if (queue.size() > 0) {
m_MediaObject.setCurrentSource(queue[0]);
forwardButton->setEnabled(queue.size() > 1);
m_MediaObject.play();
}
}
void MediaPlayer::openUrl()
{
QSettings settings;
settings.beginGroup(QLatin1String("BrowserMainWindow"));
QString sourceURL = settings.value("location").toString();
bool ok = false;
sourceURL = QInputDialog::getText(this, tr("Open Location"), tr("Please enter a valid address here:"), QLineEdit::Normal, sourceURL, &ok);
if (ok && !sourceURL.isEmpty()) {
setLocation(sourceURL);
settings.setValue("location", sourceURL);
}
}
<span class="comment"> /*!
\since 4.6
*/</span>
void MediaPlayer::openRamFile()
{
QSettings settings;
settings.beginGroup(QLatin1String("BrowserMainWindow"));
const QStringList fileNameList(QFileDialog::getOpenFileNames(this,
QString(),
settings.value("openRamFile").toString(),
QLatin1String("RAM files (*.ram)")));
if (fileNameList.isEmpty())
return;
QFile linkFile;
QList<QUrl> list;
QByteArray sourceURL;
for (int i = 0; i < fileNameList.count(); i++ ) {
linkFile.setFileName(fileNameList[i]);
if (linkFile.open(QIODevice::ReadOnly | QIODevice::Text)) {
while (!linkFile.atEnd()) {
sourceURL = linkFile.readLine().trimmed();
if (!sourceURL.isEmpty()) {
const QUrl url(QUrl::fromEncoded(sourceURL));
if (url.isValid())
list.append(url);
}
}
linkFile.close();
}
}
if (!list.isEmpty()) {
m_MediaObject.clearQueue();
setLocation(list[0].toString());
for (int i = 1; i < list.count(); i++)
m_MediaObject.enqueue(Phonon::MediaSource(list[i]));
m_MediaObject.play();
}
forwardButton->setEnabled(!m_MediaObject.queue().isEmpty());
settings.setValue("openRamFile", fileNameList[0]);
}
void MediaPlayer::finished()
{
}
void MediaPlayer::showContextMenu(const QPoint &p)
{
fileMenu->popup(m_videoWidget->isFullScreen() ? p : mapToGlobal(p));
}
void MediaPlayer::scaleChanged(QAction *act)
{
if (act->text() == tr("Scale and crop"))
m_videoWidget->setScaleMode(Phonon::VideoWidget::ScaleAndCrop);
else
m_videoWidget->setScaleMode(Phonon::VideoWidget::FitInView);
}
void MediaPlayer::aspectChanged(QAction *act)
{
if (act->text() == tr("16/9"))
m_videoWidget->setAspectRatio(Phonon::VideoWidget::AspectRatio16_9);
else if (act->text() == tr("Scale"))
m_videoWidget->setAspectRatio(Phonon::VideoWidget::AspectRatioWidget);
else if (act->text() == tr("4/3"))
m_videoWidget->setAspectRatio(Phonon::VideoWidget::AspectRatio4_3);
else
m_videoWidget->setAspectRatio(Phonon::VideoWidget::AspectRatioAuto);
}
void MediaPlayer::hasVideoChanged(bool bHasVideo)
{
info->setVisible(!bHasVideo);
m_videoWindow.setVisible(bHasVideo);
m_fullScreenAction->setEnabled(bHasVideo);
}</pre>
<p /><address><hr /><div align="center">
<table width="100%" cellspacing="0" border="0"><tr class="address">
<td width="40%" align="left">Copyright © 2010 Nokia Corporation and/or its subsidiary(-ies)</td>
<td width="20%" align="center"><a href="trademarks.html">Trademarks</a></td>
<td width="40%" align="right"><div align="right">Qt 4.6.3</div></td>
</tr></table></div></address></body>
</html>
distrib
>
Mandriva
>
current
>
i586
>
media
>
main-updates
>
by-pkgid
>
8e6051afcdb111a0317a58fb64c2abf5
>
files
>
397
