src/frontends/qt4/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()
 217 {
 218         if (!top_drawn_wide_)
 219                 return;
 220
 221         // Overpaint previous lines white
 222         drawLine(Qt::white, margin + corner_length + 2, margin + corner_length,
 223                  bwidth - margin - corner_length - 1, margin + corner_length);
 224         top_drawn_wide_ = false;
 225 }
 226
 227
 228 void GuiSetBorder::drawTopLeftTrim(BorderState draw)
 229 {
 230         QColor col;
 231         switch (draw) {
 232         case LINE_SET:
 233                 col = Qt::black;
 234                 break;
 235         case LINE_UNSET:
 236                 col = Qt::white;
 237                 break;
 238         case LINE_UNDECIDED:
 239         case LINE_UNDEF:
 240                 col = Qt::lightGray;
 241                 break;
 242         }
 243         if (!top_trim_left_.enabled)
 244                 col = QColor(Qt::white);
 245         int const lt = corner_length;
 246         if (top_trim_left_.enabled)
 247                 drawLine(col, margin + corner_length + 2, margin + corner_length,
 248                          margin + corner_length + 2 + lt, margin + corner_length);
 249 }
 250
 251
 252 void GuiSetBorder::drawTopRightTrim(BorderState draw)
 253 {
 254         QColor col;
 255         switch (draw) {
 256         case LINE_SET:
 257                 col = Qt::black;
 258                 break;
 259         case LINE_UNSET:
 260                 col = Qt::white;
 261                 break;
 262         case LINE_UNDECIDED:
 263         case LINE_UNDEF:
 264                 col = Qt::lightGray;
 265                 break;
 266         }
 267         if (!top_trim_right_.enabled)
 268                 col = QColor(Qt::white);
 269         int const rt = corner_length;
 270         if (top_trim_right_.enabled)
 271                 drawLine(col, bwidth - margin - corner_length - 1 - rt, margin + corner_length,
 272                         bwidth - margin - corner_length - 1, margin + corner_length);
 273 }
 274
 275
 276 void GuiSetBorder::drawBottom(BorderState draw)
 277 {
 278         QColor col;
 279         switch (draw) {
 280         case LINE_SET:
 281                 col = Qt::black;
 282                 bottom_drawn_wide_ = true;
 283                 break;
 284         case LINE_UNSET:
 285                 col = Qt::white;
 286                 bottom_drawn_wide_ = false;
 287                 break;
 288         case LINE_UNDECIDED:
 289         case LINE_UNDEF:
 290                 col = Qt::lightGray;
 291                 bottom_drawn_wide_ = true;
 292                 break;
 293         }
 294         if (!bottom_.enabled)
 295                 col = QColor(Qt::lightGray);
 296         int const lt = (bottom_trim_left_.enabled) ? corner_length + 4 : 0;
 297         int const rt = (bottom_trim_right_.enabled) ? corner_length + 4 : 0;
 298         drawLine(col, margin + corner_length + 2 + lt, bwidth - margin - corner_length + 1,
 299                  bwidth - margin - corner_length - 1 - rt, bwidth - margin - corner_length + 1);
 300 }
 301
 302
 303 void GuiSetBorder::undrawWideBottomLine()
 304 {
 305         if (!bottom_drawn_wide_)
 306                 return;
 307
 308         //Overpaint previous lines white
 309         drawLine(Qt::white, margin + corner_length + 2, bwidth - margin - corner_length + 1,
 310                  bwidth - margin - corner_length - 1, bwidth - margin - corner_length + 1);
 311         bottom_drawn_wide_ = false;
 312 }
 313
 314
 315 void GuiSetBorder::drawBottomLeftTrim(BorderState draw)
 316 {
 317         QColor col;
 318         switch (draw) {
 319         case LINE_SET:
 320                 col = Qt::black;
 321                 break;
 322         case LINE_UNSET:
 323                 col = Qt::white;
 324                 break;
 325         case LINE_UNDECIDED:
 326         case LINE_UNDEF:
 327                 col = Qt::lightGray;
 328                 break;
 329         }
 330         if (!bottom_trim_left_.enabled)
 331                 col = QColor(Qt::white);
 332         int const lt = corner_length;
 333         if (bottom_trim_left_.enabled)
 334                 drawLine(col, margin + corner_length + 2, bwidth - margin - corner_length + 1,
 335                          margin + corner_length + 2 + lt, bwidth - margin - corner_length + 1);
 336 }
 337
 338
 339 void GuiSetBorder::drawBottomRightTrim(BorderState draw)
 340 {
 341         QColor col;
 342         switch (draw) {
 343         case LINE_SET:
 344                 col = Qt::black;
 345                 break;
 346         case LINE_UNSET:
 347                 col = Qt::white;
 348                 break;
 349         case LINE_UNDECIDED:
 350         case LINE_UNDEF:
 351                 col = Qt::lightGray;
 352                 break;
 353         }
 354         if (!bottom_trim_right_.enabled)
 355                 col = QColor(Qt::white);
 356         int const rt = corner_length;
 357         if (bottom_trim_right_.enabled)
 358                 drawLine(col, bwidth - margin - corner_length - 1 - rt, bwidth - margin - corner_length + 1,
 359                          bwidth - margin - corner_length - 1, bwidth - margin - corner_length + 1);
 360 }
 361
 362
 363 void GuiSetBorder::setLeftEnabled(bool enabled)
 364 {
 365         left_.enabled = enabled;
 366         drawLeft(left_.set);
 367 }
 368
 369
 370 void GuiSetBorder::setRightEnabled(bool enabled)
 371 {
 372         right_.enabled = enabled;
 373         drawRight(right_.set);
 374 }
 375
 376
 377 void GuiSetBorder::setTopEnabled(bool enabled)
 378 {
 379         top_.enabled = enabled;
 380         drawTop(top_.set);
 381 }
 382
 383
 384 void GuiSetBorder::setBottomEnabled(bool enabled)
 385 {
 386         bottom_.enabled = enabled;
 387         drawBottom(bottom_.set);
 388 }
 389
 390
 391 void GuiSetBorder::setTopLeftTrimEnabled(bool enabled)
 392 {
 393         top_trim_left_.enabled = enabled;
 394         undrawWideTopLine();
 395         drawTopLeftTrim(top_trim_left_.set);
 396         drawTop(top_.set);
 397         top_drawn_wide_ = !enabled;
 398 }
 399
 400
 401 void GuiSetBorder::setTopRightTrimEnabled(bool enabled)
 402 {
 403         top_trim_right_.enabled = enabled;
 404         undrawWideTopLine();
 405         drawTopRightTrim(top_trim_right_.set);
 406         drawTop(top_.set);
 407         top_drawn_wide_ = !enabled;;
 408 }
 409
 410
 411 void GuiSetBorder::setBottomLeftTrimEnabled(bool enabled)
 412 {
 413         bottom_trim_left_.enabled = enabled;
 414         undrawWideBottomLine();
 415         drawBottomLeftTrim(bottom_trim_left_.set);
 416         drawBottom(bottom_.set);
 417         bottom_drawn_wide_ = !enabled;;
 418 }
 419
 420
 421 void GuiSetBorder::setBottomRightTrimEnabled(bool enabled)
 422 {
 423         bottom_trim_right_.enabled = enabled;
 424         undrawWideBottomLine();
 425         drawBottomRightTrim(bottom_trim_right_.set);
 426         drawBottom(bottom_.set);
 427         bottom_drawn_wide_ = !enabled;;
 428 }
 429
 430
 431 void GuiSetBorder::setLeft(BorderState border)
 432 {
 433         left_.set = border;
 434         drawLeft(border);
 435 }
 436
 437
 438 void GuiSetBorder::setRight(BorderState border)
 439 {
 440         right_.set = border;
 441         drawRight(border);
 442 }
 443
 444
 445 void GuiSetBorder::setTop(BorderState border)
 446 {
 447         top_.set = border;
 448         drawTop(border);
 449 }
 450
 451
 452 void GuiSetBorder::setBottom(BorderState border)
 453 {
 454         bottom_.set = border;
 455         drawBottom(border);
 456 }
 457
 458
 459 void GuiSetBorder::setTopLeftTrim(BorderState border)
 460 {
 461         top_trim_left_.set = border;
 462         drawTopLeftTrim(border);
 463 }
 464
 465
 466 void GuiSetBorder::setTopRightTrim(BorderState border)
 467 {
 468         top_trim_right_.set = border;
 469         drawTopRightTrim(border);
 470 }
 471
 472
 473 void GuiSetBorder::setBottomLeftTrim(BorderState border)
 474 {
 475         bottom_trim_left_.set = border;
 476         drawBottomLeftTrim(border);
 477 }
 478
 479 void GuiSetBorder::setBottomRightTrim(BorderState border)
 480 {
 481         bottom_trim_right_.set = border;
 482         drawBottomRightTrim(border);
 483 }
 484
 485
 486 void GuiSetBorder::setAll(BorderState border)
 487 {
 488         setLeft(border);
 489         setRight(border);
 490         setTop(border);
 491         setBottom(border);
 492         setTopLeftTrim(border);
 493         setTopRightTrim(border);
 494         setBottomLeftTrim(border);
 495         setBottomRightTrim(border);
 496 }
 497
 498
 499 GuiSetBorder::BorderState GuiSetBorder::getLeft()
 500 {
 501         return left_.set;
 502 }
 503
 504
 505 GuiSetBorder::BorderState GuiSetBorder::getRight()
 506 {
 507         return right_.set;
 508 }
 509
 510
 511 GuiSetBorder::BorderState GuiSetBorder::getTop()
 512 {
 513         return top_.set;
 514 }
 515
 516
 517 GuiSetBorder::BorderState GuiSetBorder::getBottom()
 518 {
 519         return bottom_.set;
 520 }
 521
 522
 523 GuiSetBorder::BorderState GuiSetBorder::getTopLeftTrim()
 524 {
 525         return top_trim_left_.set;
 526 }
 527
 528
 529 GuiSetBorder::BorderState GuiSetBorder::getTopRightTrim()
 530 {
 531         return top_trim_right_.set;
 532 }
 533
 534
 535 GuiSetBorder::BorderState GuiSetBorder::getBottomLeftTrim()
 536 {
 537         return bottom_trim_left_.set;
 538 }
 539
 540
 541 GuiSetBorder::BorderState GuiSetBorder::getBottomRightTrim()
 542 {
 543         return bottom_trim_right_.set;
 544 }
 545
 546 #include "moc_GuiSetBorder.cpp"