File indexing completed on 2024-04-14 14:30:07

 #include "krulertest.h"
 
 #include <KRuler>
 
 #include <QApplication>
 #include <QButtonGroup>
 #include <QDoubleSpinBox>
 #include <QGroupBox>
 #include <QKeyEvent>
 #include <QLabel>
 #include <QLayout>
 #include <QSpinBox>
 
 /*
 void
 MyCheckBox::mouseReleaseEvent(QMouseEvent *e )
 {
   QButton::mouseReleaseEvent(e);
   if ();
 }
 */
 
 MouseWidget::MouseWidget(QWidget *parent)
     : QFrame(parent)
 {
 }
 
 void MouseWidget::mousePressEvent(QMouseEvent *e)
 {
     mouseButtonDown = true;
     Q_EMIT newXPos(e->x());
     Q_EMIT newYPos(e->y());
 }
 
 void MouseWidget::mouseReleaseEvent(QMouseEvent *)
 {
     mouseButtonDown = false;
 }
 
 void MouseWidget::mouseMoveEvent(QMouseEvent *e)
 {
     if (mouseButtonDown) {
         Q_EMIT newXPos(e->x());
         Q_EMIT newYPos(e->y());
     }
 }
 
 void MouseWidget::resizeEvent(QResizeEvent *r)
 {
     Q_EMIT newWidth(r->size().width());
     Q_EMIT newHeight(r->size().height());
 }
 
 KRulerTest::KRulerTest()
     : QWidget(nullptr)
 {
     QVBoxLayout *topLayout = new QVBoxLayout(this);
     mainframe = new QFrame(this);
     topLayout->addWidget(mainframe);
 
     layout = new QGridLayout(mainframe);
 
     miniwidget = new QFrame(mainframe);
     miniwidget->setFrameStyle(QFrame::WinPanel | QFrame::Raised);
     bigwidget = new MouseWidget(mainframe);
     bigwidget->setFrameStyle(QFrame::WinPanel | QFrame::Sunken);
 
     //  QRect bwrect = bigwidget->frameRect();
     //  qDebug("big rect: top%i left%i bottom%i right%i",
     //    bwrect.top(), bwrect.left(), bwrect.bottom(), bwrect.right());
     hruler = new KRuler(Qt::Horizontal, mainframe);
     //  hruler->setRange( bwrect.left(), bwrect.right() );
     hruler->setRange(0, 1000);
     //  hruler->setOffset( bwrect.left() - bigwidget->frameRect().left() );
     hruler->setOffset(0);
 
     vruler = new KRuler(Qt::Vertical, mainframe);
     vruler->setOffset(0);
     vruler->setRange(0, 1000);
 
     connect(bigwidget, &MouseWidget::newXPos, hruler, &KRuler::slotNewValue);
     connect(bigwidget, &MouseWidget::newYPos, vruler, &KRuler::slotNewValue);
     connect(bigwidget, &MouseWidget::newWidth, this, &KRulerTest::slotNewWidth);
     connect(bigwidget, &MouseWidget::newHeight, this, &KRulerTest::slotNewHeight);
 
     layout->addWidget(miniwidget, 0, 0);
     layout->addWidget(hruler, 0, 1);
     layout->addWidget(vruler, 1, 0);
     layout->addWidget(bigwidget, 1, 1);
 
     mouse_message = new QLabel(QStringLiteral("Press and hold mouse button\nfor pointer movement"), bigwidget);
     mouse_message->adjustSize();
     mouse_message->move(4, 4);
 
     showMarks = new QGroupBox(QStringLiteral("Show which marks ?"), bigwidget);
     showMarks->setFixedSize(140, 160);
     showMarks->move(330, 4);
     showTM = new QCheckBox(QStringLiteral("show tiny marks"), showMarks);
     showTM->adjustSize();
     showTM->move(5, 15);
     showTM->setChecked(true);
     connect(showTM, &QCheckBox::toggled, this, &KRulerTest::slotSetTinyMarks);
     showLM = new QCheckBox(QStringLiteral("show little marks"), showMarks);
     showLM->adjustSize();
     showLM->move(5, 35);
     showLM->setChecked(true);
     connect(showLM, &QCheckBox::toggled, this, &KRulerTest::slotSetLittleMarks);
     showMM = new QCheckBox(QStringLiteral("show medium marks"), showMarks);
     showMM->adjustSize();
     showMM->move(5, 55);
     showMM->setChecked(true);
     connect(showMM, &QCheckBox::toggled, this, &KRulerTest::slotSetMediumMarks);
     showBM = new QCheckBox(QStringLiteral("show big marks"), showMarks);
     showBM->adjustSize();
     showBM->move(5, 75);
     showBM->setChecked(true);
     connect(showBM, &QCheckBox::toggled, this, &KRulerTest::slotSetBigMarks);
     showEM = new QCheckBox(QStringLiteral("show end marks"), showMarks);
     showEM->adjustSize();
     showEM->move(5, 95);
     showEM->setChecked(true);
     connect(showEM, &QCheckBox::toggled, this, &KRulerTest::slotSetEndMarks);
     showPT = new QCheckBox(QStringLiteral("show ruler pointer"), showMarks);
     showPT->adjustSize();
     showPT->move(5, 115);
     showPT->setChecked(true);
     connect(showPT, &QCheckBox::toggled, this, &KRulerTest::slotSetRulerPointer);
     fixLen = new QCheckBox(QStringLiteral("fix ruler length"), showMarks);
     fixLen->adjustSize();
     fixLen->move(5, 135);
     fixLen->setChecked(true);
     connect(fixLen, &QCheckBox::toggled, this, &KRulerTest::slotFixRulerLength);
     connect(fixLen, &QCheckBox::toggled, this, &KRulerTest::slotCheckLength);
 
     lineEdit = new QGroupBox(QStringLiteral("Value of begin/end"), bigwidget);
     lineEdit->setFixedSize(140, 80);
     lineEdit->move(330, 4 + 160);
     beginMark = new QSpinBox(lineEdit);
     beginMark->setValue(0);
     beginMark->setRange(-1000, 1000);
     beginMark->move(5, 15);
     beginMark->setFixedSize(beginMark->sizeHint());
     connect(beginMark, qOverload<int>(&QSpinBox::valueChanged), hruler, &KRuler::slotNewOffset);
     connect(beginMark, qOverload<int>(&QSpinBox::valueChanged), vruler, &KRuler::slotNewOffset);
     endMark = new QSpinBox(lineEdit);
     endMark->setValue(0);
     endMark->setRange(-1000, 1000);
     endMark->move(5, 35);
     endMark->setFixedSize(endMark->sizeHint());
     connect(endMark, qOverload<int>(&QSpinBox::valueChanged), hruler, &KRuler::slotEndOffset);
     connect(endMark, qOverload<int>(&QSpinBox::valueChanged), vruler, &KRuler::slotEndOffset);
     lengthInput = new QSpinBox(lineEdit);
     lengthInput->setValue(0);
     lengthInput->setRange(-1000, 1000);
     lengthInput->move(5, 55);
     lengthInput->setFixedSize(lengthInput->sizeHint());
     connect(lengthInput, qOverload<int>(&QSpinBox::valueChanged), hruler, &KRuler::slotEndOffset);
     connect(lengthInput, qOverload<int>(&QSpinBox::valueChanged), vruler, &KRuler::slotEndOffset);
 
     vertrot = new QGroupBox(QStringLiteral("Value of rotate translate for Vert."), bigwidget);
     vertrot->setFixedSize(140, 80);
     vertrot->move(330, 4 + 160 + 80 + 4);
     transX = new QDoubleSpinBox(vertrot);
     transX->setValue(0.0);
     transX->setRange(-1000, 1000);
     transX->setSingleStep(1);
     transX->move(5, 15);
     transX->setFixedSize(transX->sizeHint());
     // transX->setLabel("transx", AlignLeft);
     connect(transX, qOverload<double>(&QDoubleSpinBox::valueChanged), this, &KRulerTest::slotSetXTrans);
     transY = new QDoubleSpinBox(vertrot);
     transY->setValue(-12.0);
     transY->setRange(-1000, 1000);
     transY->setSingleStep(1);
     transY->move(5, 35);
     transY->setFixedSize(transY->sizeHint());
     // transY->setLabel("transy", AlignLeft);
     connect(transY, qOverload<double>(&QDoubleSpinBox::valueChanged), this, &KRulerTest::slotSetYTrans);
     rotV = new QDoubleSpinBox(vertrot);
     rotV->setValue(90.0);
     rotV->setRange(-1000, 1000);
     rotV->setSingleStep(1);
     rotV->move(5, 55);
     rotV->setFixedSize(rotV->sizeHint());
     // rotV->setLabel("rot", AlignLeft);
     connect(rotV, qOverload<double>(&QDoubleSpinBox::valueChanged), this, &KRulerTest::slotSetRotate);
 
     metricstyle = new QGroupBox(QStringLiteral("metric styles"), bigwidget);
 
     QButtonGroup *metricstyleButtons = new QButtonGroup(bigwidget);
 
     metricstyle->setFixedSize(100, 120);
     metricstyle->move(330 - 110, 4);
     pixelmetric = new QRadioButton(QStringLiteral("pixel"), metricstyle);
     pixelmetric->adjustSize();
     pixelmetric->move(5, 15);
     metricstyleButtons->addButton(pixelmetric, (int)KRuler::Pixel);
     inchmetric = new QRadioButton(QStringLiteral("inch"), metricstyle);
     inchmetric->adjustSize();
     inchmetric->move(5, 35);
     metricstyleButtons->addButton(inchmetric, (int)KRuler::Inch);
     mmmetric = new QRadioButton(QStringLiteral("millimeter"), metricstyle);
     mmmetric->adjustSize();
     mmmetric->move(5, 55);
     metricstyleButtons->addButton(mmmetric, (int)KRuler::Millimetres);
     cmmetric = new QRadioButton(QStringLiteral("centimeter"), metricstyle);
     cmmetric->adjustSize();
     cmmetric->move(5, 75);
     metricstyleButtons->addButton(cmmetric, (int)KRuler::Centimetres);
     mmetric = new QRadioButton(QStringLiteral("meter"), metricstyle);
     mmetric->adjustSize();
     mmetric->move(5, 95);
     metricstyleButtons->addButton(mmetric, (int)KRuler::Metres);
     connect(metricstyleButtons, &QButtonGroup::buttonClicked, this, [this, metricstyleButtons](QAbstractButton *button) {
         slotSetMStyle(metricstyleButtons->id(button));
     });
 
     slotUpdateShowMarks();
 }
 
 KRulerTest::~KRulerTest()
 {
     delete layout;
     delete hruler;
     delete vruler;
     delete miniwidget;
     delete bigwidget;
     delete mainframe;
 }
 
 void KRulerTest::slotNewWidth(int width)
 {
     hruler->setMaximum(width);
 }
 
 void KRulerTest::slotNewHeight(int height)
 {
     vruler->setMaximum(height);
 }
 
 void KRulerTest::slotSetTinyMarks(bool set)
 {
     hruler->setShowTinyMarks(set);
     vruler->setShowTinyMarks(set);
 }
 
 void KRulerTest::slotSetLittleMarks(bool set)
 {
     hruler->setShowLittleMarks(set);
     vruler->setShowLittleMarks(set);
 }
 
 void KRulerTest::slotSetMediumMarks(bool set)
 {
     hruler->setShowMediumMarks(set);
     vruler->setShowMediumMarks(set);
 }
 
 void KRulerTest::slotSetBigMarks(bool set)
 {
     hruler->setShowBigMarks(set);
     vruler->setShowBigMarks(set);
 }
 
 void KRulerTest::slotSetEndMarks(bool set)
 {
     hruler->setShowEndMarks(set);
     vruler->setShowEndMarks(set);
 }
 
 void KRulerTest::slotSetRulerPointer(bool set)
 {
     hruler->setShowPointer(set);
     vruler->setShowPointer(set);
 }
 
 void KRulerTest::slotSetRulerLength(int len)
 {
     hruler->setLength(len);
     vruler->setLength(len);
 }
 
 void KRulerTest::slotFixRulerLength(bool fix)
 {
     hruler->setLengthFixed(fix);
     vruler->setLengthFixed(fix);
 }
 
 void KRulerTest::slotSetMStyle(int style)
 {
     hruler->setRulerMetricStyle((KRuler::MetricStyle)style);
     vruler->setRulerMetricStyle((KRuler::MetricStyle)style);
     slotUpdateShowMarks();
 }
 
 void KRulerTest::slotUpdateShowMarks()
 {
     showTM->setChecked(hruler->showTinyMarks());
     showLM->setChecked(hruler->showLittleMarks());
     showMM->setChecked(hruler->showMediumMarks());
     showBM->setChecked(hruler->showBigMarks());
     showEM->setChecked(hruler->showEndMarks());
 }
 
 void KRulerTest::slotCheckLength(bool fixlen)
 {
     Q_UNUSED(fixlen);
     beginMark->setValue(hruler->offset());
     endMark->setValue(hruler->endOffset());
     lengthInput->setValue(hruler->length());
 }
 
 void KRulerTest::slotSetRotate(double d)
 {
     Q_UNUSED(d);
 #ifdef KRULER_ROTATE_TEST
     vruler->rotate = d;
     vruler->update();
     // debug("rotate %.1f", d);
 #endif
 }
 
 void KRulerTest::slotSetXTrans(double d)
 {
     Q_UNUSED(d);
 #ifdef KRULER_ROTATE_TEST
     vruler->xtrans = d;
     vruler->update();
     // debug("trans x %.1f", d);
 #endif
 }
 
 void KRulerTest::slotSetYTrans(double d)
 {
     Q_UNUSED(d);
 #ifdef KRULER_ROTATE_TEST
     vruler->ytrans = d;
     vruler->update();
     // debug("trans y %.1f", d);
 #endif
 }
 
 /* --- MAIN -----------------------*/
 int main(int argc, char **argv)
 {
     QCoreApplication::setAttribute(Qt::AA_UseHighDpiPixmaps);
     QApplication::setApplicationName(QStringLiteral("test"));
     QApplication *testapp;
     KRulerTest *window;
 
     testapp = new QApplication(argc, argv);
     testapp->setFont(QFont(QStringLiteral("Helvetica"), 12));
 
     window = new KRulerTest();
     window->setWindowTitle(QStringLiteral("KRulerTest"));
     window->resize(800, 600);
     window->show();
     return testapp->exec();
 }
 
 #include "moc_krulertest.cpp"