src/frontends/qt/GuiSetBorder.cpp

   1 /**
   2  * \file GuiSetBorder.cpp
   3  * This file is part of LyX, the document processor.
   4  * Licence details can be found in the file COPYING.
   5  *
   6  * \author Edwin Leuven
   7  * \author John Levon
   8  * \author Jürgen Spitzmüller
   9  *
  10  * Full author contact details are available in file CREDITS.
  11  */
  12
  13 #include <config.h>
  14
  15 #include "GuiSetBorder.h"
  16
  17 #include "support/debug.h"
  18
  19 #include <QPainter>
  20 #include <QMouseEvent>
  21 #include <QPaintEvent>
  22
  23
  24 GuiSetBorder::GuiSetBorder(QWidget * parent, Qt::WindowFlags fl)
  25         : QWidget(parent, fl), buffer(75, 75), bottom_drawn_wide_(false),
  26           top_drawn_wide_(false)
  27 {
  28         /* length of corner line */
  29         corner_length = buffer.width() / 10;
  30         /* margin */
  31         margin = buffer.height() / 10;
  32
  33         bwidth = buffer.width();
  34         bheight = buffer.height();
  35
  36         init();
  37
  38         setMinimumSize(bwidth, bheight);
  39         setMaximumSize(bwidth, bheight);
  40 }
  41
  42
  43 void GuiSetBorder::paintEvent(QPaintEvent * e)
  44 {
  45         QWidget::paintEvent(e);
  46         QPainter painter(this);
  47         painter.drawPixmap(0, 0, buffer);
  48 }
  49
  50
  51 void GuiSetBorder::init()
  52 {
  53         buffer.fill();
  54         QPainter paint(&buffer);
  55
  56         paint.setPen(Qt::black);
  57
  58         // Draw the corner marks
  59         paint.drawLine(margin + corner_length, margin,
  60                        margin + corner_length, margin + corner_length);
  61         paint.drawLine(bwidth - (margin + corner_length), margin,
  62                        bwidth - (margin + corner_length), margin + corner_length);
  63
  64         paint.drawLine(margin, margin + corner_length,
  65                        margin + corner_length, margin + corner_length);
  66         paint.drawLine(margin, bheight - (margin + corner_length),
  67                        margin + corner_length, bheight - (margin + corner_length));
  68
  69         paint.drawLine(margin + corner_length ,bheight - margin,
  70                        margin + corner_length ,bheight - (margin + corner_length));
  71         paint.drawLine(bwidth - (margin + corner_length), bheight - margin,
  72                        bwidth - (margin + corner_length), bheight - (margin + corner_length));
  73
  74         paint.drawLine(bheight - margin, margin+corner_length,
  75                        bheight - (margin + corner_length), margin + corner_length);
  76         paint.drawLine(bheight - margin, bheight - (margin + corner_length),
  77                        bheight - (margin + corner_length),bheight - (margin + corner_length));
  78 }
  79
  80
  81 void GuiSetBorder::mousePressEvent(QMouseEvent * e)
  82 {
  83 #if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
  84         if (e->position().y() > e->position().x()) {
  85                 if (e->position().y() < height() - e->position().x()) {
  86 #else
  87         if (e->y() > e->x()) {
  88                 if (e->y() < height() - e->x()) {
  89 #endif
  90                         if (left_.enabled) {
  91                                 setLeft(left_.set == LINE_SET ? LINE_UNSET : LINE_SET);
  92                                 // emit signal
  93                                 leftSet();
  94                         }
  95                 } else {
  96 #if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
  97                         if (bottom_trim_left_.enabled && e->position().x() < margin + 4 + 2 * corner_length) {
  98 #else
  99                         if (bottom_trim_left_.enabled && e->x() < margin + 4 + 2 * corner_length) {
 100 #endif
 101                                 setBottomLeftTrim(bottom_trim_left_.set == LINE_SET ? LINE_UNSET : LINE_SET);
 102                                 // emit signal
 103                                 bottomLTSet();
 104 #if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
 105                         } else if (bottom_trim_right_.enabled && e->position().x() > bwidth - margin - 2 * corner_length - 4) {
 106 #else
 107                         } else if (bottom_trim_right_.enabled && e->x() > bwidth - margin - 2 * corner_length - 4) {
 108 #endif
 109                                         setBottomRightTrim(bottom_trim_right_.set == LINE_SET ? LINE_UNSET : LINE_SET);
 110                                         // emit signal
 111                                         bottomRTSet();
 112                         } else if (bottom_.enabled) {
 113                                 setBottom(bottom_.set == LINE_SET ? LINE_UNSET : LINE_SET);
 114                                 // emit signal
 115                                 bottomSet();
 116                         }
 117                 }
 118         } else {
 119 #if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
 120                 if (e->position().y() < height() - e->position().x()) {
 121                         if (top_trim_left_.enabled && e->position().x() < margin + 4 + 2 * corner_length) {
 122 #else
 123                 if (e->y() < height() - e->x()) {
 124                         if (top_trim_left_.enabled && e->x() < margin + 4 + 2 * corner_length) {
 125 #endif
 126                                 setTopLeftTrim(top_trim_left_.set == LINE_SET ? LINE_UNSET : LINE_SET);
 127                                 // emit signal
 128                                 topLTSet();
 129 #if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
 130                         } else if (top_trim_right_.enabled && e->position().x() > bwidth - margin - 2 * corner_length - 4) {
 131 #else
 132                         } else if (top_trim_right_.enabled && e->x() > bwidth - margin - 2 * corner_length - 4) {
 133 #endif
 134                                         setTopRightTrim(top_trim_right_.set == LINE_SET ? LINE_UNSET : LINE_SET);
 135                                         // emit signal
 136                                         topRTSet();
 137                         } else if (top_.enabled) {
 138                                 setTop(top_.set == LINE_SET ? LINE_UNSET : LINE_SET);
 139                                 // emit signal
 140                                 topSet();
 141                         }
 142                 } else {
 143                         if (right_.enabled) {
 144                                 setRight(right_.set == LINE_SET ? LINE_UNSET : LINE_SET);
 145                                 // emit signal
 146                                 rightSet();
 147                         }
 148                 }
 149         }
 150         update();
 151         // emit signal
 152         clicked();
 153 }
 154
 155
 156 void GuiSetBorder::drawLine(QColor const & col, int x, int y, int x2, int y2)
 157 {
 158         QPainter paint(&buffer);
 159         QPen p = paint.pen();
 160         p.setWidth(2);
 161         p.setColor(col);
 162         paint.setPen(p);
 163         paint.drawLine(x, y, x2, y2);
 164 }
 165
 166
 167 void GuiSetBorder::drawLeft(BorderState draw)
 168 {
 169         QColor col;
 170         switch (draw) {
 171         case LINE_SET:
 172                 col = Qt::black;
 173                 break;
 174         case LINE_UNSET:
 175                 col = Qt::white;
 176                 break;
 177         case LINE_UNDECIDED:
 178         case LINE_UNDEF:
 179                 col = Qt::lightGray;
 180                 break;
 181         }
 182         if (!left_.enabled)
 183                 col = QColor(Qt::lightGray);
 184         drawLine(col, margin + corner_length, margin + corner_length + 2,
 185                  margin + corner_length, bheight - margin - corner_length - 1);
 186 }
 187
 188
 189 void GuiSetBorder::drawRight(BorderState draw)
 190 {
 191         QColor col;
 192         switch (draw) {
 193         case LINE_SET:
 194                 col = Qt::black;
 195                 break;
 196         case LINE_UNSET:
 197                 col = Qt::white;
 198                 break;
 199         case LINE_UNDECIDED:
 200         case LINE_UNDEF:
 201                 col = Qt::lightGray;
 202                 break;
 203         }
 204         if (!right_.enabled)
 205                 col = QColor(Qt::lightGray);
 206         drawLine(col, bheight - margin - corner_length + 1, margin + corner_length + 2,
 207                  bheight - margin - corner_length + 1, bheight - margin - corner_length - 1);
 208 }
 209
 210
 211 void GuiSetBorder::drawTop(BorderState draw)
 212 {
 213         QColor col;
 214         switch (draw) {
 215         case LINE_SET:
 216                 col = Qt::black;
 217                 top_drawn_wide_ = true;
 218                 break;
 219         case LINE_UNSET:
 220                 col = Qt::white;
 221                 top_drawn_wide_ = false;
 222                 break;
 223         case LINE_UNDECIDED:
 224         case LINE_UNDEF:
 225                 col = Qt::lightGray;
 226                 top_drawn_wide_ = true;
 227                 break;
 228         }
 229         if (!top_.enabled)
 230                 col = QColor(Qt::lightGray);
 231         int const lt = (top_trim_left_.enabled) ? corner_length + 4 : 0;
 232         int const rt = (top_trim_right_.enabled) ? corner_length + 4 : 0;
 233         drawLine(col, margin + corner_length + 2 + lt, margin + corner_length,
 234                  bwidth - margin - corner_length - 1 - rt, margin + corner_length);
 235 }
 236
 237
 238 void GuiSetBorder::undrawWideTopLine(bool const right)
 239 {
 240         if (!top_drawn_wide_ && !right)
 241                 return;
 242
 243         // Overpaint previous lines white
 244         if (right)
 245                 drawLine(Qt::white, margin + 2 * (corner_length + 2), margin + corner_length,
 246                         bwidth - margin - corner_length - 1, margin + corner_length);
 247         else
 248                 drawLine(Qt::white, margin + corner_length + 2, margin + corner_length,
 249                          bwidth - margin - corner_length - 1, margin + corner_length);
 250         top_drawn_wide_ = false;
 251 }
 252
 253
 254 void GuiSetBorder::drawTopLeftTrim(BorderState draw)
 255 {
 256         QColor col;
 257         switch (draw) {
 258         case LINE_SET:
 259                 col = Qt::black;
 260                 break;
 261         case LINE_UNSET:
 262                 col = Qt::white;
 263                 break;
 264         case LINE_UNDECIDED:
 265         case LINE_UNDEF:
 266                 col = Qt::lightGray;
 267                 break;
 268         }
 269         if (!top_trim_left_.enabled)
 270                 col = QColor(Qt::white);
 271         int const lt = corner_length;
 272         if (top_trim_left_.enabled)
 273                 drawLine(col, margin + corner_length + 2, margin + corner_length,
 274                          margin + corner_length + 2 + lt, margin + corner_length);
 275 }
 276
 277
 278 void GuiSetBorder::drawTopRightTrim(BorderState draw)
 279 {
 280         QColor col;
 281         switch (draw) {
 282         case LINE_SET:
 283                 col = Qt::black;
 284                 break;
 285         case LINE_UNSET:
 286                 col = Qt::white;
 287                 break;
 288         case LINE_UNDECIDED:
 289         case LINE_UNDEF:
 290                 col = Qt::lightGray;
 291                 break;
 292         }
 293         if (!top_trim_right_.enabled)
 294                 col = QColor(Qt::white);
 295         int const rt = corner_length;
 296         if (top_trim_right_.enabled)
 297                 drawLine(col, bwidth - margin - corner_length - 1 - rt, margin + corner_length,
 298                         bwidth - margin - corner_length - 1, margin + corner_length);
 299 }
 300
 301
 302 void GuiSetBorder::drawBottom(BorderState draw)
 303 {
 304         QColor col;
 305         switch (draw) {
 306         case LINE_SET:
 307                 col = Qt::black;
 308                 bottom_drawn_wide_ = true;
 309                 break;
 310         case LINE_UNSET:
 311                 col = Qt::white;
 312                 bottom_drawn_wide_ = false;
 313                 break;
 314         case LINE_UNDECIDED:
 315         case LINE_UNDEF:
 316                 col = Qt::lightGray;
 317                 bottom_drawn_wide_ = true;
 318                 break;
 319         }
 320         if (!bottom_.enabled)
 321                 col = QColor(Qt::lightGray);
 322         int const lt = (bottom_trim_left_.enabled) ? corner_length + 4 : 0;
 323         int const rt = (bottom_trim_right_.enabled) ? corner_length + 4 : 0;
 324         drawLine(col, margin + corner_length + 2 + lt, bwidth - margin - corner_length + 1,
 325                  bwidth - margin - corner_length - 1 - rt, bwidth - margin - corner_length + 1);
 326 }
 327
 328
 329 void GuiSetBorder::undrawWideBottomLine(bool const right)
 330 {
 331         if (!bottom_drawn_wide_ && !right)
 332                 return;
 333
 334         // Overpaint previous lines white
 335         if (right)
 336                 drawLine(Qt::white, margin + 2 * (corner_length + 2), bwidth - margin - corner_length + 1,
 337                         bwidth - margin - corner_length - 1, bwidth - margin - corner_length + 1);
 338         else
 339                 drawLine(Qt::white, margin + corner_length + 2, bwidth - margin - corner_length + 1,
 340                          bwidth - margin - corner_length - 1, bwidth - margin - corner_length + 1);
 341         bottom_drawn_wide_ = false;
 342 }
 343
 344
 345 void GuiSetBorder::drawBottomLeftTrim(BorderState draw)
 346 {
 347         QColor col;
 348         switch (draw) {
 349         case LINE_SET:
 350                 col = Qt::black;
 351                 break;
 352         case LINE_UNSET:
 353                 col = Qt::white;
 354                 break;
 355         case LINE_UNDECIDED:
 356         case LINE_UNDEF:
 357                 col = Qt::lightGray;
 358                 break;
 359         }
 360         if (!bottom_trim_left_.enabled)
 361                 col = QColor(Qt::white);
 362         int const lt = corner_length;
 363         if (bottom_trim_left_.enabled)
 364                 drawLine(col, margin + corner_length + 2, bwidth - margin - corner_length + 1,
 365                          margin + corner_length + 2 + lt, bwidth - margin - corner_length + 1);
 366 }
 367
 368
 369 void GuiSetBorder::drawBottomRightTrim(BorderState draw)
 370 {
 371         QColor col;
 372         switch (draw) {
 373         case LINE_SET:
 374                 col = Qt::black;
 375                 break;
 376         case LINE_UNSET:
 377                 col = Qt::white;
 378                 break;
 379         case LINE_UNDECIDED:
 380         case LINE_UNDEF:
 381                 col = Qt::lightGray;
 382                 break;
 383         }
 384         if (!bottom_trim_right_.enabled)
 385                 col = QColor(Qt::white);
 386         int const rt = corner_length;
 387         if (bottom_trim_right_.enabled)
 388                 drawLine(col, bwidth - margin - corner_length - 1 - rt, bwidth - margin - corner_length + 1,
 389                          bwidth - margin - corner_length - 1, bwidth - margin - corner_length + 1);
 390 }
 391
 392
 393 void GuiSetBorder::setLeftEnabled(bool enabled)
 394 {
 395         left_.enabled = enabled;
 396         drawLeft(left_.set);
 397 }
 398
 399
 400 void GuiSetBorder::setRightEnabled(bool enabled)
 401 {
 402         right_.enabled = enabled;
 403         drawRight(right_.set);
 404 }
 405
 406
 407 void GuiSetBorder::setTopEnabled(bool enabled)
 408 {
 409         top_.enabled = enabled;
 410         drawTop(top_.set);
 411 }
 412
 413
 414 void GuiSetBorder::setBottomEnabled(bool enabled)
 415 {
 416         bottom_.enabled = enabled;
 417         drawBottom(bottom_.set);
 418 }
 419
 420
 421 void GuiSetBorder::setTopLeftTrimEnabled(bool enabled)
 422 {
 423         top_trim_left_.enabled = enabled;
 424         undrawWideTopLine();
 425         drawTopLeftTrim(top_trim_left_.set);
 426         drawTop(top_.set);
 427         top_drawn_wide_ = !enabled;
 428 }
 429
 430
 431 void GuiSetBorder::setTopRightTrimEnabled(bool enabled)
 432 {
 433         top_trim_right_.enabled = enabled;
 434         undrawWideTopLine(enabled);
 435         drawTopRightTrim(top_trim_right_.set);
 436         drawTop(top_.set);
 437         top_drawn_wide_ = !enabled;
 438 }
 439
 440
 441 void GuiSetBorder::setBottomLeftTrimEnabled(bool enabled)
 442 {
 443         bottom_trim_left_.enabled = enabled;
 444         undrawWideBottomLine();
 445         drawBottomLeftTrim(bottom_trim_left_.set);
 446         drawBottom(bottom_.set);
 447         bottom_drawn_wide_ = !enabled;
 448 }
 449
 450
 451 void GuiSetBorder::setBottomRightTrimEnabled(bool enabled)
 452 {
 453         bottom_trim_right_.enabled = enabled;
 454         undrawWideBottomLine(enabled);
 455         drawBottomRightTrim(bottom_trim_right_.set);
 456         drawBottom(bottom_.set);
 457         bottom_drawn_wide_ = !enabled;
 458 }
 459
 460
 461 void GuiSetBorder::setLeft(BorderState border)
 462 {
 463         left_.set = border;
 464         drawLeft(border);
 465 }
 466
 467
 468 void GuiSetBorder::setRight(BorderState border)
 469 {
 470         right_.set = border;
 471         drawRight(border);
 472 }
 473
 474
 475 void GuiSetBorder::setTop(BorderState border)
 476 {
 477         top_.set = border;
 478         drawTop(border);
 479 }
 480
 481
 482 void GuiSetBorder::setBottom(BorderState border)
 483 {
 484         bottom_.set = border;
 485         drawBottom(border);
 486 }
 487
 488
 489 void GuiSetBorder::setTopLeftTrim(BorderState border)
 490 {
 491         top_trim_left_.set = border;
 492         drawTopLeftTrim(border);
 493 }
 494
 495
 496 void GuiSetBorder::setTopRightTrim(BorderState border)
 497 {
 498         top_trim_right_.set = border;
 499         drawTopRightTrim(border);
 500 }
 501
 502
 503 void GuiSetBorder::setBottomLeftTrim(BorderState border)
 504 {
 505         bottom_trim_left_.set = border;
 506         drawBottomLeftTrim(border);
 507 }
 508
 509 void GuiSetBorder::setBottomRightTrim(BorderState border)
 510 {
 511         bottom_trim_right_.set = border;
 512         drawBottomRightTrim(border);
 513 }
 514
 515
 516 void GuiSetBorder::setAll(BorderState border)
 517 {
 518         setLeft(border);
 519         setRight(border);
 520         setTop(border);
 521         setBottom(border);
 522         setTopLeftTrim(border);
 523         setTopRightTrim(border);
 524         setBottomLeftTrim(border);
 525         setBottomRightTrim(border);
 526 }
 527
 528
 529 GuiSetBorder::BorderState GuiSetBorder::getLeft()
 530 {
 531         return left_.set;
 532 }
 533
 534
 535 GuiSetBorder::BorderState GuiSetBorder::getRight()
 536 {
 537         return right_.set;
 538 }
 539
 540
 541 GuiSetBorder::BorderState GuiSetBorder::getTop()
 542 {
 543         return top_.set;
 544 }
 545
 546
 547 GuiSetBorder::BorderState GuiSetBorder::getBottom()
 548 {
 549         return bottom_.set;
 550 }
 551
 552
 553 GuiSetBorder::BorderState GuiSetBorder::getTopLeftTrim()
 554 {
 555         return top_trim_left_.set;
 556 }
 557
 558
 559 GuiSetBorder::BorderState GuiSetBorder::getTopRightTrim()
 560 {
 561         return top_trim_right_.set;
 562 }
 563
 564
 565 GuiSetBorder::BorderState GuiSetBorder::getBottomLeftTrim()
 566 {
 567         return bottom_trim_left_.set;
 568 }
 569
 570
 571 GuiSetBorder::BorderState GuiSetBorder::getBottomRightTrim()
 572 {
 573         return bottom_trim_right_.set;
 574 }
 575
 576 #include "moc_GuiSetBorder.cpp"