QtGui/QWidget No Such file or Directory



  • I am using Qt 5.0.2 , and in videowidget.h it is showing that QtGui/QWidget No such file or directory. Videowidget.h is only Read file.
    Can somebody suggest what to do to resolve this problem.

    Thanks



  • maybe you forget to include the head file.and would you to show some your codes?



  • @joeQ
    i am trying to use gstreamer on qt5.

    #include <QtGStreamer/QGst/Ui/VideoWidget>
    after adding this when i am tryig to run my progrrame it opens videowidget and there it shows error of QtGui/QWidget No such file or directory. This Videowidget is basically READ only file.


  • Lifetime Qt Champion

    Hi,

    That's an include from Qt 4, QWidget is in the widgets module in Qt 5.



  • @SGaist thankyou for you reply.
    #include <QtGStreamer/QGst/Ui/VideoWidget> i am using this one. so what should i use instead of[ <QtGStreamer/QGst/Ui/VideoWidget>] avoiding error of QtGui/QWidget No such file.
    thankyou



  • @SGaist
    .profile
    QT += core gui
    QT += widgets

    greaterThan(QT_MAJOR_VERSION, 4): QT += widgets

    TARGET = Gstreamer
    TEMPLATE = app

    SOURCES += main.cpp
    mediaapp.cpp
    player.cpp

    HEADERS += mediaapp.h
    player.h

    FORMS += mediaapp.ui
    player.ui

    HEADER Files//
    mediapp.h
    #ifndef MEDIAAPP_H
    #define MEDIAAPP_H
    #include <QTimer>
    #include <QtWidgets>
    #include<QtGui/QWidgetList>
    #include <QStyle>
    #include <QLabel>
    class Player;
    class QBoxLayout;
    class QLabel;
    class QSlider;
    class QToolButton;
    class QTimer;
    class MediaApp : public QWidget
    {
    Q_OBJECT
    public:
    MediaApp(QWidget *parent = 0);
    ~MediaApp();
    void openFile(const QString & fileName);
    private Q_SLOTS:
    void open();
    void toggleFullScreen();
    void onStateChanged();
    void onPositionChanged();
    void setPosition(int position);
    void showControls(bool show = true);
    void hideControls() { showControls(false); }
    protected:
    void mouseMoveEvent(QMouseEvent *event);
    private:
    QToolButton *initButton(QStyle::StandardPixmap icon, const QString & tip,
    QObject *dstobj, const char *slot_method, QLayout *layout);
    void createUI(QBoxLayout *appLayout);
    QString m_baseDir;
    Player *m_player;
    QToolButton *m_openButton;
    QToolButton *m_fullScreenButton;
    QToolButton *m_playButton;
    QToolButton *m_pauseButton;
    QToolButton *m_stopButton;
    QSlider *m_positionSlider;
    QSlider *m_volumeSlider;
    QLabel *m_positionLabel;
    QLabel *m_volumeLabel;
    QTimer m_fullScreenTimer;
    };
    #endif

    PLAYER.h//

    #ifndef PLAYER_H
    #define PLAYER_H
    #include <QTimer>
    #include <QLabel>
    #include <QTime>
    #include <QtGStreamer/QGst/Pipeline>
    #include <QtGStreamer/QGst/Ui/VideoWidget>

    class Player : public QGst::Ui::VideoWidget
    {
    Q_OBJECT
    public:
    Player(QWidget *parent = 0);
    ~Player();
    void setUri(const QString & uri);
    QTime position() const;
    void setPosition(const QTime & pos);
    int volume() const;
    QTime length() const;
    QGst::State state() const;
    public Q_SLOTS:
    void play();
    void pause();
    void stop();
    void setVolume(int volume);
    Q_SIGNALS:
    void positionChanged();
    void stateChanged();
    private:
    void onBusMessage(const QGst::MessagePtr & message);
    void handlePipelineStateChange(const QGst::StateChangedMessagePtr & scm);
    QGst::PipelinePtr m_pipeline;
    QTimer m_positionTimer;
    };
    #endif

    Source file main.cpp
    #include "mediaapp.h"
    #include <QApplication>
    #include <QtGStreamer/QGlib/Init>
    #include<QtGStreamer/QGst/Init>
    #include<QWidget>
    #include <QtWidgets>
    #include <QLabel>
    #include <QtWidgets/QToolButton>
    #include <QtCore>
    int main(int argc, char *argv[])
    {
    QApplication app(argc, argv);
    QGst::init(&argc, &argv);
    MediaApp media;
    media.show();
    if (argc == 2) {
    media.openFile(argv[1]);
    }
    return app.exec();
    }
    mediapp.cpp//
    #include "mediaapp.h"
    #include "player.h"
    #include <QBoxLayout>
    #include <QFileDialog>
    #include <QToolButton>
    #include <QLabel>
    #include <QSlider>
    #include <QMouseEvent>
    #include <QtWidgets/QToolButton>
    MediaApp::MediaApp(QWidget *parent)
    : QWidget(parent)
    {
    //create the player
    m_player = new Player(this);
    connect(m_player, SIGNAL(positionChanged()), this, SLOT(onPositionChanged()));
    connect(m_player, SIGNAL(stateChanged()), this, SLOT(onStateChanged()));
    //m_baseDir is used to remember the last directory that was used.
    //defaults to the current working directory
    m_baseDir = QLatin1String(".");
    //this timer (re-)hides the controls after a few seconds when we are in fullscreen mode
    m_fullScreenTimer.setSingleShot(true);
    connect(&m_fullScreenTimer, SIGNAL(timeout()), this, SLOT(hideControls()));
    //create the UI
    QVBoxLayout appLayout = new QVBoxLayout;
    appLayout->setContentsMargins(0, 0, 0, 0);
    createUI(appLayout);
    setLayout(appLayout);
    onStateChanged(); //set the controls to their default state
    setWindowTitle(tr("QtGStreamer example player"));
    resize(400, 400);
    }
    MediaApp::~MediaApp()
    {
    delete m_player;
    }
    void MediaApp::openFile(const QString & fileName)
    {
    m_baseDir = QFileInfo(fileName).path();
    m_player->stop();
    m_player->setUri(fileName);
    m_player->play();
    }
    void MediaApp::open()
    {
    QString fileName = QFileDialog::getOpenFileName(this, tr("Open a Movie"), m_baseDir);
    if (!fileName.isEmpty()) {
    openFile(fileName);
    }
    }
    void MediaApp::toggleFullScreen()
    {
    if (isFullScreen()) {
    setMouseTracking(false);
    m_player->setMouseTracking(false);
    m_fullScreenTimer.stop();
    showControls();
    showNormal();
    } else {
    setMouseTracking(true);
    m_player->setMouseTracking(true);
    hideControls();
    showFullScreen();
    }
    }
    void MediaApp::onStateChanged()
    {
    QGst::State newState = m_player->state();
    m_playButton->setEnabled(newState != QGst::StatePlaying);
    m_pauseButton->setEnabled(newState == QGst::StatePlaying);
    m_stopButton->setEnabled(newState != QGst::StateNull);
    m_positionSlider->setEnabled(newState != QGst::StateNull);
    m_volumeSlider->setEnabled(newState != QGst::StateNull);
    m_volumeLabel->setEnabled(newState != QGst::StateNull);
    m_volumeSlider->setValue(m_player->volume());
    //if we are in Null state, call onPositionChanged() to restore
    //the position of the slider and the text on the label
    if (newState == QGst::StateNull) {
    onPositionChanged();
    }
    }
    /
    Called when the positionChanged() is received from the player */
    void MediaApp::onPositionChanged()
    {
    QTime length(0,0);
    QTime curpos(0,0);
    if (m_player->state() != QGst::StateReady &&
    m_player->state() != QGst::StateNull)
    {
    length = m_player->length();
    curpos = m_player->position();
    }
    m_positionLabel->setText(curpos.toString("hh:mm:ss.zzz")

    • "/" +
      length.toString("hh:mm:ss.zzz"));
      if (length != QTime(0,0)) {
      m_positionSlider->setValue(curpos.msecsTo(QTime(0,0)) * 1000 / length.msecsTo(QTime(0,0)));
      } else {
      m_positionSlider->setValue(0);
      }
      if (curpos != QTime(0,0)) {
      m_positionLabel->setEnabled(true);
      m_positionSlider->setEnabled(true);
      }
      }
      /* Called when the user changes the slider's position */
      void MediaApp::setPosition(int value)
      {
      uint length = -m_player->length().msecsTo(QTime(0,0));
      if (length != 0 && value > 0) {
      QTime pos(0,0);
      pos = pos.addMSecs(length * (value / 1000.0));
      m_player->setPosition(pos);
      }
      }
      void MediaApp::showControls(bool show)
      {
      m_openButton->setVisible(show);
      m_playButton->setVisible(show);
      m_pauseButton->setVisible(show);
      m_stopButton->setVisible(show);
      m_fullScreenButton->setVisible(show);
      m_positionSlider->setVisible(show);
      m_volumeSlider->setVisible(show);
      m_volumeLabel->setVisible(show);
      m_positionLabel->setVisible(show);
      }
      void MediaApp::mouseMoveEvent(QMouseEvent *event)
      {
      Q_UNUSED(event);
      if (isFullScreen()) {
      showControls();
      m_fullScreenTimer.start(3000); //re-hide controls after 3s
      }
      }
      QToolButton *MediaApp::initButton(QStyle::StandardPixmap icon, const QString & tip,
      QObject *dstobj, const char *slot_method, QLayout *layout)
      {
      QToolButton *button = new QToolButton;
      button->setIcon(style()->standardIcon(icon));
      button->setIconSize(QSize(36, 36));
      button->setToolTip(tip);
      connect(button, SIGNAL(clicked()), dstobj, slot_method);
      layout->addWidget(button);
      return button;
      }
      void MediaApp::createUI(QBoxLayout *appLayout)
      {
      appLayout->addWidget(m_player);
      m_positionLabel = new QLabel();
      m_positionSlider = new QSlider(Qt::Horizontal);
      m_positionSlider->setTickPosition(QSlider::TicksBelow);
      m_positionSlider->setTickInterval(10);
      m_positionSlider->setMaximum(1000);
      connect(m_positionSlider, SIGNAL(sliderMoved(int)), this, SLOT(setPosition(int)));
      m_volumeSlider = new QSlider(Qt::Horizontal);
      m_volumeSlider->setTickPosition(QSlider::TicksLeft);
      m_volumeSlider->setTickInterval(2);
      m_volumeSlider->setMaximum(10);
      m_volumeSlider->setMaximumSize(64,32);
      connect(m_volumeSlider, SIGNAL(sliderMoved(int)), m_player, SLOT(setVolume(int)));
      QGridLayout *posLayout = new QGridLayout;
      posLayout->addWidget(m_positionLabel, 1, 0);
      posLayout->addWidget(m_positionSlider, 1, 1, 1, 2);
      appLayout->addLayout(posLayout);
      QHBoxLayout *btnLayout = new QHBoxLayout;
      btnLayout->addStretch();
      m_openButton = initButton(QStyle::SP_DialogOpenButton, tr("Open File"),
      this, SLOT(open()), btnLayout);
      m_playButton = initButton(QStyle::SP_MediaPlay, tr("Play"),
      m_player, SLOT(play()), btnLayout);
      m_pauseButton = initButton(QStyle::SP_MediaPause, tr("Pause"),
      m_player, SLOT(pause()), btnLayout);
      m_stopButton = initButton(QStyle::SP_MediaStop, tr("Stop"),
      m_player, SLOT(stop()), btnLayout);
      m_fullScreenButton = initButton(QStyle::SP_TitleBarMaxButton, tr("Fullscreen"),
      this, SLOT(toggleFullScreen()), btnLayout);
      btnLayout->addStretch();
      m_volumeLabel = new QLabel();
      m_volumeLabel->setPixmap(
      style()->standardIcon(QStyle::SP_MediaVolume).pixmap(QSize(32, 32),
      QIcon::Normal, QIcon::On));
      btnLayout->addWidget(m_volumeLabel);
      btnLayout->addWidget(m_volumeSlider);
      appLayout->addLayout(btnLayout);
      }

    player.cpp//

    #include "player.h"
    #include <QDir>
    #include <QLabel>
    #include <QUrl>
    #include<QWidget>
    #include <QtWidgets/QToolButton>
    #include <QtGStreamer/QGlib/Connect>

    #include <QtGStreamer/QGlib/Error>
    #include <QtGStreamer/QGst/Pipeline>
    #include <QtGStreamer/QGst/ElementFactory>
    #include <QtGStreamer/QGst/Bus>
    #include <QtGStreamer/QGst/Message>
    #include <QtGStreamer/QGst/Query>
    #include <QtGStreamer/QGst/ClockTime>
    #include <QtGStreamer/QGst/Event>
    #include <QtGStreamer/QGst/StreamVolume>
    Player::Player(QWidget *parent)
    : QGst::Ui::VideoWidget(parent)
    {
    //this timer is used to tell the ui to change its position slider & label
    //every 100 ms, but only when the pipeline is playing
    connect(&m_positionTimer, SIGNAL(timeout()), this, SIGNAL(positionChanged()));
    }
    Player::~Player()
    {
    if (m_pipeline) {
    m_pipeline->setState(QGst::StateNull);
    stopPipelineWatch();
    }
    }
    void Player::setUri(const QString & uri)
    {
    QString realUri = uri;
    //if uri is not a real uri, assume it is a file path
    if (realUri.indexOf("://") < 0) {
    realUri = QUrl::fromLocalFile(realUri).toEncoded();
    }
    if (!m_pipeline) {
    m_pipeline = QGst::ElementFactory::make("playbin").dynamicCastQGst::Pipeline();
    if (m_pipeline) {
    //let the video widget watch the pipeline for new video sinks
    watchPipeline(m_pipeline);
    //watch the bus for messages
    QGst::BusPtr bus = m_pipeline->bus();
    bus->addSignalWatch();
    QGlib::connect(bus, "message", this, &Player::onBusMessage);
    } else {
    qCritical() << "Failed to create the pipeline";
    }
    }
    if (m_pipeline) {
    m_pipeline->setProperty("uri", realUri);
    }
    }
    QTime Player::position() const
    {
    if (m_pipeline) {
    //here we query the pipeline about its position
    //and we request that the result is returned in time format
    QGst::PositionQueryPtr query = QGst::PositionQuery::create(QGst::FormatTime);
    m_pipeline->query(query);
    return QGst::ClockTime(query->position()).toTime();
    } else {
    return QTime(0,0);
    }
    }
    void Player::setPosition(const QTime & pos)
    {
    QGst::SeekEventPtr evt = QGst::SeekEvent::create(
    1.0, QGst::FormatTime, QGst::SeekFlagFlush,
    QGst::SeekTypeSet, QGst::ClockTime::fromTime(pos),
    QGst::SeekTypeNone, QGst::ClockTime::None
    );
    m_pipeline->sendEvent(evt);
    }
    int Player::volume() const
    {
    if (m_pipeline) {
    QGst::StreamVolumePtr svp =
    m_pipeline.dynamicCastQGst::StreamVolume();
    if (svp) {
    return svp->volume(QGst::StreamVolumeFormatCubic) * 10;
    }
    }
    return 0;
    }
    void Player::setVolume(int volume)
    {
    if (m_pipeline) {
    QGst::StreamVolumePtr svp =
    m_pipeline.dynamicCastQGst::StreamVolume();
    if(svp) {
    svp->setVolume((double)volume / 10, QGst::StreamVolumeFormatCubic);
    }
    }
    }
    QTime Player::length() const
    {
    if (m_pipeline) {
    //here we query the pipeline about the content's duration
    //and we request that the result is returned in time format
    QGst::DurationQueryPtr query = QGst::DurationQuery::create(QGst::FormatTime);
    m_pipeline->query(query);
    return QGst::ClockTime(query->duration()).toTime();
    } else {
    return QTime(0,0);
    }
    }
    QGst::State Player::state() const
    {
    return m_pipeline ? m_pipeline->currentState() : QGst::StateNull;
    }
    void Player::play()
    {
    if (m_pipeline) {
    m_pipeline->setState(QGst::StatePlaying);
    }
    }
    void Player::pause()
    {
    if (m_pipeline) {
    m_pipeline->setState(QGst::StatePaused);
    }
    }
    void Player::stop()
    {
    if (m_pipeline) {
    m_pipeline->setState(QGst::StateNull);
    //once the pipeline stops, the bus is flushed so we will
    //not receive any StateChangedMessage about this.
    //so, to inform the ui, we have to emit this signal manually.
    Q_EMIT stateChanged();
    }
    }
    void Player::onBusMessage(const QGst::MessagePtr & message)
    {
    switch (message->type()) {
    case QGst::MessageEos: //End of stream. We reached the end of the file.
    stop();
    break;
    case QGst::MessageError: //Some error occurred.
    qCritical() << message.staticCastQGst::ErrorMessage()->error();
    stop();
    break;
    case QGst::MessageStateChanged: //The element in message->source() has changed state
    if (message->source() == m_pipeline) {
    handlePipelineStateChange(message.staticCastQGst::StateChangedMessage());
    }
    break;
    default:
    break;
    }
    }
    void Player::handlePipelineStateChange(const QGst::StateChangedMessagePtr & scm)
    {
    switch (scm->newState()) {
    case QGst::StatePlaying:
    //start the timer when the pipeline starts playing
    m_positionTimer.start(100);
    break;
    case QGst::StatePaused:
    //stop the timer when the pipeline pauses
    if(scm->oldState() == QGst::StatePlaying) {
    m_positionTimer.stop();
    }
    break;
    default:
    break;
    }
    Q_EMIT stateChanged();
    }
    All this i am using on Qt 5.0.1 on Ubuntu 12.04
    because of that Videowidget thing it is showiung that error of QtGui/QWidget No such file. Videowidget.h is READ only. so how to avoid this thing .

    i reallly appreciate your support.
    thnks


  • Lifetime Qt Champion

    How did you build QtGStreamer ?


Log in to reply
 

Looks like your connection to Qt Forum was lost, please wait while we try to reconnect.