Skip to content
  • Categories
  • Recent
  • Tags
  • Popular
  • Users
  • Groups
  • Search
  • Get Qt Extensions
  • Unsolved
Collapse
Brand Logo
  1. Home
  2. Qt Development
  3. General and Desktop
  4. QtGui/QWidget No Such file or Directory
QtWS25 Last Chance

QtGui/QWidget No Such file or Directory

Scheduled Pinned Locked Moved General and Desktop
qt5media playervideooutput
7 Posts 3 Posters 9.4k Views
  • Oldest to Newest
  • Newest to Oldest
  • Most Votes
Reply
  • Reply as topic
Log in to reply
This topic has been deleted. Only users with topic management privileges can see it.
  • J Offline
    J Offline
    JasonB
    wrote on last edited by
    #1

    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

    1 Reply Last reply
    0
    • joeQJ Offline
      joeQJ Offline
      joeQ
      wrote on last edited by
      #2

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

      Just do it!

      J 1 Reply Last reply
      0
      • joeQJ joeQ

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

        J Offline
        J Offline
        JasonB
        wrote on last edited by
        #3

        @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.

        1 Reply Last reply
        0
        • SGaistS Offline
          SGaistS Offline
          SGaist
          Lifetime Qt Champion
          wrote on last edited by
          #4

          Hi,

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

          Interested in AI ? www.idiap.ch
          Please read the Qt Code of Conduct - https://forum.qt.io/topic/113070/qt-code-of-conduct

          J 2 Replies Last reply
          0
          • SGaistS SGaist

            Hi,

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

            J Offline
            J Offline
            JasonB
            wrote on last edited by
            #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

            1 Reply Last reply
            0
            • SGaistS SGaist

              Hi,

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

              J Offline
              J Offline
              JasonB
              wrote on last edited by
              #6

              @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

              1 Reply Last reply
              0
              • SGaistS Offline
                SGaistS Offline
                SGaist
                Lifetime Qt Champion
                wrote on last edited by
                #7

                How did you build QtGStreamer ?

                Interested in AI ? www.idiap.ch
                Please read the Qt Code of Conduct - https://forum.qt.io/topic/113070/qt-code-of-conduct

                1 Reply Last reply
                0

                • Login

                • Login or register to search.
                • First post
                  Last post
                0
                • Categories
                • Recent
                • Tags
                • Popular
                • Users
                • Groups
                • Search
                • Get Qt Extensions
                • Unsolved