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 (e->y() > e->x()) {
  84                 if (e->y() < height() - e->x()) {
  85                         if (left_.enabled) {
  86                                 setLeft(left_.set == LINE_SET ? LINE_UNSET : LINE_SET);
  87                                 // emit signal
  88                                 leftSet();
  89                         }
  90                 } else {
  91                         if (bottom_trim_left_.enabled && e->x() < margin + 4 + 2 * corner_length) {
  92                                 setBottomLeftTrim(bottom_trim_left_.set == LINE_SET ? LINE_UNSET : LINE_SET);
  93                                 // emit signal
  94                                 bottomLTSet();
  95                         } else if (bottom_trim_right_.enabled && e->x() > bwidth - margin - 2 * corner_length - 4) {
  96                                         setBottomRightTrim(bottom_trim_right_.set == LINE_SET ? LINE_UNSET : LINE_SET);
  97                                         // emit signal
  98                                         bottomRTSet();
  99                         } else if (bottom_.enabled) {
 100                                 setBottom(bottom_.set == LINE_SET ? LINE_UNSET : LINE_SET);
 101                                 // emit signal
 102                                 bottomSet();
 103                         }
 104                 }
 105         } else {
 106                 if (e->y() < height() - e->x()) {
 107                         if (top_trim_left_.enabled && e->x() < margin + 4 + 2 * corner_length) {
 108                                 setTopLeftTrim(top_trim_left_.set == LINE_SET ? LINE_UNSET : LINE_SET);
 109                                 // emit signal
 110                                 topLTSet();
 111                         } else if (top_trim_right_.enabled && e->x() > bwidth - margin - 2 * corner_length - 4) {
 112                                         setTopRightTrim(top_trim_right_.set == LINE_SET ? LINE_UNSET : LINE_SET);
 113                                         // emit signal
 114                                         topRTSet();
 115                         } else if (top_.enabled) {
 116                                 setTop(top_.set == LINE_SET ? LINE_UNSET : LINE_SET);
 117                                 // emit signal
 118                                 topSet();
 119                         }
 120                 } else {
 121                         if (right_.enabled) {
 122                                 setRight(right_.set == LINE_SET ? LINE_UNSET : LINE_SET);
 123                                 // emit signal
 124                                 rightSet();
 125                         }
 126                 }
 127         }
 128         update();
 129         // emit signal
 130         clicked();
 131 }
 132
 133
 134 void GuiSetBorder::drawLine(QColor const & col, int x, int y, int x2, int y2)
 135 {
 136         QPainter paint(&buffer);
 137         QPen p = paint.pen();
 138         p.setWidth(2);
 139         p.setColor(col);
 140         paint.setPen(p);
 141         paint.drawLine(x, y, x2, y2);
 142 }
 143
 144
 145 void GuiSetBorder::drawLeft(BorderState draw)
 146 {
 147         QColor col;
 148         switch (draw) {
 149         case LINE_SET:
 150                 col = Qt::black;
 151                 break;
 152         case LINE_UNSET:
 153                 col = Qt::white;
 154                 break;
 155         case LINE_UNDECIDED:
 156         case LINE_UNDEF:
 157                 col = Qt::lightGray;
 158                 break;
 159         }
 160         if (!left_.enabled)
 161                 col = QColor(Qt::lightGray);
 162         drawLine(col, margin + corner_length, margin + corner_length + 2,
 163                  margin + corner_length, bheight - margin - corner_length - 1);
 164 }
 165
 166
 167 void GuiSetBorder::drawRight(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 (!right_.enabled)
 183                 col = QColor(Qt::lightGray);
 184         drawLine(col, bheight - margin - corner_length + 1, margin + corner_length + 2,
 185                  bheight - margin - corner_length + 1, bheight - margin - corner_length - 1);
 186 }
 187
 188
 189 void GuiSetBorder::drawTop(BorderState draw)
 190 {
 191         QColor col;
 192         switch (draw) {
 193         case LINE_SET:
 194                 col = Qt::black;
 195                 top_drawn_wide_ = true;
 196                 break;
 197         case LINE_UNSET:
 198                 col = Qt::white;
 199                 top_drawn_wide_ = false;
 200                 break;
 201         case LINE_UNDECIDED:
 202         case LINE_UNDEF:
 203                 col = Qt::lightGray;
 204                 top_drawn_wide_ = true;
 205                 break;
 206         }
 207         if (!top_.enabled)
 208                 col = QColor(Qt::lightGray);
 209         int const lt = (top_trim_left_.enabled) ? corner_length + 4 : 0;
 210         int const rt = (top_trim_right_.enabled) ? corner_length + 4 : 0;
 211         drawLine(col, margin + corner_length + 2 + lt, margin + corner_length,
 212                  bwidth - margin - corner_length - 1 - rt, margin + corner_length);
 213 }
 214
 215
 216 void GuiSetBorder::undrawWideTopLine(bool const right)
 217 {
 218         if (!top_drawn_wide_ && !right)
 219                 return;
 220
 221         // Overpaint previous lines white
 222         if (right)
 223                 drawLine(Qt::white, margin + 2 * (corner_length + 2), margin + corner_length,
 224                         bwidth - margin - corner_length - 1, margin + corner_length);
 225         else
 226                 drawLine(Qt::white, margin + corner_length + 2, margin + corner_length,
 227                          bwidth - margin - corner_length - 1, margin + corner_length);
 228         top_drawn_wide_ = false;
 229 }
 230
 231
 232 void GuiSetBorder::drawTopLeftTrim(BorderState draw)
 233 {
 234         QColor col;
 235         switch (draw) {
 236         case LINE_SET:
 237                 col = Qt::black;
 238                 break;
 239         case LINE_UNSET:
 240                 col = Qt::white;
 241                 break;
 242         case LINE_UNDECIDED:
 243         case LINE_UNDEF:
 244                 col = Qt::lightGray;
 245                 break;
 246         }
 247         if (!top_trim_left_.enabled)
 248                 col = QColor(Qt::white);
 249         int const lt = corner_length;
 250         if (top_trim_left_.enabled)
 251                 drawLine(col, margin + corner_length + 2, margin + corner_length,
 252                          margin + corner_length + 2 + lt, margin + corner_length);
 253 }
 254
 255
 256 void GuiSetBorder::drawTopRightTrim(BorderState draw)
 257 {
 258         QColor col;
 259         switch (draw) {
 260         case LINE_SET:
 261                 col = Qt::black;
 262                 break;
 263         case LINE_UNSET:
 264                 col = Qt::white;
 265                 break;
 266         case LINE_UNDECIDED:
 267         case LINE_UNDEF:
 268                 col = Qt::lightGray;
 269                 break;
 270         }
 271         if (!top_trim_right_.enabled)
 272                 col = QColor(Qt::white);
 273         int const rt = corner_length;
 274         if (top_trim_right_.enabled)
 275                 drawLine(col, bwidth - margin - corner_length - 1 - rt, margin + corner_length,
 276                         bwidth - margin - corner_length - 1, margin + corner_length);
 277 }
 278
 279
 280 void GuiSetBorder::drawBottom(BorderState draw)
 281 {
 282         QColor col;
 283         switch (draw) {
 284         case LINE_SET:
 285                 col = Qt::black;
 286                 bottom_drawn_wide_ = true;
 287                 break;
 288         case LINE_UNSET:
 289                 col = Qt::white;
 290                 bottom_drawn_wide_ = false;
 291                 break;
 292         case LINE_UNDECIDED:
 293         case LINE_UNDEF:
 294                 col = Qt::lightGray;
 295                 bottom_drawn_wide_ = true;
 296                 break;
 297         }
 298         if (!bottom_.enabled)
 299                 col = QColor(Qt::lightGray);
 300         int const lt = (bottom_trim_left_.enabled) ? corner_length + 4 : 0;
 301         int const rt = (bottom_trim_right_.enabled) ? corner_length + 4 : 0;
 302         drawLine(col, margin + corner_length + 2 + lt, bwidth - margin - corner_length + 1,
 303                  bwidth - margin - corner_length - 1 - rt, bwidth - margin - corner_length + 1);
 304 }
 305
 306
 307 void GuiSetBorder::undrawWideBottomLine(bool const right)
 308 {
 309         if (!bottom_drawn_wide_ && !right)
 310                 return;
 311
 312         // Overpaint previous lines white
 313         if (right)
 314                 drawLine(Qt::white, margin + 2 * (corner_length + 2), bwidth - margin - corner_length + 1,
 315                         bwidth - margin - corner_length - 1, bwidth - margin - corner_length + 1);
 316         else
 317                 drawLine(Qt::white, margin + corner_length + 2, bwidth - margin - corner_length + 1,
 318                          bwidth - margin - corner_length - 1, bwidth - margin - corner_length + 1);
 319         bottom_drawn_wide_ = false;
 320 }
 321
 322
 323 void GuiSetBorder::drawBottomLeftTrim(BorderState draw)
 324 {
 325         QColor col;
 326         switch (draw) {
 327         case LINE_SET:
 328                 col = Qt::black;
 329                 break;
 330         case LINE_UNSET:
 331                 col = Qt::white;
 332                 break;
 333         case LINE_UNDECIDED:
 334         case LINE_UNDEF:
 335                 col = Qt::lightGray;
 336                 break;
 337         }
 338         if (!bottom_trim_left_.enabled)
 339                 col = QColor(Qt::white);
 340         int const lt = corner_length;
 341         if (bottom_trim_left_.enabled)
 342                 drawLine(col, margin + corner_length + 2, bwidth - margin - corner_length + 1,
 343                          margin + corner_length + 2 + lt, bwidth - margin - corner_length + 1);
 344 }
 345
 346
 347 void GuiSetBorder::drawBottomRightTrim(BorderState draw)
 348 {
 349         QColor col;
 350         switch (draw) {
 351         case LINE_SET:
 352                 col = Qt::black;
 353                 break;
 354         case LINE_UNSET:
 355                 col = Qt::white;
 356                 break;
 357         case LINE_UNDECIDED:
 358         case LINE_UNDEF:
 359                 col = Qt::lightGray;
 360                 break;
 361         }
 362         if (!bottom_trim_right_.enabled)
 363                 col = QColor(Qt::white);
 364         int const rt = corner_length;
 365         if (bottom_trim_right_.enabled)
 366                 drawLine(col, bwidth - margin - corner_length - 1 - rt, bwidth - margin - corner_length + 1,
 367                          bwidth - margin - corner_length - 1, bwidth - margin - corner_length + 1);
 368 }
 369
 370
 371 void GuiSetBorder::setLeftEnabled(bool enabled)
 372 {
 373         left_.enabled = enabled;
 374         drawLeft(left_.set);
 375 }
 376
 377
 378 void GuiSetBorder::setRightEnabled(bool enabled)
 379 {
 380         right_.enabled = enabled;
 381         drawRight(right_.set);
 382 }
 383
 384
 385 void GuiSetBorder::setTopEnabled(bool enabled)
 386 {
 387         top_.enabled = enabled;
 388         drawTop(top_.set);
 389 }
 390
 391
 392 void GuiSetBorder::setBottomEnabled(bool enabled)
 393 {
 394         bottom_.enabled = enabled;
 395         drawBottom(bottom_.set);
 396 }
 397
 398
 399 void GuiSetBorder::setTopLeftTrimEnabled(bool enabled)
 400 {
 401         top_trim_left_.enabled = enabled;
 402         undrawWideTopLine();
 403         drawTopLeftTrim(top_trim_left_.set);
 404         drawTop(top_.set);
 405         top_drawn_wide_ = !enabled;
 406 }
 407
 408
 409 void GuiSetBorder::setTopRightTrimEnabled(bool enabled)
 410 {
 411         top_trim_right_.enabled = enabled;
 412         undrawWideTopLine(enabled);
 413         drawTopRightTrim(top_trim_right_.set);
 414         drawTop(top_.set);
 415         top_drawn_wide_ = !enabled;
 416 }
 417
 418
 419 void GuiSetBorder::setBottomLeftTrimEnabled(bool enabled)
 420 {
 421         bottom_trim_left_.enabled = enabled;
 422         undrawWideBottomLine();
 423         drawBottomLeftTrim(bottom_trim_left_.set);
 424         drawBottom(bottom_.set);
 425         bottom_drawn_wide_ = !enabled;
 426 }
 427
 428
 429 void GuiSetBorder::setBottomRightTrimEnabled(bool enabled)
 430 {
 431         bottom_trim_right_.enabled = enabled;
 432         undrawWideBottomLine(enabled);
 433         drawBottomRightTrim(bottom_trim_right_.set);
 434         drawBottom(bottom_.set);
 435         bottom_drawn_wide_ = !enabled;
 436 }
 437
 438
 439 void GuiSetBorder::setLeft(BorderState border)
 440 {
 441         left_.set = border;
 442         drawLeft(border);
 443 }
 444
 445
 446 void GuiSetBorder::setRight(BorderState border)
 447 {
 448         right_.set = border;
 449         drawRight(border);
 450 }
 451
 452
 453 void GuiSetBorder::setTop(BorderState border)
 454 {
 455         top_.set = border;
 456         drawTop(border);
 457 }
 458
 459
 460 void GuiSetBorder::setBottom(BorderState border)
 461 {
 462         bottom_.set = border;
 463         drawBottom(border);
 464 }
 465
 466
 467 void GuiSetBorder::setTopLeftTrim(BorderState border)
 468 {
 469         top_trim_left_.set = border;
 470         drawTopLeftTrim(border);
 471 }
 472
 473
 474 void GuiSetBorder::setTopRightTrim(BorderState border)
 475 {
 476         top_trim_right_.set = border;
 477         drawTopRightTrim(border);
 478 }
 479
 480
 481 void GuiSetBorder::setBottomLeftTrim(BorderState border)
 482 {
 483         bottom_trim_left_.set = border;
 484         drawBottomLeftTrim(border);
 485 }
 486
 487 void GuiSetBorder::setBottomRightTrim(BorderState border)
 488 {
 489         bottom_trim_right_.set = border;
 490         drawBottomRightTrim(border);
 491 }
 492
 493
 494 void GuiSetBorder::setAll(BorderState border)
 495 {
 496         setLeft(border);
 497         setRight(border);
 498         setTop(border);
 499         setBottom(border);
 500         setTopLeftTrim(border);
 501         setTopRightTrim(border);
 502         setBottomLeftTrim(border);
 503         setBottomRightTrim(border);
 504 }
 505
 506
 507 GuiSetBorder::BorderState GuiSetBorder::getLeft()
 508 {
 509         return left_.set;
 510 }
 511
 512
 513 GuiSetBorder::BorderState GuiSetBorder::getRight()
 514 {
 515         return right_.set;
 516 }
 517
 518
 519 GuiSetBorder::BorderState GuiSetBorder::getTop()
 520 {
 521         return top_.set;
 522 }
 523
 524
 525 GuiSetBorder::BorderState GuiSetBorder::getBottom()
 526 {
 527         return bottom_.set;
 528 }
 529
 530
 531 GuiSetBorder::BorderState GuiSetBorder::getTopLeftTrim()
 532 {
 533         return top_trim_left_.set;
 534 }
 535
 536
 537 GuiSetBorder::BorderState GuiSetBorder::getTopRightTrim()
 538 {
 539         return top_trim_right_.set;
 540 }
 541
 542
 543 GuiSetBorder::BorderState GuiSetBorder::getBottomLeftTrim()
 544 {
 545         return bottom_trim_left_.set;
 546 }
 547
 548
 549 GuiSetBorder::BorderState GuiSetBorder::getBottomRightTrim()
 550 {
 551         return bottom_trim_right_.set;
 552 }
 553
 554 #include "moc_GuiSetBorder.cpp"