Russian Qt Forum

QT       += core gui

greaterThan(QT_MAJOR_VERSION, 4): QT += widgets

TEMPLATE = app
TARGET = gotocell
INCLUDEPATH += .

# Input
SOURCES += main.cpp
HEADERS  += mainwindow.h
FORMS += gotocelldialog.ui

#include <QApplication>
#include <QDialog>

#include "ui_gotocelldialog.h"

int main(int argc, char *argv[])
{
	QApplication app(argc, argv);
	Ui::GoToCellDialog ui;
	QDialog *dialog = new QDialog;
	ui.setupUi(dialog);
	dialog->show();

	return app.exec();
}

QT       += core gui

greaterThan(QT_MAJOR_VERSION, 4): QT += widgets

QT       += core gui

greaterThan(QT_MAJOR_VERSION, 4): QT += widgets

#include <QObject>
class htmlhandler : public QObject
{
    Q_OBJECT
public:
    explicit htmlhandler(QObject *parent = 0);

public slots:
    void process_url();
};

--- (Import): Generating new project of paint2.pro file
--- (qmake) : Using: c:\qt\qt5.5.0\5.5\msvc2013_64\bin\qmake
--- (qmake) : Working Directory: E:\Qt\APP2\paint2
--- (qmake) : Arguments: -tp vc "paint2.pro" -o "paint2.vcxproj" QMAKE_INCDIR_QT=$(QTDIR)\include QMAKE_LIBDIR=$(QTDIR)\lib QMAKE_MOC=$(QTDIR)\bin\moc.exe QMAKE_QMAKE=$(QTDIR)\bin\qmake.exe

[1] - Could not find qmake configuration file win32-msvc2013_64.
[2] - Error processing project file: paint2.pro

--- (Import): Error(s): 2
--- (qmake) : Exit Code: 3

--- (Import): Generating new project of paint2.pro file
--- (qmake) : Using: c:\qt\qt5.5.0\5.5\msvc2013_64\bin\qmake
--- (qmake) : Working Directory: E:\Qt\APP2\paint2
--- (qmake) : Arguments: -tp vc "paint2.pro" -o "paint2.vcxproj" QMAKE_INCDIR_QT=$(QTDIR)\include QMAKE_LIBDIR=$(QTDIR)\lib QMAKE_MOC=$(QTDIR)\bin\moc.exe QMAKE_QMAKE=$(QTDIR)\bin\qmake.exe

[1] - Could not find qmake configuration file win32-msvc2013_64.
[2] - Error processing project file: paint2.pro

--- (Import): Error(s): 2
--- (qmake) : Exit Code: 3

[1] - Could not find qmake configuration file win32-msvc2013_64.

#include "paint.h"
#include <QtWidgets>

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    paint w;
    w.show();
    return a.exec();
}

#ifndef PAINT_H
#define PAINT_H

#include <QtWidgets>

class paint : public QWidget
{
    Q_OBJECT
public:
    int btn;
    QVector<QPoint> vec;
    QVector<QPoint> vec2;
    explicit paint(QWidget *parent = 0);

protected:
    virtual void paintEvent(QPaintEvent*);
    virtual void mousePressEvent(QMouseEvent * ev);
    virtual void mouseMoveEvent(QMouseEvent * ev2);

signals:

public slots:
};

#endif // PAINT_H

#include "paint.h"

paint::paint(QWidget *parent) : QWidget(parent)
{

}

void paint::paintEvent(QPaintEvent *)
{
    QPainter p(this);
    p.setPen(QPen(Qt::black,3));
    if(btn==1){
        p.setPen(QPen(Qt::white,3));
    }
    
    
    for(int i = 0; i<vec.count(); ++i)
   {
      p.drawPoint(vec[i]);
    }

     for(int i = 1; i<vec2.count(); ++i)
    {
    p.drawLine(vec2[i-1],vec2[i]);
     }
   
}



void paint::mousePressEvent(QMouseEvent *ev)
{
    if(ev->button()==Qt::RightButton){
        btn=1;
    }
    else{
        btn=0;
    }
    vec.insert(vec.end(),ev->pos());
     this->repaint();

}

void paint::mouseMoveEvent(QMouseEvent *ev2)
{

    vec2.insert(vec2.end(),ev2->pos());
    this->repaint();
}

import QtQuick 2.5
import Qt.labs.controls 1.0

Item {
    clip:true
    property int margin: 20
    property int fontSize:  12
    property int ceilSize:  20;
    property int incCeilSize: ceilSize + 1
    property color borderColor: "#424242"

    property int rows:       0;
    property int rowSize:    0;

    property int column:     0;
    property int columnSize: 0;

    implicitHeight : crossGrid.height+margin*2
    implicitWidth : crossGrid.width+margin*2

    function loadFromNonogramsOrg(url) {
        console.log("Load:"+url);
        crossword.formNanogramsOrg(url);
    }

    function showOnlyNaturalNumber(val)
    {
        return val > 0 ? val: " ";
    }

    function drawCrossword(){
        var csize = crossword.size;
        if(csize.column() === 0 || csize.rows() === 0){
            return;
        }
        console.log(csize.column() + "x" + csize.rows());
        hRepeater.model = 0;
        rRepeater.model = 0;

        rowSize = crossword.rowSize();
        columnSize = crossword.columnSize();

        rows = csize.rows();
        column = csize.column();

        hRepeater.model = crossword.columnSize()*csize.column();
        rRepeater.model = crossword.rowSize()*csize.rows();
        bgImg.visible = true;
    }

    Image{
        id: bgImg
        asynchronous: true
        visible: false
        height: parent.height
        width: parent.width
        source:"qrc:/wall-paper.jpg"
    }

    Grid {
        id: crossGrid
        anchors.centerIn: parent
        columns: 2
        spacing: 2
        rowSpacing: 0
        columnSpacing: 0

        Rectangle{
            id:topLeftItm
            width: rowSize * ceilSize
            height:columnSize * ceilSize
            border.width: 1
            border.color: borderColor
            color: "transparent"
        }

        Grid {
            id: cGrid
            rows: columnSize
            columns: column

            Repeater {
                id: hRepeater
                model: 0
                Item {
                    width: ceilSize; height: ceilSize
                    property int rw : Math.floor(index/column)
                    property int cn : Math.floor(index%column)
                    property int prw: rw+1
                    property int pcm: cn+1

                    Rectangle{
                        height: (prw % 5 == 0) || (prw == columnSize) ? ceilSize : incCeilSize
                        width:  (pcm % 5 == 0)  ? ceilSize : incCeilSize
                        color: "transparent"
                        border.width: 1
                        border.color: borderColor

                        Text {
                            anchors.centerIn: parent
                            text:showOnlyNaturalNumber(
                                     crossword.columnValue(cn,rw));
                            font{
                                family: mandarinFont.name
                                pixelSize: fontSize
                            }
                        }

                    }
                }
            }
        }

        Grid {
            id: rGrid
            rows: rows
            columns: rowSize

            Repeater {
                id: rRepeater
                model: 0
                Item {
                    width: ceilSize; height: ceilSize
                    property int rw : Math.floor(index/rowSize)
                    property int cn : Math.floor(index%rowSize)
                    property int prw: rw+1
                    property int pcn: cn+1

                    Rectangle{
                        height: prw % 5 == 0 ? ceilSize : incCeilSize
                        width:  (pcn % 5 == 0) || (pcn == rowSize)
                                ? ceilSize : incCeilSize
                        color: "transparent"
                        border.width: 1
                        border.color: borderColor

                        Text {
                            anchors.centerIn: parent
                            text:showOnlyNaturalNumber(
                                     crossword.rowValue(rw,cn));
                            font{
                                family: mandarinFont.name
                                pixelSize: fontSize
                            }
                        }
                    }
                }
            }
        }

        Rectangle{
            id: playingField
            width: column * ceilSize
            height:rows   * ceilSize
            border.width: 1
            border.color: borderColor
            color: "transparent"

            Grid{
                rows: rows
                columns:column
                Repeater {
                    id: bRepeater
                    model: rows * column
                    Item {
                        id: ceilItm
                        width: ceilSize; height: ceilSize
                        property int rw : Math.floor(index/column)
                        property int cn : Math.floor(index%column)
                        state: "default"

                        Rectangle{
                            id: itmRec
                            height: (rw+1) % 5 == 0 ? ceilSize : incCeilSize
                            width: (cn+1) % 5 == 0  ? ceilSize : incCeilSize
                            color: "transparent"
                            border.width: 1
                            border.color: borderColor
                        }

                        Text{
                            id: itmTxt
                            visible:false
                            height: parent.height
                            width: parent.width
                            font.pixelSize: ceilSize
                            horizontalAlignment: Text.AlignHCenter
                            verticalAlignment:   Text.AlignVCenter
                            text:"+"
                            rotation:45
                        }

                        MouseArea {
                            anchors.fill: parent
                            onClicked: {
                                if(parent.state == "default"){
                                    parent.state = "SHADED";
                                }else if(parent.state == "SHADED"){
                                    parent.state = "CLEAR";
                                }else{
                                    parent.state = "default";
                                }

                            }
                        }

                        states: [
                            State{
                                name:"SHADED"
                                PropertyChanges {
                                    target: itmRec; color: "black";
                                }
                                PropertyChanges {
                                    target: itmTxt; visible: false;
                                }
                            },
                            State{
                                name:"CLEAR"
                                PropertyChanges {
                                    target: itmRec; color: "transparent";
                                }
                                PropertyChanges {
                                    target: itmTxt; visible: true;
                                }
                            }
                        ]
                    }
                }
            }
        }
    }

    Text{
        visible: bgImg.visible
        anchors{
            right: parent.right
            rightMargin: 10
            bottom: parent.bottom
        }
        text:qsTr("Source: ")+"www.nonograms.ru"

        font{
            family: hanZiFont.name
            pixelSize: 12
        }
    }

    Connections {
        target: crossword
        onLoaded: {
            drawCrossword();
        }
    }
}

        this->_Thread = new QThread(this);
	this->_Materials = new MaterialsUpdate(this->_AllFiles, this);
	connect(_Materials, SIGNAL(ShowMeassage(QString)), this, SLOT(ShowProgressMessage(QString)));
	connect(_Materials, SIGNAL(ShowProgressBar(bool)), this, SLOT(ShowProgressBar(bool)));
	connect(_Materials, SIGNAL(UpdateProgressBar(double, double)), this, SLOT(UpdateProgressBar(double, double)));//Прогресбар
	connect(_Materials, SIGNAL(MessageSignal(QString)), this, SLOT(ShowErrorMessage(QString)));
	connect(_Materials, SIGNAL(OperationComplit()), this, SLOT(DeleteCompasClass()));
	connect(this->_Thread, SIGNAL(started()), _Materials, SLOT(UpdateMaterials()));
        connect(this->_Thread, SIGNAL(finished()), this, SLOT(deleteLater()));
	_Materials->moveToThread(this->_Thread);
	this->_Thread->setPriority(QThread::Priority::LowestPriority);
    this->_Thread->start();

this->_Materials = new MaterialsUpdate(this->_AllFiles, this);

bool QChar::isDigit(uint ucs4)

static QString symbolIsFigure(const QString& input){

input[i] 

QChar::isDigit(input[i])

QChar::isDigit(input[i])

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>
#include <QFile>
#include <QFileDialog>
#include "mypoint.h"
#include "opengl.h"
#include "mypoligon.h"

namespace Ui {
class MainWindow;
}

class MainWindow : public QMainWindow
{
    Q_OBJECT

public:
    explicit MainWindow(QWidget *parent = 0);
    ~MainWindow();


 OpenGL GL;

    QString pointpath; //путь к файлу с точкам

//QList<myPoint*> MyPointList; //список точек

myPoint getpoint(QString str); //функция преобразования строки в точку.
myPoint *pt; //глобально объявленная ссылка на объект точки.
myPoligon *poligon;//глобально объявленная ссылка на объект полигона.

int NN = -1;
private slots:
    void on_pathButton_clicked();

    void on_readButton_clicked();

    void on_getPoints_clicked();

    void on_MyPointsOutput_clicked();



    void on_OpenGL_clicked();

    void on_GetTriIndexes_clicked();



    void on_newPoligon_clicked();

private:
    Ui::MainWindow *ui;
};

#endif // MAINWINDOW_H

#include "mainwindow.h"
#include "ui_mainwindow.h"
#include "mypoint.h"
#include "opengl.h"
#include <opengl.h>
#include "mypoligon.h"
#include <QDebug>
MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    ui->setupUi(this);
    pointpath = ui->lineEdit->text();
    GL.vertexRedy = false;
    GL.poligonRedy = false;


}

MainWindow::~MainWindow()
{
    delete ui;

}





void MainWindow::on_pathButton_clicked()
{
    //получение пути к файлу из QFileDialog
    pointpath = QFileDialog::getOpenFileName(this);
     ui->lineEdit->setText(pointpath);

     ui->textEdit->append("file path get complite");
}




void MainWindow::on_readButton_clicked()
{
    //открытие файла и чтение (работает)
    QFile file(pointpath);
    if(file.open(QIODevice::ReadOnly)){


    }
    ui->textEdit->append("file open complite");
}



void MainWindow::on_getPoints_clicked()
{int i;
    QFile file(pointpath);
    if(file.open(QIODevice::ReadOnly)){
while(!file.atEnd()){
pt = new myPoint;
QString str = file.readLine();
if(i > NN){
pt->getPoint(str);
GL.MyPointList.push_back(pt);

if(pt->color>GL.colorMax) GL.colorMax = pt->color;
i=0;}
i++;
}
ui->textEdit->append("pointList: "+QString::number(GL.MyPointList.count()));
}
}


void MainWindow::on_MyPointsOutput_clicked()
{

for (int i = 0; i< GL.MyPointList.count();++i){
   ui->textEdit->append(QString::number(GL.MyPointList[i]->returnVector3D().x()) + " " +QString::number(GL.MyPointList[i]->returnVector3D().y()) + " " +QString::number(GL.MyPointList[i]->returnVector3D().z()) + " " +QString::number((float)(GL.MyPointList[i]->returnColor())));
    }
ui->textEdit->append(QString::number(GL.colorMax));
}



void MainWindow::on_OpenGL_clicked()
{

    GL.resize(600,600);

    GL.show();
    GL.updateGL();

}

void MainWindow::on_GetTriIndexes_clicked()
{   QString str = "C:/Users/Геннадий/Desktop/Аспирантура/Программа расчёта ИК-заметности/с полигонами (триугольники) ++/";

    QString str2 = "треугольники";
    QFileDialog::Options opt;

    QFile trifile(QFileDialog::getOpenFileName(this,str2,str));
    if(trifile.open(QIODevice::ReadOnly| QIODevice::Text)){
        ui->textEdit->append("trifile open");
    }
    QList<QString> sList;
    while(!trifile.atEnd()){
        sList.push_back((trifile.readLine()));
    }

    ui->textEdit->append("sList created"+QString::number(sList.count()));

    QList<QString>::iterator ii;
    for(ii=sList.begin(); ii != sList.end(); ++ii){
        GL.vertexIndexes.push_back((*ii).section(',',0,0).toFloat());
        GL.vertexIndexes.push_back((*ii).section(',',1,1).toFloat());
        GL.vertexIndexes.push_back((*ii).section(',',2,2).toFloat());
    }
ui->textEdit->append("vertexIndexes: "+QString::number(GL.vertexIndexes.count()));
    QList<float>::iterator ff;
    int i;
    i=1;
    ui->textEdit->append("print vertexIndexes");
    for(ff=GL.vertexIndexes.begin(); ff != GL.vertexIndexes.end(); ff++){
        ui->textEdit->append(QString::number((*ff))+" "+QString::number(GL.MyPointList[(*ff)]->color));
        i++;
    }
    ui->textEdit->append("print vertexIndexes complite"+QString::number(GL.vertexIndexes.count()));
    GL.vertexRedy = true;

}

void MainWindow::on_newPoligon_clicked()
{  

    for(int i=0;i<=GL.vertexIndexes.count()-3;i = i+3){

    poligon = new myPoligon((*(GL.MyPointList[GL.vertexIndexes[i]])),(*(GL.MyPointList[GL.vertexIndexes[i+1]])),(*(GL.MyPointList[GL.vertexIndexes[i+2]])));


    GL.MyPoligonList.push_back(poligon);
    qDebug(QString::number(i).toUtf8());

    }

    ui->textEdit->append("создано "+QString::number(GL.MyPoligonList.count())+" полигонов");
    GL.poligonRedy = true;
}

#ifndef MYPOINT_H
#define MYPOINT_H

#include <QWidget>
#include <QGLWidget>
#include <QVector3D>

class myPoint : public QWidget
{

Q_OBJECT

private:




public:
    QVector3D point;
    myPoint(QWidget *parent = 0);
    myPoint(const myPoint &other);
    ~myPoint();

     GLfloat color;
     void getPoint(QString str );
     GLfloat returnColor();
     QVector3D returnVector3D();

signals:

public slots:
};

#endif // MYPOINT_H

mypoint.cpp:

#include "mypoint.h"
#include <QWidget>


myPoint::myPoint ( QWidget* parent) : QWidget(parent)
{

}

myPoint::myPoint (const myPoint &other ) : QWidget( )
{
point = other.point;
color = other.color;
}

myPoint::~myPoint()
{

}



void myPoint::getPoint(QString str)
{
    point = QVector3D(str.section(";",0,0).toFloat(),str.section(";",1,1).toFloat(),str.section(";",2,2).toFloat());
    color = (GLfloat)str.section(";",3,3).toFloat();
}

GLfloat myPoint::returnColor()
{
    return color;
}







QVector3D myPoint::returnVector3D()
{
    return point;
}

#ifndef MYPOLIGON_H
#define MYPOLIGON_H


#include <QWidget>
#include <QGLWidget>
#include <QVector3D>
#include "mypoint.h"


class myPoligon : public QWidget
{

Q_OBJECT

private:




public:
    myPoint point1, point2, point3;
    myPoligon(QWidget *parent = 0);
    myPoligon(const myPoligon &other);
    myPoligon(myPoint pt1, myPoint pt2, myPoint pt3);
    ~myPoligon();

    float S();
    float SS; //площадь полигона

    GLfloat color;
    GLfloat getColor();

    QVector3D center;
    QVector3D normal;

signals:

public slots:
};

#endif //MYPOLIGON_H

mypoligon.cpp:

#include "mypoligon.h"
#include <QWidget>
#include "mypoint.h"


myPoligon::myPoligon( QWidget* parent) : QWidget(parent)
{

}

myPoligon::myPoligon (const myPoligon &other ) : QWidget( )
{

}

myPoligon::myPoligon(myPoint pt1, myPoint pt2 , myPoint pt3)
{
point1.point =  pt1.point;
point2.point =  pt2.point;
point3.point =  pt3.point;
color = (pt1.color + pt2.color + pt3.color)/3.0;
center = QVector3D((pt1.point.x()+pt2.point.x()+pt3.point.x())/3.0,(pt1.point.y()+pt2.point.y()+pt3.point.y())/3.0,(pt1.point.z()+pt2.point.z()+pt3.point.z())/3.0 );
normal = QVector3D::crossProduct(pt1.point-pt3.point,pt3.point-pt2.point);
}

myPoligon::~myPoligon()
{

}

float myPoligon::S()
{
SS=QVector3D().dotProduct(point1.point-point2.point,point1.point-point3.point);
return SS;
}

GLfloat myPoligon::getColor()
{
    return color;
}

#ifndef OPENGL_H
#define OPENGL_H
#include <QWidget>
#include <QGLWidget>
#include <QKeyEvent>
#include "mypoint.h"
#include "mypoligon.h"

class OpenGL : public QGLWidget
{
    Q_OBJECT
protected:
   void initializeGL();
   void resizeGL(int nWidth, int nHeight);
   void paintGL();


public:
    OpenGL(QWidget *parent = 0);

void keyPressEvent(QKeyEvent *event);
void mousePressEvent(QMouseEvent *event);
void mouseMoveEvent(QMouseEvent *event);

QPoint pressPosition;
GLfloat xAxisRotation;
GLfloat yAxisRotation;
GLfloat zAxisRotation;
GLfloat currentHeight;
GLfloat currentWidth;
GLfloat zoom;
GLfloat translateX;
GLfloat translateY;
GLfloat colorMax;
QList<float> vertexIndexes; //номера вершин в каждом треугольнике.
bool vertexRedy;
bool poligonRedy;
QList<myPoint*> MyPointList; //список точек
QList<myPoligon*> MyPoligonList;//список полигонов

};

#endif // OPENGL_H

#include "opengl.h"
#include <QDebug>
#include "mainwindow.h"

OpenGL::OpenGL(QWidget* parent) : QGLWidget(parent)
{

}


void OpenGL::initializeGL()
{
    glClearColor(0.5, 0.5, 0.5, 0.5);
    glEnableClientState(GL_VERTEX_ARRAY);
    glEnableClientState(GL_COLOR_ARRAY);
    //glShadeModel(GL_FLAT); //отключает плавные переходы цветов
   glEnable(GL_CULL_FACE); //если включено - задние грани не видны
     zoom = 1.0;


}
void OpenGL::resizeGL(int nWidth, int nHeight)
{
    glMatrixMode(GL_PROJECTION);
    if(nWidth < nHeight){
    nWidth = nHeight;
    }
    else
    {
      nHeight = nWidth;
    }
    glLoadIdentity();

    glOrtho(0.0, 1.0, 0.0, 1.0, -1.0, 1.0);

    glViewport(0, 0, (GLint)nWidth, (GLint)nHeight);

    currentHeight =(GLint)nWidth;
    currentWidth =(GLint)nHeight;


}
void OpenGL::paintGL()
{
    glMatrixMode(GL_MODELVIEW); //
                                // глобальная система координат
        glLoadIdentity();       //

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glPointSize(15);


    glRotatef(yAxisRotation, 0.0, 1.0, 0.0);
    glRotatef(xAxisRotation, 1.0, 0.0, 0.0);
    glRotatef(zAxisRotation, 0.0, 0.0, 1.0);
    glScalef(zoom, zoom, zoom);
    glTranslatef(translateX,translateY,0);





if(!MyPointList.empty()){
    glBegin(GL_POINTS);
    QList<myPoint*>::iterator pt;
    for(pt = MyPointList.begin(); pt!=MyPointList.end();++pt){

        glColor3f((*pt)->color/colorMax,0,0);
glVertex3f((*pt)->returnVector3D().x(),(*pt)->returnVector3D().y(),(*pt)->returnVector3D().z());
    }
   glEnd();
};




   if(poligonRedy){
       glBegin(GL_TRIANGLES);

       QList<myPoligon * >::iterator pol;
       for(pol = MyPoligonList.begin(); pol != MyPoligonList.end(); ++pol){

           glColor3f((*pol)->getColor()/colorMax,0,0);
           glVertex3f((*pol)->point1.point.x(),(*pol)->point1.point.y(),(*pol)->point1.point.z());

           glVertex3f((*pol)->point2.point.x(),(*pol)->point2.point.y(),(*pol)->point2.point.z());

           glVertex3f((*pol)->point3.point.x(),(*pol)->point3.point.y(),(*pol)->point3.point.z());
       }
        glEnd();
   };


   if(poligonRedy){


       QList<myPoligon * >::iterator pol;

       for(pol = MyPoligonList.begin(); pol != MyPoligonList.end(); ++pol){
glBegin(GL_LINE_STRIP);
glLineWidth(1);
           glColor3f(1,1,1);
           glVertex3f((*pol)->center.x(),(*pol)->center.y(),(*pol)->center.z());
           glVertex3f((*pol)->normal.x()+(*pol)->center.x(),(*pol)->normal.y()+(*pol)->center.y(),(*pol)->normal.z()+(*pol)->center.z());
glEnd();
       }

   };





}//Close PaintGL




void OpenGL::mousePressEvent(QMouseEvent *event)
{
    pressPosition = event->pos();


}

void OpenGL::mouseMoveEvent(QMouseEvent *event)
{



    xAxisRotation += (180 * ((GLfloat)event->y() - (GLfloat)pressPosition.y())) / (currentHeight);
    yAxisRotation += (180 * ((GLfloat)event->x() - (GLfloat)pressPosition.x())) / (currentWidth);

    pressPosition = event->pos();


    updateGL();
}



void OpenGL::keyPressEvent(QKeyEvent *event)
{
     if(event->key()==Qt::Key_PageUp){
        zoom += 0.01;

        updateGL();
    }
    else if(event->key()==Qt::Key_PageDown){
        zoom -= 0.01;

        updateGL();
    }
    else if(event->key()==Qt::Key_Enter){

         xAxisRotation = 0.0;
         yAxisRotation = 0.0;
        updateGL();
    }
    else if(event->key()==Qt::Key_Right){
        translateX += 0.1;
        updateGL();
    }
    else if(event->key()==Qt::Key_Left) {
        translateX -= 0.1;
        updateGL();
    }
    else if(event->key()==Qt::Key_Up) {
        translateY += 0.1;
        updateGL();
    }
    else if(event->key()==Qt::Key_Down) {
        translateY -= 0.1;
        updateGL();
    }
     else if(event->key()==Qt::Key_Q){

zAxisRotation += 0.1;
updateGL();
     }
}