Tuesday, 9 March Introduction to Qt

Transcription

1 Introduction to Qt

2 Qt Qt supports the development of multi-platform GUI applications It has a write once, compile anywhere approach Using a single source tree and a simple recompilation applications can be written for Linux, Solaris Mac OS X and Windows Qt uses a unique inter-object communication mechanism called Signals and Slots Qt applications can be built visually using Qt Designer

3 More Specifically Qt includes a rich set of Widgets (controls) that provide standard GUI functionality Qt also provides a mechanism for handling all standard GUI events these include Mouse input Keyboard input Timers Drag and Drop from other GUI modules Qt also supports 2D and 3D (via OpenGL) graphics Also thematic support for various windows managers are included so look and feel is devolved from the design of the application to the Window manager level

4 Widgets Widgets are visual elements that are combined to create user interfaces. They include Buttons, Menus, scroll bars, message boxes and application main windows. Qt's widgets can be used as either controls or containers Custom widgets can be created by sub-classing the main widget class or other existing widgets A Widget can contain any number of child widgets and Qt provides layout managers to ease the positioning and re-sizing of widgets

5 Python Qt also has a python interface which allows us to develop GUI s for Python This can now also be used in both Maya and Houdini for development of user interfaces

6 A simple Example 1 #include <qapplication> 2 #include <qlabel> 3 4 int main(int argc, char *argv[]) 5 { 6 // make an instance of the QtApplicaiton 7 QApplication app(argc,argv); 8 // create a new label using HTML markupfor the text 9 QLabel *hello = new QLabel("<font color=blue size=\"45 \"><B>Hello</B><i>Qt!</i>/</font>",0); 10 // change the size of the widget 11 hello->resize(130, 80); 12 // show the widget 13 hello->show(); 14 // hand control over to the Qt sub system 15 return app.exec(); 16 }

7 Automatic Makefile generation The qmake tool will automatically pickup files in a directory and generate a suitable Qt makefile. Typically qmake reads in a.pro file to generate the Makefile however qmake will also generate the.pro file too. To generate a.pro file type 1 qmake -project -o Qt1.pro

8 Building the project 1 ###################################################################### 2 # Automatically generated by qmake (2.01a) Mon Mar 9 13:47: ###################################################################### 4 5 TEMPLATE = app 6 TARGET = Qt1 7 DEPENDPATH +=. 8 INCLUDEPATH += # Input 11 SOURCES += main.cpp qmake -project will generate the project file for the files in the current directory. Running qmake again (without arguments) will generate the Makefile. Then make is used to build the application

9 QtCreator With the new QtCreator IDE all the project files can be generated using the wizard The main processes outlined in the previous slides are the same, however they are combined into the creator app QMake / Make are still used

10 Extending Widgets with inheritance Developers can create their own widgets and dialogs by sub-classing QWidget or one of its subclasses. The following example subclasses the QLCDNumber widget to produce a full digital clock The LCDNumber widget can be set to have a number of segments and these values then set to be certain values based on a text string.

11 1 #ifndef CLOCK_H 2 #define CLOCK_H 3 4 #include <qlcdnumber> 5 6 // our clock class extends the QLCDNumber 7 class Clock : public QLCDNumber 8 { 9 10 public : 11 // ctor 12 Clock( 13 QWidget *_parent=0 14 ); 15 protected : 16 // an event to update the clock this even is provided by Qt 17 void timerevent( 18 QTimerEvent *_event 19 ); 20 private : 21 // draw the time 22 void ShowTime(); 23 // flash the : flag 24 bool m_showingcolon; }; #endif

12 1 #include <qdatetime> 2 3 #include "Clock.h" 4 5 Clock::Clock( 6 QWidget *_parent 7 ) : 8 QLCDNumber( 9 (uint)8, 10 _parent 11 ) 12 { 13 // set the flag to show the colon 14 m_showingcolon = true; 15 // call the method to set the LCD segments 16 ShowTime(); 17 // start a timer This is part of QObject and will execute 18 // the protected method timerevent when triggered 19 // we want the event every 1000ms to get our seconds 20 starttimer(1000); 21 // set the style of the LCD 22 setsegmentstyle(qlcdnumber::filled); 23 } void Clock::timerEvent( 26 QTimerEvent *_event 27 ) 28 { 29 // this is called when the timer is triggered. 30 ShowTime(); 31 } void Clock::ShowTime() 34 { 35 // Get the current time in the format hh:mm:ss 36 QString time = QTime::currentTime().toString("hh:mm:ss"); 37 // if we are showing the colon set it or a space 38 if(!m_showingcolon) 39 { 40 time[5]=' '; 41 } 42 // call the LCD widget's display method 43 display(time); 44 // toggle the colon 45 m_showingcolon ˆ=true; 46 }

13 Clock Main application 1 #include <qapplication> 2 3 #include "Clock.h" 4 5 int main( 6 int _argc, 7 char *_argv[] 8 ) 9 { 10 QApplication app(_argc,_argv); 11 Clock *clock = new Clock; 12 clock->resize(800,200); 13 clock->show(); 14 return app.exec(); 15 }

14 Signals and Slots GUI applications respond to user actions For example when a user clicks a menu item or a toolbar button the application executes some code More generally we want objects of any kind to be able to communicate with each other. The programmer must relate events to the relevant code. A signal in Qt is multicast so all object will receive it, we must hook up objects we want to respond to a particular signal.

15 Signals and Slots are a flexible OO system of inter-object communication written in C++ With the callback system it is necessary to pass a pointer to a function to the object being processed. When the button is then pressed the function is called. With signals each Widget emits a signal when an event occurs. For example when a button is clicked the Button will emit a clicked signal. This signal can then be connected to a function (called a slot) calling the connect() function to relate the signal to a particular slot.

16 For example if a Quit button's clicked() signal is connected to the application's quit() slot a user's click on Quit makes the application terminate. In Code this is written as 1 connect(button,signal(clicked()),qapp,slot(quit())); Connections can be added or removed at any time during the execution of a Qt application.

17 Signals and Slots Example To benefit from Signals and Slots, a class must inherit from QObject or one of its subclasses. It must also include the Q_OBJECT macro in the class's definition. Signals are declared in the signals section of the class while slots are declared in the public slots, protected slots or private slots sections This will then automatically generate wrapper code using the qt Meta-object compiler (moc) This code should not be edited.

18 SimpleEditor UI This simple editor has the ability to load a file into the edit widget Save the file Clear the text window It also uses the Qt File Widget to select the file for load and save And used Signals and Slots for Communications

19 1 #ifndef UI_SIMPLEEDIT_H 2 #define UI_SIMPLEEDIT_H 3 4 class SimpleEditor : public QMainWindow 5 { 6 Q_OBJECT 7 private : 8 // the main widget for the UI 9 QWidget *centralwidget; 10 // text edit widget used for the main text area. 11 QTextEdit *textedit; 12 // a button to clear the screen 13 QPushButton *ClearButton; 14 // a button to save the contents of the text edit. 15 QPushButton *SaveButton; 16 // a button to load a file to the text edit. 17 QPushButton *LoadButton; private slots: 20 // slots to respond to the button clicks 21 void ClearText(); 22 void SaveText(); 23 void LoadText(); 24 public: 25 // ctor 26 SimpleEditor(QWidget *parent=null, Qt::WindowFlags flags=0); 27 // build the ui and set the widgets 28 void setupui(qmainwindow *MainWindow); 29 // re-set various elements 30 }; #endif // UI_SIMPLEEDIT_H

20 1 SimpleEditor::SimpleEditor(QWidget *parent, Qt::WindowFlags flags): QMainWindow(parent, flags) 2 { 3 // setup the widgets and build the main UI. 4 setupui(this); 5 // connect the different buttons click methods to the Functions 6 connect(clearbutton, SIGNAL(clicked ()),this, SLOT(ClearText(void))) ; 7 connect(savebutton, SIGNAL(clicked ()),this, SLOT(SaveText(void))) ; 8 connect(loadbutton, SIGNAL(clicked ()),this, SLOT(LoadText(void))) ; 9 10 } void SimpleEditor::setupUi(QMainWindow *MainWindow) 14 { 15 // if the main windo has no been named name it. 16 if (MainWindow->objectName().isEmpty()) 17 MainWindow->setObjectName(QString::fromUtf8("MainWindow")); 18 // set the size of the window 19 MainWindow->resize(579, 399); 20 MainWindow->setWindowTitle(QApplication::translate("MainWindow", "SimpleEditor", 0, QApplication: :UnicodeUTF8)); // create a centeral widget and set it's name 23 centralwidget = new QWidget(MainWindow); 24 centralwidget->setobjectname(qstring::fromutf8("centralwidget")); 25 // now we create the other widets and make them parented to the centeral widget. 26 // add the textedit component 27 textedit = new QTextEdit(centralwidget); 28 textedit->setobjectname(qstring::fromutf8("textedit")); 29 textedit->setgeometry(qrect(20, 20, 421, 341)); 30 // set the clear button 31 ClearButton = new QPushButton(centralwidget); 32 ClearButton->setObjectName(QString::fromUtf8("ClearButton")); 33 ClearButton->setGeometry(QRect(450, 30, 113, 32)); 34 ClearButton->setText(QApplication::translate("MainWindow", "Clear Text", 0, QApplication:: UnicodeUTF8)); // set the save button 37 SaveButton = new QPushButton(centralwidget); 38 SaveButton->setObjectName(QString::fromUtf8("SaveButton")); 39 SaveButton->setText(QApplication::translate("MainWindow", "Save", 0, QApplication::UnicodeUTF8)); // set the load button. 42 SaveButton->setGeometry(QRect(450, 70, 113, 32)); 43 LoadButton = new QPushButton(centralwidget); 44 LoadButton->setObjectName(QString::fromUtf8("Load")); 45 LoadButton->setGeometry(QRect(450, 110, 113, 32)); 46 LoadButton->setText(QApplication::translate("MainWindow", "Load", 0, QApplication::UnicodeUTF8)); // now add the centeral widget to the main window. 49 MainWindow->setCentralWidget(centralwidget); } // setupui

21 1 void SimpleEditor::LoadText() 2 { 3 QString filename; 4 // load the file by getting the file name from the dialog 5 if (filename.isnull()) 6 filename = QFileDialog::getOpenFileName(this, 7 tr("open File"), "", "ALL Files (*)"); 8 // if this is not empty 9 if (!filename.isempty()) 10 { 11 QFile file(filename); 12 // read the file and check for text 13 if (file.open(qfile::readonly QFile::Text)) 14 textedit->settext(file.readall()); 15 } 16 } 1 void SimpleEditor::ClearText() 2 { 3 // call the clear method to clear the text edit. 4 textedit->clear(); 5 }

22 1 void SimpleEditor::SaveText() 2 { 3 // use on of the dialog boxes to get the file name to save 4 QString s = QFileDialog::getSaveFileName(this, 5 tr("qfiledialog::getsavefilename()"), 6 "", 7 tr("all Files (*);"), 8 NULL 9 ); // if this is empty do not save. 12 if (s.isempty()) 13 return; 14 else 15 { 16 // use the QFile object to save the file 17 QFile file( s ); // Write the text to a file 18 if ( file.open( QFile::WriteOnly ) ) 19 { 20 // create a text stream and pass the textedit data to it as plain text 21 QTextStream stream( &file ); 22 stream << textedit->toplaintext(); 23 } 24 } 25 }

23 Designer Qt has a User interface design tool called designer(-qt4) This allows the development of basic user interfaces, Forms, Widgets and main window applications It will also allow the generation of C++ code that can be used to create the window in the application. This code is generated using the uic program (User Interface Compiler)

24 Using Designer Files in a Project We can add the ui file generated to the.pro file and every time the ui file changes it will be re-compiled into a new.h file of the same name as the ui file with the prefix ui. In this example ui_mainwindow.h will be created 1 # # 3 # Project created by QtCreator T23:20:09 4 # 5 # QT += opengl 8 9 TARGET = QtGLBaseApp 10 TEMPLATE = app SOURCES += main.cpp\ 14 mainwindow.cpp GLWindow.cpp HEADERS += mainwindow.h GLWindow.h FORMS += mainwindow.ui 19 INCLUDEPATH = $(HOME)/GraphicsLib/include 20 unix:libs += -lglew 21 LIBS += -L/$(HOME)/GraphicsLib/lib -l GraphicsLib

25 ui header file. As the ui header file is generated automatically it will always have the same format as shown This file should not be edited as it is generated code 1 #ifndef UI_MAINWINDOW_H 2 #define UI_MAINWINDOW_H 3 4 #include <QtCore/QVariant> class Ui_MainWindowClass 7 { 8 public: 9 QWidget *centralwidget; void setupui(qmainwindow *MainWindowClass) 12 { 13 if (MainWindowClass->objectName().isEmpty()) 14 MainWindowClass->setObjectName(QString::fromUtf8("MainWindowClass")); retranslateui(mainwindowclass); QMetaObject::connectSlotsByName(MainWindowClass); 19 } // setupui void retranslateui(qmainwindow *MainWindowClass) 22 { 23 MainWindowClass->setWindowTitle(QApplication::translate("MainWindowClass", "Qt OpenGL Demo Application", 0, QApplication::UnicodeUTF8)); Q_UNUSED(MainWindowClass); 26 } // retranslateui }; namespace Ui { 31 class MainWindowClass: public Ui_MainWindowClass {}; 32 } // namespace Ui #endif // UI_MAINWINDOW_H

26 Using the ui Form The ui form is placed in a namespace called Ui To use the form we need to create a new class within this namespace and call the setupui function to create the form / window. If we wish to extend the functionality of the form we can add new widgets etc within this new Class. Typically this class is called the same thing as the ui window calling it but it doesn t need to be. The following code shows the basic structure of the class

27 1 #ifndef MAINWINDOW_H 2 #define MAINWINDOW_H 3 4 #include <QtGui/QMainWindow> 5 6 // add the MainWindowClass to the namespace Ui 7 // Ui is automatically created by the mainwindow.ui file in the designer 8 namespace Ui 9 { 10 class MainWindowClass; 11 } // This is the MainWindow Class which is generated by the Ui file, if we wish to add anything to the main 14 // Ui we add it here 15 class MainWindow : public QMainWindow 16 { 17 Q_OBJECT 18 protected : 19 public: 20 // ctor 21 MainWindow(QWidget *parent = 0); 22 // dtor 23 MainWindow(); private slots : private: 28 // The actual Ui interface created in designer 29 Ui::MainWindowClass *ui; }; #endif // MAINWINDOW_H

28 ctor / dtor 1 MainWindow::MainWindow(QWidget *parent) 2 : QMainWindow(parent), ui(new Ui::MainWindowClass) 3 { 4 // setup the Ui, this method is generated automatically from the Designer file 5 // any changes in the designer will change this file and we don't need to edit it. 6 ui->setupui(this); 7 // we add any new functionality we need here 8 // add any signals / slots we need here 9 10 } MainWindow:: MainWindow() 13 { 14 // remove the ui on completion 15 delete ui; 16 }

29 main.cpp 1 #include <QtGui/QApplication> 2 #include "mainwindow.h" 3 // this code runs the basic main window and is created by the Qt Creator app 4 int main(int argc, char *argv[]) 5 { 6 // make an instance of the QApplication 7 QApplication a(argc, argv); 8 // Create a new MainWindow 9 MainWindow w; 10 // show it 11 w.show(); 12 // hand control over to Qt framework 13 return a.exec(); 14 }

30 Case Study OpenGL Application

31

32 User Interface The UI has a number of controls which will change attributes in the OpenGL Window. It also has a QFrame widget placed as a container for the GLWindow which is created as a separate class in the project. This allows us to specify where the GLWindow will be placed in the initial ui design, and then over-ride it later when we create the GLWindow in code. Qt has a special Widget called QGLWidget which is specifically designed to allow access to OpenGL We just extend it using inheritance to create our own Class.

33 QGLWidget QGLWidget provides functionality for displaying OpenGL graphics integrated into a Qt application. It is very simple to use. You inherit from it and use the subclass like any other QWidget, except that you have the choice between using QPainter and standard OpenGL rendering commands. QGLWidget provides three convenient virtual functions that you can reimplement in your subclass to perform the typical OpenGL tasks which are shown on the next slide

34 QGLWidget paintgl() - Renders the OpenGL scene. Gets called whenever the widget needs to be updated. resizegl() - Sets up the OpenGL viewport, projection, etc. Gets called whenever the the widget has been resized (and also when it is shown for the first time because all newly created widgets get a resize event automatically). initializegl() - Sets up the OpenGL rendering context, defines display lists, etc. Gets called once before the first time resizegl() or paintgl() is called.

35 ngl + Qt We can also use ngl with Qt, however some elements are not used We do not need to use SDL Video if we are using Qt as SDL is a kind of windowing system as well, however other elements (Joystick, sound could be used) To use ngl we need to add an number of ngl specific defines to the project, these can be seen in the following example. Using QtCreator is also the best way of getting ngl and ngl examples working under windows

36 GLWindow Class 1 class GLWindow : public QGLWidget 2 { 3 Q_OBJECT 4 public : 5 GLWindow( 6 QWidget *_parent 7 ); 8 9 void RotateGL( 10 const float _x, 11 const float _y, 12 const float _z 13 ); inline void SetObject( 16 const int _o 17 ) {m_object=_o;} inline void SetScale( 20 const float _s 21 ){m_scale=_s;} inline void SetColour( 24 const float _r, 25 const float _g, 26 const float _b); void ToggleWireframe(); void MoveCamera( 31 const float _x, 32 const float _y, 33 const float _z 34 ); 35 private : 36 int m_spinxface; 37 int m_spinyface; 38 bool m_rotate; 39 int m_origx; 40 int m_origy; 41 ngl::camera *m_cam; 42 float m_xrot; 43 float m_yrot; 44 float m_zrot; 45 int m_object; 46 float m_scale; 47 ngl::colour m_colour; 48 bool m_wireframe; 49 protected: void initializegl(); 52 void resizegl( 53 const int _w, 54 const int _h 55 ); 56 void paintgl(); };

37 GLWindow Methods The ctor is used to setup the class attributes and default values. No OpenGL commands are issued here, and no ngl opengl Classes are constructed as we need a valid gl contex first. 1 GLWindow::GLWindow( 2 QWidget *_parent 3 ) : 4 QGLWidget(_parent) 5 { 6 7 // set this widget to have the initial keyboard focus 8 setfocus(); 9 // re-size the widget to that of the parent (in this case the GLFrame passed in on construction) 10 this->resize(_parent->size()); 11 // Now set the initial GLWindow attributes to default values 12 // Roate is false 13 m_rotate=false; 14 // mouse rotation values set to 0 15 m_spinxface=0; 16 m_spinyface=0; 17 m_xrot=0.0; 18 m_yrot=0.0; 19 m_zrot=0.0; 20 // initial object is 0 (Teapot) 21 m_object=0; 22 // scale is m_scale=1.0; 24 // set wireframe to true 25 m_wireframe=true; 26 }

38 1 void GLWindow::initializeGL() 2 { 3 // now we construct the Camera which will be initialise in the reshape method 4 ngl::vector eye(2,2,2); 5 ngl::vector look(0,0,0); 6 ngl::vector up(0,1,0,1); 7 8 m_cam = new ngl::camera(eye,look,up,ngl::perspective); 9 m_cam->setshape(90,(float)780.0/576.0,0.4,20,ngl::perspective); 10 // set the colour to white m_colour.set(1,1,1); ngl::nglinit *Init = ngl::nglinit::instance(); 15 Init->InitGlew(); 16 Init->InitVBOandImageLib(); 17 ngl::vboprimitives *prim=ngl::vboprimitives::instance(); 18 prim->createvbosphere("sphere",0.5,50); glenable(gl_lighting); 21 // smooth shading 22 glshademodel(gl_smooth); 23 // depth testing 24 glenable(gl_depth_test); 25 //.5 gray background colour 26 glclearcolor(0.5,0.5,0.5,1.0); 27 // create a basic light 28 glenable(gl_light0); 29 float pos[]={2,2,2,1}; 30 gllightfv(gl_light0,gl_position,pos); 31 // enable colour material so the current colour will change the material 32 glenable(gl_color_material); 33 glcolormaterial(gl_front_and_back,gl_ambient_and_diffuse); 34 }

39 1 void GLWindow::paintGL() 2 { 3 // clear the screen 4 glclear(gl_color_buffer_bit GL_DEPTH_BUFFER_BIT); 5 // now setup our camera 6 m_cam->use(); 7 // push the gl matrix 8 glpushmatrix(); 9 // do global mouse rotation 10 glrotated( (GLdouble) m_spinxface, 1.0, 0.0, 0.0 ) ; 11 glrotated( (GLdouble) m_spinyface, 0.0, 1.0, 0.0 ) ; 12 glpushmatrix(); 13 // now do local rotations based on the X,Y,Z values change for the GUI 14 glrotatef(m_xrot,1,0,0); 15 glrotatef(m_yrot,0,1,0); 16 glrotatef(m_zrot,0,0,1); 17 // now we do the scale and actually draw the model 18 glpushmatrix(); 19 // set the colour 20 m_colour.use(); 21 // scale 22 glscalef(m_scale,m_scale,m_scale); 23 // decide which object to draw ngl::vboprimitives *prim=ngl::vboprimitives::instance(); 26 if(m_wireframe==true) 27 { 28 glpolygonmode(gl_front_and_back,gl_line); 29 } 30 else 31 { 32 glpolygonmode(gl_front_and_back,gl_fill); 33 } 34 switch (m_object) 35 { 36 case 0 : { prim->drawvbo("teapot"); break; } 37 case 1 : { prim->drawvbo("sphere"); break; } 38 case 2 : { prim->drawvbo("cube"); break; } 39 } 40 glpopmatrix(); // end scale push 41 glpopmatrix(); // end gui rotate push 42 glpopmatrix(); // end mouse push 43 }

40 Mouse Events Each widget will receive a mouse event when the mouse is activated within the range of the widget. The QObject base class implements a basic mouse event handler which can be over-ridden in the sub class to catch mouse events and process them. The basic mouse handlers are as follows 1 void mousemoveevent ( QMouseEvent * event ) ; 2 3 void mousepressevent ( QMouseEvent * event ) ; 4 5 void mousereleaseevent ( QMouseEvent * event );

41 mousepressevent The Mouse Press event is triggered when the mouse button is pressed over the widget. To determine the button pressed we have to query the event structure and look for the button as shown in the example below 1 void GLWindow::mousePressEvent ( 2 QMouseEvent * _event 3 ) 4 { 5 // this method is called when the mouse button is pressed in this case we 6 // store the value where the maouse was clicked (x,y) and set the Rotate flag to true 7 if(_event->button() == Qt::LeftButton) 8 { 9 m_origx = _event->x(); 10 m_origy = _event->y(); 11 m_rotate =true; 12 } 13 }

42 mousereleaseevent This event is triggered when the mouse button is released, if the mouse press was captured over the widget the release may not necessarily me released over that widget 1 void GLWindow::mouseReleaseEvent ( 2 QMouseEvent * _event 3 ) 4 { 5 // this event is called when the mouse button is released 6 // we then set Rotate to false 7 if (_event->button() == Qt::LeftButton) 8 { 9 m_rotate=false; 10 } 11 }

43 mousemoveevent The move event is triggered when the mouse is moved, we can check the state of the button in this method to see if it is being held 1 void GLWindow::mouseMoveEvent ( 2 QMouseEvent * _event 3 ) 4 { 5 // note the method buttons() is the button state when event was called 6 // this is different from button() which is used to check which button was 7 // pressed when the mousepress/release event is generated 8 if(m_rotate && _event->buttons() == Qt::LeftButton) 9 { 10 m_spinyface = ( m_spinyface + (_event->x() - m_origx) ) % 360 ; 11 m_spinxface = ( m_spinxface + (_event->y() - m_origy) ) % 360 ; 12 m_origx = _event->x(); 13 m_origy = _event->y(); 14 } 15 // re-draw GL 16 updategl(); 17 }

44 MainWindow Class The MainWindow class creates an instance of the ui created in designer. Any extra functionality such as extra widgets or signal handling is implemented in this class. The MainWindow class for the GL application is shown next

45 1 #include <QtGui/QMainWindow> 2 #include <QtGui/QColorDialog> 3 4 #include "GLWindow.h" namespace Ui 8 { 9 class MainWindowClass; 10 } class MainWindow : public QMainWindow 13 { 14 Q_OBJECT 15 protected : 16 void keypressevent( 17 QKeyEvent *_event 18 ); 19 public: 20 // ctor 21 MainWindow(QWidget *parent = 0); 22 // dtor 23 MainWindow(); 24 private slots : 25 void RotateGL(); 26 void SetObject( 27 int _object 28 ); 29 void SetScale( 30 double _scale 31 ); 32 void ChangeColour(); void ChangeDrawMode(){m_gl->ToggleWireframe();}; private: 37 Ui::MainWindowClass *m_ui; 38 GLWindow *m_gl; 39 };

46 ctor 1 MainWindow::MainWindow( 2 QWidget *parent 3 ): 4 QMainWindow(parent), m_ui(new Ui::MainWindowClass) 5 { 6 // setup the Ui, this method is generated automatically from the Designer file 7 // any changes in the designer will change this file and we don't need to edit it. 8 m_ui->setupui(this); 9 // now we create an instance of our GLWindow with the GLFrame created in the Ui file. 10 // This allows us to create a place holder for the GLWindow in designer and the GLWindow inherits this 11 // as the parent. 12 m_gl = new GLWindow(m_ui->s_GLFrame); // we now manually connect the different signals and slots for our GUI clsomponents so we can 15 // call different methods when values are changed. 16 connect(m_ui->m_rotx,signal(valuechanged(int)),this,slot(rotategl())); 17 connect(m_ui->m_roty,signal(valuechanged(int)),this,slot(rotategl())); 18 connect(m_ui->m_rotz,signal(valuechanged(int)),this,slot(rotategl())); 19 connect(m_ui->m_objectchoice,signal(currentindexchanged(int)),this,slot(setobject(int))); 20 connect(m_ui->m_scale,signal(valuechanged(double)),this,slot(setscale(double))); 21 connect(m_ui->m_colour,signal(clicked()),this,slot(changecolour())); 22 connect(m_ui->m_wireframe,signal(clicked()),this,slot(changedrawmode())); // set the MainWindow to have focus once a widget has been released. 25 setfocuspolicy(qt::strongfocus); 26 }

47 keypressevent The QMainWindow class will process all keyboard events using the keypressevent method We can over-ride this method in the inherited class and call methods (such as move a camera). Care must be taken with this as the Ui has certain key combinations and short cuts which may also be set.

48 1 void MainWindow::keyPressEvent( 2 QKeyEvent *_event 3 ) 4 { 5 // this method is called every time the main window recives a key event. 6 // we then switch on the key value and set the camera in the GLWindow 7 switch (_event->key()) 8 { 9 case Qt::Key_Up : { m_gl->movecamera(0,-0.1,0); break; } 10 case Qt::Key_Down : { m_gl->movecamera(0,0.1,0); break; } 11 case Qt::Key_Left : { m_gl->movecamera(0.1,0,0); break; } 12 case Qt::Key_Right : { m_gl->movecamera(-0.1,0,0); break; } 13 case Qt::Key_I : { m_gl->movecamera(0,0,0.1); break; } 14 case Qt::Key_O : { m_gl->movecamera(0,0,-0.1); break; } 15 } 16 // finally update the GLWindow and re-draw 17 m_gl->updategl(); 18 }

49 Message Passing with Slots For each UI component that effects some of OpenGL elements we assign a signal / slot combination The Process is then to respond to an event and call a method in the m_gl class contained in the MainWindow class

50 1 void MainWindow::RotateGL() 2 { 3 // This method is called everytime one of the rotation sliders is changed 4 // we get the value of x,y,z rot and pass it to the GLWindow RotateGL method 5 m_gl->rotategl(-m_ui->m_rotx->value(),m_ui->m_roty->value(),m_ui->m_rotz->value()); 6 // we now tell the GLWindow to update and re-draw. 7 m_gl->updategl(); 8 } 1 void MainWindow::SetObject(int _object) 2 { 3 // This slot is called when the combo box is changed 4 // the index into the combo box i is passed to the slot and used to set the object property 5 // in the GLWindow 6 m_gl->setobject(_object); 7 // we now tell the GLWindow to update and re-draw 8 m_gl->updategl(); 9 } 1 void MainWindow::SetScale( 2 double _scale 3 ) 4 { 5 // This slot is called when the scale spinbox is changed 6 // the value is passed to the slot and scale is changed in the GLWindow 7 m_gl->setscale(_scale); 8 // we now tell the GLWindow to update and re-draw. 9 m_gl->updategl(); 10 }

51 Colour dialog 1 void MainWindow::ChangeColour() 2 { 3 // this slot is called when the colour button is pushed 4 // we first use the colour diam_glog to get the colour 5 6 QColor colour = QColorDialog::getColor(); 7 // we now check to see if a colour was set or if the cancel was pressed 8 // using the isvalid method 9 10 if (colour.isvalid()) 11 { 12 // if it was we get the colour values using the..f() function and call the 13 // SetColour method in the GLWindow 14 m_gl->setcolour(colour.redf(),colour.greenf(),colour.bluef()); 15 // finally we update the GLWindow m_gl->updategl(); 18 } 19 }

52 References Qt Documentation