Skip to content
Snippets Groups Projects
Commit 418534bf authored by jf3g19's avatar jf3g19
Browse files

initial commit

parents
No related branches found
No related tags found
No related merge requests found
#include "button.h"
//constructors for coloured buttons with or without text
Button::Button(const QString& text, QWidget* parent) : QToolButton(parent)
{
this->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred);
this->setText(text);
}
Button::Button(QWidget* parent) : QToolButton(parent)
{
setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred);
}
QSize Button::sizeHint() const
{
QSize size = QToolButton::sizeHint();
size.rheight() += 20;
size.rwidth() = qMax(size.width(), size.height());
return size;
}
//accessors for member variables
QColor Button::getColor()
{
return buttonColor;
}
button.h 0 → 100644
#pragma once
#include "QtWidgets/qtoolbutton.h"
#include "QtWidgets/qwidget.h"
class Button : public QToolButton
{
Q_OBJECT
public:
Button(const QString& text, QWidget* parent = nullptr);
Button(QWidget* parent = nullptr);
QSize sizeHint() const override;
QColor getColor();
private:
QColor buttonColor;
};
#include "card_a.h"
Card_A::Card_A(controller_ptr Controller)
{
controller = Controller;
connect_to_pointer(this, SIGNAL(Card_A::setNewMainWindow), controller, SLOT(WindowController::handleNewMainWindow));
button1 = new Button("button 1");
button2 = new Button("button 2");
this->addWidget(button1);
this->addWidget(button2);
connect(button1, &QAbstractButton::clicked, this, &Card_A::button1Slot);
connect(button2, &QAbstractButton::clicked, this, &Card_A::button2Slot);
}
void Card_A::button1Slot()
{
Card_B* card = new Card_B(controller);
emit setNewMainWindow(card);
}
void Card_A::button2Slot()
{
Card_C* card = new Card_C(controller);
emit setNewMainWindow(card);
}
card_a.h 0 → 100644
#pragma once
#ifndef CARD_A_H
#define CARD_A_H
#include <QVBoxLayout>
#include "windowcontroller.h"
#include "button.h"
#include "card_b.h"
#include "card_c.h"
#include "connecttemplates.h"
using controller_ptr = QSharedPointer<WindowController>;
class Card_A : public QVBoxLayout
{
Q_OBJECT
public:
Card_A(controller_ptr Controller);
signals:
void setNewMainWindow(QVBoxLayout*);
public slots:
void button1Slot();
void button2Slot();
private:
controller_ptr controller;
Button* button1;
Button* button2;
};
#endif // CARD_A_H
#include "card_b.h"
Card_B::Card_B(controller_ptr Controller)
{
controller = Controller;
connect_to_pointer(this, SIGNAL(Card_B::setNewMainWindow), controller, SLOT(WindowController::handleNewMainWindow));
button1 = new Button("button 1");
this->addWidget(button1);
connect(button1, &QAbstractButton::clicked, this, &Card_B::button1Slot);
}
void Card_B::button1Slot()
{
std::cout << "hello world" << std::endl;
}
card_b.h 0 → 100644
#pragma once
#ifndef CARD_B_H
#define CARD_B_H
#include <QVBoxLayout>
#include "windowcontroller.h"
#include "button.h"
#include <iostream>
#include "connecttemplates.h"
using controller_ptr = QSharedPointer<WindowController>;
class Card_B : public QVBoxLayout
{
Q_OBJECT
public:
Card_B(controller_ptr Controller);
signals:
void setNewMainWindow(QVBoxLayout*);
public slots:
void button1Slot();
private:
controller_ptr controller;
Button* button1;
};
#endif // CARD_B_H
#include "card_c.h"
#include "card_b.h"
Card_C::Card_C(controller_ptr Controller)
{
controller = Controller;
connect_to_pointer(this, SIGNAL(Card_C::setNewMainWindow), controller, SLOT(WindowController::handleNewMainWindow));
button1 = new Button("button 1");
button2 = new Button("button 2");
button3 = new Button("button 3");
this->addWidget(button1);
this->addWidget(button2);
this->addWidget(button3);
connect(button1, &QAbstractButton::clicked, this, &Card_C::button1Slot);
connect(button2, &QAbstractButton::clicked, this, &Card_C::button2Slot);
connect(button3, &QAbstractButton::clicked, this, &Card_C::button3Slot);
}
void Card_C::button1Slot()
{
std::cout << "hello world 1" << std::endl;
}
void Card_C::button2Slot()
{
std::cout << "hello world 2" << std::endl;
}
void Card_C::button3Slot()
{
std::cout << "hello world 3" << std::endl;
}
card_c.h 0 → 100644
#pragma once
#ifndef CARD_C_H
#define CARD_C_H
#include <QVBoxLayout>
#include "windowcontroller.h"
#include "button.h"
#include "connecttemplates.h"
using controller_ptr = QSharedPointer<WindowController>;
class Card_C : public QVBoxLayout
{
Q_OBJECT
public:
Card_C(controller_ptr Controller);
signals:
void setNewMainWindow(QVBoxLayout*);
public slots:
void button1Slot();
void button2Slot();
void button3Slot();
private:
controller_ptr controller;
Button* button1;
Button* button2;
Button* button3;
};
#endif // CARD_C_H
#ifndef CONNECTTEMPLATES_H
#define CONNECTTEMPLATES_H
#endif // CONNECTTEMPLATES_H
#include <QSharedPointer>
template<typename T>
QMetaObject::Connection connect_from_pointer(
const QSharedPointer<T>& sender,
const char *signal,
const QObject *receiver,
const char *method,
Qt::ConnectionType type = Qt::AutoConnection)
{
return QObject::connect(sender.data(), signal, receiver, method, type);
}
/*
template <typename Func1, typename Func2>
QMetaObject::Connection connect_from_pointer(
const QSharedPointer<typename QtPrivate::FunctionPointer<Func1>::Object>& sender,
Func1 signal,
const typename QtPrivate::FunctionPointer<Func2>::Object *receiver,
Func2 slot,
Qt::ConnectionType type = Qt::AutoConnection)
{
return QObject::connect(sender.data(), signal, receiver, slot, type);
}
*/
template<class T>
QMetaObject::Connection connect_to_pointer(
const QObject *sender,
const char *signal,
const QSharedPointer<T>& receiver,
const char *method,
Qt::ConnectionType type = Qt::AutoConnection)
{
return QObject::connect(sender, signal, receiver.data(), method, type);
}
/*
template <typename Func1, typename Func2>
QMetaObject::Connection connect_to_pointer(
const typename QtPrivate::FunctionPointer<Func1>::Object *sender,
Func1 signal,
const QSharedPointer<typename QtPrivate::FunctionPointer<Func2>::Object>& receiver,
Func2 slot,
Qt::ConnectionType type)
{
return QObject::connect(sender, signal, receiver.data(), slot, type);
}
template<class T, class U>
QMetaObject::Connection connect_pointers(
const QSharedPointer<T>& sender,
const char *signal,
const QSharedPointer<U>& receiver,
const char *method,
Qt::ConnectionType type = Qt::AutoConnection)
{
return QObject::connect(sender.data(), signal, receiver.data(), method, type);
}
*/
template <typename Func1, typename Func2>
QMetaObject::Connection connect_pointers(
const QSharedPointer<typename QtPrivate::FunctionPointer<Func1>::Object>& sender,
Func1 signal,
const QSharedPointer<typename QtPrivate::FunctionPointer<Func2>::Object>& receiver,
Func2 slot,
Qt::ConnectionType type = Qt::AutoConnection)
{
return QObject::connect(sender.data(), signal, receiver.data(), slot, type);
}
QT += core gui
greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
CONFIG += c++11
# The following define makes your compiler emit warnings if you use
# any Qt feature that has been marked deprecated (the exact warnings
# depend on your compiler). Please consult the documentation of the
# deprecated API in order to know how to port your code away from it.
DEFINES += QT_DEPRECATED_WARNINGS
# You can also make your code fail to compile if it uses deprecated APIs.
# In order to do so, uncomment the following line.
# You can also select to disable deprecated APIs only up to a certain version of Qt.
#DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000 # disables all the APIs deprecated before Qt 6.0.0
SOURCES += \
button.cpp \
card_a.cpp \
card_b.cpp \
card_c.cpp \
main.cpp \
mainwindow.cpp \
windowcontroller.cpp
HEADERS += \
button.h \
card_a.h \
card_b.h \
card_c.h \
connecttemplates.h \
mainwindow.h \
windowcontroller.h
# Default rules for deployment.
qnx: target.path = /tmp/$${TARGET}/bin
else: unix:!android: target.path = /opt/$${TARGET}/bin
!isEmpty(target.path): INSTALLS += target
This diff is collapsed.
main.cpp 0 → 100644
#include "mainwindow.h"
#include "windowcontroller.h"
#include "card_a.h"
#include <QApplication>
using controller_ptr = QSharedPointer<WindowController>;
#include "connecttemplates.h"
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
MainWindow* w = new MainWindow;
controller_ptr controller = controller_ptr(new WindowController);
connect_from_pointer(controller, SIGNAL(WindowController::setNewMainWindow), w, SLOT(MainWindow::handleNewMainWindow));
Card_A* card_a = new Card_A(controller);
w->handleNewMainWindow(card_a);
w->show();
return a.exec();
}
#include "mainwindow.h"
MainWindow::MainWindow(QWidget *parent)
{
}
MainWindow::~MainWindow()
{
}
void MainWindow::handleNewMainWindow(QVBoxLayout* layout)
{
delete this->layout();
qDeleteAll(this->children());
this->setLayout(layout);
}
#pragma once
#ifndef MAINWINDOW_H
#define MAINWINDOW_H
#include <QMainWindow>
#include <QDialog>
#include <QVBoxLayout>
class MainWindow : public QDialog
{
Q_OBJECT
public:
MainWindow(QWidget *parent = nullptr);
~MainWindow();
public slots:
void handleNewMainWindow(QVBoxLayout* layout);
private:
};
#endif // MAINWINDOW_H
#include "windowcontroller.h"
WindowController::WindowController()
{
}
void WindowController::handleNewMainWindow(QVBoxLayout* layout)
{
emit newMainWindow(layout);
}
#pragma once
#ifndef WINDOWCONTROLLER_H
#define WINDOWCONTROLLER_H
#include <QVBoxLayout>
#include <QWidget>
class WindowController : public QObject
{
Q_OBJECT
public:
WindowController();
public slots:
void handleNewMainWindow(QVBoxLayout* layout);
signals:
void newMainWindow(QVBoxLayout* layout);
};
#endif // WINDOWCONTROLLER_H
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment