text: /****************************************************************************
  **
  ** Copyright (C) 2016 The Qt Company Ltd.
  ** Contact: https://www.qt.io/licensing/
  **
  ** This file is part of the test suite of the Qt Toolkit.
  **
  ** $QT_BEGIN_LICENSE:GPL-EXCEPT$
  ** Commercial License Usage
  ** Licensees holding valid commercial Qt licenses may use this file in
  ** accordance with the commercial license agreement provided with the
  ** Software or, alternatively, in accordance with the terms contained in
  ** a written agreement between you and The Qt Company. For licensing terms
  ** and conditions see https://www.qt.io/terms-conditions. For further
  ** information use the contact form at https://www.qt.io/contact-us.
  **
  ** GNU General Public License Usage
  ** Alternatively, this file may be used under the terms of the GNU
  ** General Public License version 3 as published by the Free Software
  ** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
  ** included in the packaging of this file. Please review the following
  ** information to ensure the GNU General Public License requirements will
  ** be met: https://www.gnu.org/licenses/gpl-3.0.html.
  **
  ** $QT_END_LICENSE$
  **
  ****************************************************************************/
  
  #include "openglwidget.h"
  #include <QApplication>
  #include <QPushButton>
  #include <QMdiArea>
  #include <QMdiSubWindow>
  #include <QMenu>
  #include <QMenuBar>
  #include <QMainWindow>
  #include <QLCDNumber>
  #include <QScrollArea>
  #include <QScrollBar>
  #include <QTabWidget>
  #include <QLabel>
  #include <QTimer>
  #include <QSurfaceFormat>
  #include <QDebug>
  #include <private/qwindow_p.h>
  
  class Tools : public QObject
  {
      Q_OBJECT
  
  public:
      Tools(QWidget *root, QWidget *widgetToTurn, const QVector<QWidget *> glwidgets)
          : m_root(root), m_widgetToTurn(widgetToTurn), m_glWidgets(glwidgets) { }
      void dump();
  
  private slots:
      void turnNative();
      void hideShowAllGL();
      void dumpCompositingStatus();
  
  signals:
      void aboutToShowGLWidgets();
  
  private:
      void dumpWidget(QWidget *w, int indent = 0);
  
      QWidget *m_root;
      QWidget *m_widgetToTurn;
      QVector<QWidget *> m_glWidgets;
  };
  
  void Tools::turnNative()
  {
      qDebug("Turning into native");
      m_widgetToTurn->winId();
      dump();
  }
  
  void Tools::hideShowAllGL()
  {
      if (m_glWidgets[0]->isVisible()) {
          qDebug("Hiding all render-to-texture widgets");
          foreach (QWidget *w, m_glWidgets)
              w->hide();
      } else {
          qDebug("Showing all render-to-texture widgets");
          emit aboutToShowGLWidgets();
          foreach (QWidget *w, m_glWidgets)
              w->show();
      }
  }
  
  void Tools::dump()
  {
      qDebug() << "Widget hierarchy";
      dumpWidget(m_root);
      qDebug() << "========";
  }
  
  void Tools::dumpWidget(QWidget *w, int indent)
  {
      QString indentStr;
      indentStr.fill(' ', indent);
      qDebug().noquote() << indentStr << w << "winId =" << w->internalWinId();
      foreach (QObject *obj, w->children()) {
          if (QWidget *cw = qobject_cast<QWidget *>(obj))
              dumpWidget(cw, indent + 4);
      }
  }
  
  void Tools::dumpCompositingStatus()
  {
      QWindow *w = m_root->window()->windowHandle();
      qDebug() << "Compositing status for" << w << m_root->window() << "is" << QWindowPrivate::get(w)->compositing;
  }
  
  class TabWidgetResetter : public QObject
  {
      Q_OBJECT
  public:
      TabWidgetResetter(QTabWidget *tw) : m_tw(tw) { }
  public slots:
      void reset() { m_tw->setCurrentIndex(0); }
  private:
      QTabWidget *m_tw;
  };
  
  int main(int argc, char *argv[])
  {
      if (argc > 1 && !strcmp(argv[1], "--sharecontext")) {
          qDebug("Requesting all contexts to share");
          QCoreApplication::setAttribute(Qt::AA_ShareOpenGLContexts);
      }
  
      QApplication a(argc, argv);
  
      QSurfaceFormat format;
      if (QCoreApplication::arguments().contains(QLatin1String("--multisample")))
          format.setSamples(4);
      if (QCoreApplication::arguments().contains(QLatin1String("--coreprofile"))) {
          format.setVersion(3, 2);
          format.setProfile(QSurfaceFormat::CoreProfile);
      }
      qDebug() << "Requesting" << format;
  
      QMainWindow wnd;
      wnd.setObjectName("Main Window");
      wnd.resize(1024, 768);
  
      QMdiArea *w = new QMdiArea;
      w->setObjectName("MDI area");
      w->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
      wnd.setCentralWidget(w);
  
      OpenGLWidget *glw = new OpenGLWidget(33, QVector3D(0, 0, 1));
      glw->setObjectName("First GL Widget with 33 ms timer");
      glw->setFormat(format);
      glw->setMinimumSize(100, 100);
      QMdiSubWindow *sw = w->addSubWindow(glw);
      sw->setObjectName("First MDI Sub-Window");
      sw->setWindowTitle("33 ms timer");
  
      OpenGLWidget *glw2 = new OpenGLWidget(16);
      glw2->setObjectName("Second GL Widget with 16 ms timer");
      glw2->setFormat(format);
      glw2->setMinimumSize(100, 100);
      QOpenGLWidget *glw22 = new OpenGLWidget(16);
      glw22->setObjectName("Second #2 GLWidget");
      glw22->setParent(glw2);
      glw22->resize(40, 40);
      sw = w->addSubWindow(glw2);
      sw->setObjectName("Second MDI Sub-Window");
      sw->setWindowTitle("16 ms timer");
  
      OpenGLWidget *glw3 = new OpenGLWidget(0); // trigger updates continuously, no timer
      glw3->setObjectName("GL widget in scroll area (possibly native)");
      glw3->setFormat(format);
      glw3->setFixedSize(600, 600);
      OpenGLWidget *glw3child = new OpenGLWidget(0);
      const float glw3ClearColor[] = { 0.5f, 0.2f, 0.8f };
      glw3child->setClearColor(glw3ClearColor);
      glw3child->setObjectName("Child widget of GL Widget in scroll area");
      glw3child->setFormat(format);
      glw3child->setParent(glw3);
      glw3child->setGeometry(500, 500, 100, 100); // lower right corner of parent
      QScrollArea *sa = new QScrollArea;
      sa->setWidget(glw3);
      sa->setMinimumSize(100, 100);
      sa->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
      sw = w->addSubWindow(sa);
      sw->setObjectName("MDI Sub-Window for scroll area");
      sw->setWindowTitle("Cont. update");
      sw->resize(300, 300);
      sa->verticalScrollBar()->setValue(300);
  
      QLCDNumber *lcd = new QLCDNumber;
      lcd->display(1337);
      lcd->setMinimumSize(300, 100);
      sw = w->addSubWindow(lcd);
      sw->setObjectName("MDI Sub-Window for LCD widget");
      sw->setWindowTitle("Ordinary widget");
  
      QTabWidget *tw = new QTabWidget;
      QOpenGLWidget *glw4 = new OpenGLWidget(16, QVector3D(1, 0, 0));
      glw4->setObjectName("GL widget in tab widget");
      tw->addTab(glw4, "OpenGL");
      QLabel *label = new QLabel("Another tab");
      tw->addTab(label, "Not OpenGL");
      tw->setMinimumSize(100, 100);
      sw = w->addSubWindow(tw);
      sw->setObjectName("MDI Sub-Window for tab widget");
      sw->setWindowTitle("Tabs");
  
      TabWidgetResetter twr(tw);
      Tools t(&wnd, glw3, QVector<QWidget *>() << glw << glw2 << glw3 << glw4);
      QObject::connect(&t, SIGNAL(aboutToShowGLWidgets()), &twr, SLOT(reset()));
      QMenu *toolsMenu = wnd.menuBar()->addMenu("&Tools");
      toolsMenu->addAction("&Turn widgets (or some parent) into native", &t, SLOT(turnNative()));
      toolsMenu->addAction("&Hide/show all OpenGL widgets", &t, SLOT(hideShowAllGL()));
  
      QTimer compStatusDumpTimer;
      QObject::connect(&compStatusDumpTimer, SIGNAL(timeout()), &t, SLOT(dumpCompositingStatus()));
      compStatusDumpTimer.start(5000);
  
      wnd.show();
  
      if (glw->isValid())
          qDebug() << "Got" << glw->format();
  
      t.dump();
  
      return a.exec();
  }
  
  #include "main.moc"
  