CgQtGui.cpp

#include "CgQtGLRenderWidget.h"
#include "CgQtGui.h"
#include "CgQtMainApplication.h"
#include "../CgBase/CgEnums.h"
#include "../CgEvents/CgMouseEvent.h"
#include "../CgEvents/CgKeyEvent.h"
#include "../CgEvents/CgWindowResizeEvent.h"
#include "../CgEvents/CgLoadMeshEvent.h"
#include "../CgEvents/CgLoadPointCloudEvent.h"
#include "../CgEvents/CgTrackballEvent.h"
#include "../CgEvents/CgSplatEvent.h"
#include "../CgEvents/CgPickRayEvent.h"
#include "../CgEvents/CgKdTreeEvent.h"
#include "../CgEvents/CgWheelEvent.h"

#include <QSlider>
#include <QVBoxLayout>
#include <QHBoxLayout>
#include <QKeyEvent>
#include <QPushButton>
#include <QDesktopWidget>
#include <QApplication>
#include <QMessageBox>
#include <QLabel>
#include <QSpinBox>
#include <QCheckBox>
#include <QPushButton>
#include <QGroupBox>
#include <QButtonGroup>
#include <QRadioButton>
#include <QMenuBar>
#include <QActionGroup>
#include <QFileDialog>
#include <iostream>



CgQtGui::CgQtGui(CgQtMainApplication *mw)
    : m_mainWindow(mw)
{
    m_glRenderWidget = new CgQtGLRenderWidget;


    connect(m_glRenderWidget, SIGNAL(mouseEvent(QMouseEvent*)), this, SLOT(mouseEvent(QMouseEvent*)));
    connect(m_glRenderWidget, SIGNAL(viewportChanged(int,int)), this, SLOT(viewportChanged(int,int)));
    connect(m_glRenderWidget, SIGNAL(trackballChanged()), this, SLOT(slotTrackballChanged()));


    QVBoxLayout *mainLayout = new QVBoxLayout;
    QHBoxLayout *container = new QHBoxLayout;


    QWidget *kdTreeOptionsWidget = new QWidget;
    createKdTreeOptionPanel(kdTreeOptionsWidget);

    QWidget *otheropt = new QWidget;
    createOptionPanelExample2(otheropt);

    QTabWidget* m_tabs = new QTabWidget();
    m_tabs->addTab(kdTreeOptionsWidget,"&k-d tree");
    m_tabs->addTab(otheropt,"&My Tab2");
    container->addWidget(m_tabs);

    m_tabs->setMaximumWidth(400);

    container->addWidget(m_glRenderWidget);

    QWidget *w = new QWidget;
    w->setLayout(container);
    mainLayout->addWidget(w);

    setLayout(mainLayout);
    setWindowTitle(tr("Exercise Visual Computing -  Summer 2021"));


    /* create Menu Bar */
    m_menuBar = new QMenuBar;
    QMenu *file_menu = new QMenu("&File" );
    file_menu->addAction("&Open Mesh Model", this, SLOT(slotLoadMeshFile()));
    file_menu->addAction("&Open Point Cloud", this, SLOT(slotLoadPointCloudFile()));


    // todo: Add Quit-Action
    m_menuBar->addMenu( file_menu );
    QMenu *settings_menu = new QMenu("&Setting" );
    QMenu *polygon_mode_menu = new QMenu("&Polygon Mode" );

    QAction* m_custom_rot=settings_menu->addAction("&Backface Culling", m_glRenderWidget, SLOT(slotBackfaceCulling()));
    m_custom_rot->setCheckable(true);
    m_custom_rot->setChecked(false);

    QAction* m_lighting=settings_menu->addAction("&Lighting on", m_glRenderWidget, SLOT(slotLighting()));
    m_lighting->setCheckable(true);
    m_lighting->setChecked(false);

    QAction* use_splats=settings_menu->addAction("&show splats", this, SLOT(slotSplatting()));
    use_splats->setCheckable(true);
    use_splats->setChecked(false);

    QAction* show_pickray=settings_menu->addAction("&show pick ray", this, SLOT(slotPickRay()));
    show_pickray->setCheckable(true);
    show_pickray->setChecked(false);

    QActionGroup* polygonmode_group = new QActionGroup(this);
    polygonmode_group->setExclusive(true);

    QAction* points=polygon_mode_menu->addAction("&Points", m_glRenderWidget, SLOT(slotRenderPoints()));
    points->setCheckable(true);
    points->setChecked(false);

    QAction* lines=polygon_mode_menu->addAction("&Lines", m_glRenderWidget, SLOT(slotRenderLines()));
    lines->setCheckable(true);
    lines->setChecked(true);

    QAction* filled=polygon_mode_menu->addAction("&Filled", m_glRenderWidget, SLOT(slotRenderFilled()));
    filled->setCheckable(true);
    filled->setChecked(false);

    polygonmode_group->addAction(points);
    polygonmode_group->addAction(lines);
    polygonmode_group->addAction(filled);

    // todo: Add Quit-Action
    m_menuBar->addMenu( file_menu );
    m_menuBar->addMenu( settings_menu );
    m_menuBar->addMenu( polygon_mode_menu );

    m_mainWindow->setMenuBar(m_menuBar);
}

QSlider *CgQtGui::createSlider()
{
    QSlider *slider = new QSlider(Qt::Vertical);
    slider->setRange(0, 360 * 16);
    slider->setSingleStep(16);
    slider->setPageStep(15 * 16);
    slider->setTickInterval(15 * 16);
    slider->setTickPosition(QSlider::TicksRight);
    return slider;
}

void CgQtGui::createKdTreeOptionPanel(QWidget* parent)
{
    QVBoxLayout *tab1_control = new QVBoxLayout();

    /* checkbox for toggling the plane display*/

    display_kd_tree_checkbox = new QCheckBox("display k-d tree planes");
    display_kd_tree_checkbox->setCheckable(true);
    display_kd_tree_checkbox->setChecked(false);
    connect(display_kd_tree_checkbox, SIGNAL( clicked() ), this, SLOT(slotKdDepthSpinboxChanged()) );
    tab1_control->addWidget(display_kd_tree_checkbox);


    /* label */

    QLabel *max_depth_label = new QLabel("depth limit (0 for none):");
    tab1_control->addWidget(max_depth_label);
    max_depth_label->setAlignment(Qt::AlignTop);
    max_depth_label->setSizePolicy(QSizePolicy::Maximum, QSizePolicy::Fixed);

    /*Example for using a spinbox */

    max_kd_depth_spinbox = new QSpinBox();
    tab1_control->addWidget(max_kd_depth_spinbox);
    max_kd_depth_spinbox->setMinimum(0);
    max_kd_depth_spinbox->setMaximum(50);
    max_kd_depth_spinbox->setValue(0);
    connect(max_kd_depth_spinbox, SIGNAL(valueChanged(int) ), this, SLOT(slotKdDepthSpinboxChanged()) );
    tab1_control->addWidget(max_kd_depth_spinbox);
    max_kd_depth_spinbox->setAlignment(Qt::AlignTop);
    max_kd_depth_spinbox->setSizePolicy(QSizePolicy::Ignored, QSizePolicy::Fixed);

    // fill space
    QWidget *filler = new QWidget();
    tab1_control->addWidget(filler);
    filler->setSizePolicy(QSizePolicy::Ignored, QSizePolicy::Ignored);

    parent->setLayout(tab1_control);
}

void CgQtGui::createOptionPanelExample2(QWidget* parent)
{
    QVBoxLayout *tab2_control = new QVBoxLayout();
    QHBoxLayout *subBox = new QHBoxLayout();

    /*Example for using a button group */

    QGroupBox* myGroupBox = new QGroupBox("Radiobutton Group Example ");

    myButtonGroup = new QButtonGroup(subBox);
    myButtonGroup->setExclusive(true);

    QRadioButton* radiobutton1 = new QRadioButton( "&Option1");
    QRadioButton* radiobutton2 = new QRadioButton( "&Option2");
    QRadioButton* radiobutton3 = new QRadioButton( "&Option3");
    QRadioButton* radiobutton4 = new QRadioButton( "&Option4");
    QRadioButton* radiobutton5 = new QRadioButton( "&Option5");

    radiobutton2->setChecked(true);

    myButtonGroup->addButton(radiobutton1,0);
    myButtonGroup->addButton(radiobutton2,1);
    myButtonGroup->addButton(radiobutton3,2);
    myButtonGroup->addButton(radiobutton4,3);
    myButtonGroup->addButton(radiobutton5,4);


    QVBoxLayout *vbox = new QVBoxLayout;
    vbox->addWidget(radiobutton1);
    vbox->addWidget(radiobutton2);
    vbox->addWidget(radiobutton3);
    vbox->addWidget(radiobutton4);
    vbox->addWidget(radiobutton5);
    vbox->addStretch(1);
    myGroupBox->setLayout(vbox);
    subBox->addWidget(myGroupBox);
    tab2_control->addLayout(subBox);

    connect(myButtonGroup, SIGNAL( buttonClicked(int) ), this, SLOT( slotButtonGroupSelectionChanged() ) );
    parent->setLayout(tab2_control);

}

void CgQtGui::slotButtonGroupSelectionChanged()
{

}

void CgQtGui::slotKdDepthSpinboxChanged() {
    int depth = display_kd_tree_checkbox->isChecked()
        ? max_kd_depth_spinbox->value()
        : -1;

    CgBaseEvent* e = new CgKdTreeEvent(Cg::CgKdTreeEvent, depth);
    notifyObserver(e);
    m_glRenderWidget->redraw();
}

void CgQtGui::slotLoadPointCloudFile()
{
    QString file=  QFileDialog::getOpenFileName(this, tr("Open Obj-File"),"",tr("Model Files (*.obj)"));
    CgBaseEvent* e = new CgLoadPointCloudEvent(Cg::CgLoadPointCloudEvent, file.toStdString());
    notifyObserver(e);
}


void CgQtGui::slotSplatting()
{
  m_use_spats=!m_use_spats;
  CgBaseEvent* e = new CgSplatEvent(Cg::CgSplatEvent, m_use_spats);
  notifyObserver(e);
}

void CgQtGui::slotPickRay()
{
  m_show_pickray=!m_show_pickray;
  CgBaseEvent* e = new CgPickRayEvent(Cg::CgPickRayEvent, m_show_pickray);
  notifyObserver(e);
}


void CgQtGui::slotLoadMeshFile()
{
    QString file=  QFileDialog::getOpenFileName(this, tr("Open Obj-File"),"",tr("Model Files (*.obj)"));
    CgBaseEvent* e = new CgLoadMeshEvent(Cg::CgLoadMeshEvent, file.toStdString());
    notifyObserver(e);
}


void CgQtGui::slotTrackballChanged()
{
    CgBaseEvent* e = new CgTrackballEvent(Cg::CgTrackballEvent, m_glRenderWidget->getTrackballRotation());
    notifyObserver(e);
}

void CgQtGui::mouseEvent(QMouseEvent* event)
{

   // std::cout << QApplication::keyboardModifiers() << std::endl;

  //  if(QApplication::keyboardModifiers().testFlag(Qt::ControlModifier)==true)
    //    std::cout << Cg::ControlModifier << endl;


   if(event->type()==QEvent::MouseButtonPress)
   {


        CgBaseEvent* e = new CgMouseEvent(Cg::CgMouseButtonPress,
                                          glm::vec2(event->localPos().x() ,event->localPos().y()),
                                          (Cg::MouseButtons)event->button());

        notifyObserver(e);
   }

   if(event->type() == QEvent::MouseButtonRelease)
   {
        CgBaseEvent* e = new CgMouseEvent(Cg::CgMouseButtonRelease,
                                          glm::vec2(event->localPos().x() ,event->localPos().y()),
                                          (Cg::MouseButtons)event->button());

        notifyObserver(e);
   }

   if(event->type()==QEvent::MouseMove)
   {
       CgBaseEvent* e= new CgMouseEvent(Cg::CgMouseMove,
                                        glm::vec2(event->localPos().x() ,event->localPos().y()),
                                        (Cg::MouseButtons)event->button());
       notifyObserver(e);
   }



}

void CgQtGui::wheelEvent(QWheelEvent* event)
{
    CgBaseEvent* e = new CgWheelEvent(Cg::CgMouseWheel, event->angleDelta().y() / 8.0);
    notifyObserver(e);
}

void CgQtGui::keyPressEvent(QKeyEvent *event)
{
   CgBaseEvent* e= new CgKeyEvent(Cg::CgKeyPressEvent,(Cg::Key)event->key(),(Cg::KeyboardModifiers)event->nativeModifiers(),event->text().toStdString());
   notifyObserver(e);
}


void CgQtGui::viewportChanged(int w, int h)
{
     CgBaseEvent* e = new CgWindowResizeEvent(Cg::WindowResizeEvent,w,h);
     notifyObserver(e);
}




CgBaseRenderer* CgQtGui::getRenderer()
{
    return m_glRenderWidget;
}