Shamusworld >> Repos - architektonas/blob - src/base/rs_eventhandler.cpp

   1 // rs_eventhandler.cpp
   2 //
   3 // Part of the Architektonas Project
   4 // Originally part of QCad Community Edition by Andrew Mustun
   5 // Extensively rewritten and refactored by James L. Hammons
   6 // (C) 2010 Underground Software
   7 //
   8 // JLH = James L. Hammons <jlhamm@acm.org>
   9 //
  10 // Who  When        What
  11 // ---  ----------  -----------------------------------------------------------
  12 // JLH  05/28/2010  Added this text. :-)
  13 //
  14
  15 #include "rs_eventhandler.h"
  16
  17 #include <QtGui>
  18 #include "rs_actioninterface.h"
  19 #include "rs_commandevent.h"
  20 #include "rs_debug.h"
  21 #include "rs_dialogfactory.h"
  22 #include "rs_graphicview.h"
  23 #include "rs_math.h"
  24
  25 /**
  26  * Constructor.
  27  */
  28 RS_EventHandler::RS_EventHandler(RS_GraphicView * graphicView)
  29 {
  30         this->graphicView = graphicView;
  31         actionIndex = -1;
  32
  33         for(int i=0; i<RS_MAXACTIONS; ++i)
  34                 currentActions[i] = NULL;
  35
  36         coordinateInputEnabled = true;
  37         defaultAction = NULL;
  38 }
  39
  40 /**
  41  * Destructor.
  42  */
  43 RS_EventHandler::~RS_EventHandler()
  44 {
  45         RS_DEBUG->print("RS_EventHandler::~RS_EventHandler");
  46
  47         if (defaultAction != NULL)
  48         {
  49                 defaultAction->finish();
  50                 delete defaultAction;
  51                 defaultAction = NULL;
  52         }
  53
  54         killAllActions();
  55
  56         RS_DEBUG->print("RS_EventHandler::~RS_EventHandler: Deleting all actions..");
  57
  58         for(int i=0; i<RS_MAXACTIONS; ++i)
  59         {
  60                 if (currentActions[i] != NULL)
  61                 {
  62                         currentActions[i]->setFinished();
  63                         //delete currentActions[i];
  64                         //currentActions[i] = NULL;
  65                 }
  66         }
  67
  68         cleanUp();
  69         RS_DEBUG->print("RS_EventHandler::~RS_EventHandler: Deleting all actions..: OK");
  70         RS_DEBUG->print("RS_EventHandler::~RS_EventHandler: OK");
  71 }
  72
  73 /**
  74  * Go back in current action.
  75  */
  76 void RS_EventHandler::back()
  77 {
  78         QMouseEvent e(QEvent::MouseButtonRelease, QPoint(0, 0), Qt::RightButton, Qt::RightButton,
  79                 Qt::NoModifier);
  80         mouseReleaseEvent(&e);
  81 }
  82
  83 /**
  84  * Go enter pressed event for current action.
  85  */
  86 void RS_EventHandler::enter()
  87 {
  88 //      QKeyEvent e(QEvent::KeyPress, Qt::Key_Enter, '\n', 0);
  89         QKeyEvent e(QEvent::KeyPress, Qt::Key_Enter, Qt::NoModifier, "\n", false, 0);
  90         keyPressEvent(&e);
  91 }
  92
  93 /**
  94  * Called by RS_GraphicView
  95  */
  96 void RS_EventHandler::mousePressEvent(QMouseEvent * e)
  97 {
  98         if (actionIndex >= 0 && currentActions[actionIndex] != NULL)
  99         {
 100                 currentActions[actionIndex]->mousePressEvent(e);
 101                 e->accept();
 102         }
 103         else
 104         {
 105                 if (defaultAction != NULL)
 106                 {
 107                         defaultAction->mousePressEvent(e);
 108                         e->accept();
 109                 }
 110                 else
 111                 {
 112                         RS_DEBUG->print("currently no action defined");
 113                         e->ignore();
 114                 }
 115         }
 116 }
 117
 118 /**
 119  * Called by RS_GraphicView
 120  */
 121 void RS_EventHandler::mouseReleaseEvent(QMouseEvent * e)
 122 {
 123         if (actionIndex >= 0 && currentActions[actionIndex] != NULL
 124                 && !currentActions[actionIndex]->isFinished())
 125         {
 126                 RS_DEBUG->print("call action %s", currentActions[actionIndex]->getName().toLatin1().data());
 127                 currentActions[actionIndex]->mouseReleaseEvent(e);
 128
 129                 // Clean up actions - one might be finished now
 130                 cleanUp();
 131                 e->accept();
 132         }
 133         else
 134         {
 135                 if (defaultAction != NULL)
 136                         defaultAction->mouseReleaseEvent(e);
 137                 else
 138                         e->ignore();
 139         }
 140 }
 141
 142 /**
 143  * Called by RS_GraphicView
 144  */
 145 void RS_EventHandler::mouseMoveEvent(QMouseEvent * e)
 146 {
 147         if (actionIndex >= 0 && currentActions[actionIndex] != NULL
 148                 && !currentActions[actionIndex]->isFinished())
 149         {
 150                 currentActions[actionIndex]->mouseMoveEvent(e);
 151                 e->accept();
 152         }
 153         else
 154         {
 155                 if (defaultAction!=NULL)
 156                 {
 157                         defaultAction->mouseMoveEvent(e);
 158                         e->accept();
 159                 }
 160                 else
 161                         e->ignore();
 162                 //RS_DEBUG->print("currently no action defined");
 163         }
 164 }
 165
 166 /**
 167  * Called by RS_GraphicView
 168  */
 169 void RS_EventHandler::mouseLeaveEvent()
 170 {
 171         if (actionIndex >= 0 && currentActions[actionIndex] != NULL
 172                 && !currentActions[actionIndex]->isFinished())
 173         {
 174                 currentActions[actionIndex]->suspend();
 175         }
 176         else
 177         {
 178                 if (defaultAction != NULL)
 179                         defaultAction->suspend();
 180                 //RS_DEBUG->print("currently no action defined");
 181         }
 182 }
 183
 184 /**
 185  * Called by RS_GraphicView
 186  */
 187 void RS_EventHandler::mouseEnterEvent()
 188 {
 189         if (actionIndex >= 0 && currentActions[actionIndex] != NULL
 190                 && !currentActions[actionIndex]->isFinished())
 191         {
 192                 currentActions[actionIndex]->resume();
 193         }
 194         else
 195         {
 196                 if (defaultAction != NULL)
 197                         defaultAction->resume();
 198         }
 199 }
 200
 201 /**
 202  * Called by RS_GraphicView
 203  */
 204 void RS_EventHandler::keyPressEvent(QKeyEvent * e)
 205 {
 206         if (actionIndex >= 0 && currentActions[actionIndex] != NULL
 207                 && !currentActions[actionIndex]->isFinished())
 208         {
 209                 currentActions[actionIndex]->keyPressEvent(e);
 210         }
 211         else
 212         {
 213                 if (defaultAction != NULL)
 214                         defaultAction->keyPressEvent(e);
 215                 else
 216                         e->ignore();
 217
 218                 //RS_DEBUG->print("currently no action defined");
 219         }
 220 }
 221
 222 /**
 223  * Called by RS_GraphicView
 224  */
 225 void RS_EventHandler::keyReleaseEvent(QKeyEvent * e)
 226 {
 227         if (actionIndex >= 0 && currentActions[actionIndex] != NULL
 228                 && !currentActions[actionIndex]->isFinished())
 229         {
 230                 currentActions[actionIndex]->keyReleaseEvent(e);
 231         }
 232         else
 233         {
 234                 if (defaultAction != NULL)
 235                         defaultAction->keyReleaseEvent(e);
 236                 else
 237                         e->ignore();
 238
 239                 //RS_DEBUG->print("currently no action defined");
 240         }
 241 }
 242
 243 /**
 244  * Handles command line events.
 245  */
 246 void RS_EventHandler::commandEvent(RS_CommandEvent * e)
 247 {
 248         RS_DEBUG->print("RS_EventHandler::commandEvent");
 249         QString cmd = e->getCommand();
 250
 251         if (coordinateInputEnabled)
 252         {
 253                 if (!e->isAccepted())
 254                 {
 255                         // handle absolute cartesian coordinate input:
 256                         if (cmd.contains(',') && cmd.at(0) != '@')
 257                         {
 258                                 if (actionIndex >= 0 && currentActions[actionIndex] != NULL
 259                                         && !currentActions[actionIndex]->isFinished())
 260                                 {
 261                                         int commaPos = cmd.indexOf(',');
 262                                         RS_DEBUG->print("RS_EventHandler::commandEvent: 001");
 263                                         bool ok1, ok2;
 264                                         RS_DEBUG->print("RS_EventHandler::commandEvent: 002");
 265                                         double x = RS_Math::eval(cmd.left(commaPos), &ok1);
 266                                         RS_DEBUG->print("RS_EventHandler::commandEvent: 003a");
 267                                         double y = RS_Math::eval(cmd.mid(commaPos + 1), &ok2);
 268                                         RS_DEBUG->print("RS_EventHandler::commandEvent: 004");
 269
 270                                         if (ok1 && ok2)
 271                                         {
 272 //                                              RS_DEBUG->print("RS_EventHandler::commandEvent: 005");
 273 //                                              RS_CoordinateEvent ce(Vector(x, y));
 274                                                 RS_DEBUG->print("RS_EventHandler::commandEvent: 006");
 275 //                                              currentActions[actionIndex]->coordinateEvent(&ce);
 276                                                 Vector ce(x, y);
 277                                                 currentActions[actionIndex]->coordinateEvent(&ce);
 278                                         }
 279                                         else
 280                                         {
 281                                                 if (RS_DIALOGFACTORY != NULL)
 282                                                         RS_DIALOGFACTORY->commandMessage("Expression Syntax Error");
 283                                         }
 284
 285                                         e->accept();
 286                                 }
 287                         }
 288                 }
 289
 290                 // handle relative cartesian coordinate input:
 291                 if (!e->isAccepted())
 292                 {
 293                         if (cmd.contains(',') && cmd.at(0) == '@')
 294                         {
 295                                 if (actionIndex >= 0 && currentActions[actionIndex] != NULL
 296                                         && !currentActions[actionIndex]->isFinished())
 297                                 {
 298                                         int commaPos = cmd.indexOf(',');
 299                                         bool ok1, ok2;
 300                                         double x = RS_Math::eval(cmd.mid(1, commaPos - 1), &ok1);
 301                                         double y = RS_Math::eval(cmd.mid(commaPos + 1), &ok2);
 302
 303                                         if (ok1 && ok2)
 304                                         {
 305 //                                              RS_CoordinateEvent ce(Vector(x,y) + graphicView->getRelativeZero());
 306 //                                              currentActions[actionIndex]->coordinateEvent(&ce);
 307                                                 Vector ce(Vector(x,y) + graphicView->getRelativeZero());
 308                                                 currentActions[actionIndex]->coordinateEvent(&ce);
 309                                         }
 310                                         else
 311                                         {
 312                                                 if (RS_DIALOGFACTORY != NULL)
 313                                                         RS_DIALOGFACTORY->commandMessage("Expression Syntax Error");
 314                                         }
 315
 316                                         e->accept();
 317                                 }
 318                         }
 319                 }
 320
 321                 // handle absolute polar coordinate input:
 322                 if (!e->isAccepted())
 323                 {
 324                         if (cmd.contains('<') && cmd.at(0) != '@')
 325                         {
 326                                 if (actionIndex >= 0 && currentActions[actionIndex] != NULL
 327                                         && !currentActions[actionIndex]->isFinished())
 328                                 {
 329                                         int commaPos = cmd.indexOf('<');
 330                                         bool ok1, ok2;
 331                                         double r = RS_Math::eval(cmd.left(commaPos), &ok1);
 332                                         double a = RS_Math::eval(cmd.mid(commaPos + 1), &ok2);
 333
 334                                         if (ok1 && ok2)
 335                                         {
 336                                                 Vector pos;
 337                                                 pos.setPolar(r,RS_Math::deg2rad(a));
 338 //                                              RS_CoordinateEvent ce(pos);
 339 //                                              currentActions[actionIndex]->coordinateEvent(&ce);
 340                                                 currentActions[actionIndex]->coordinateEvent(&pos);
 341                                         }
 342                                         else
 343                                         {
 344                                                 if (RS_DIALOGFACTORY != NULL)
 345                                                         RS_DIALOGFACTORY->commandMessage("Expression Syntax Error");
 346                                         }
 347
 348                                         e->accept();
 349                                 }
 350                         }
 351                 }
 352
 353                 // handle relative polar coordinate input:
 354                 if (!e->isAccepted())
 355                 {
 356                         if (cmd.contains('<') && cmd.at(0) == '@')
 357                         {
 358                                 if (actionIndex >= 0 && currentActions[actionIndex] !=NULL
 359                                         && !currentActions[actionIndex]->isFinished())
 360                                 {
 361 //                                      int commaPos = cmd.find('<');
 362                                         int commaPos = cmd.indexOf('<');
 363                                         bool ok1, ok2;
 364                                         double r = RS_Math::eval(cmd.mid(1, commaPos - 1), &ok1);
 365                                         double a = RS_Math::eval(cmd.mid(commaPos + 1), &ok2);
 366
 367                                         if (ok1 && ok2)
 368                                         {
 369                                                 Vector pos;
 370                                                 pos.setPolar(r,RS_Math::deg2rad(a));
 371 //                                              RS_CoordinateEvent ce(pos + graphicView->getRelativeZero());
 372 //                                              currentActions[actionIndex]->coordinateEvent(&ce);
 373                                                 Vector ce(pos + graphicView->getRelativeZero());
 374                                                 currentActions[actionIndex]->coordinateEvent(&ce);
 375                                         }
 376                                         else
 377                                         {
 378                                                 if (RS_DIALOGFACTORY != NULL)
 379                                                         RS_DIALOGFACTORY->commandMessage("Expression Syntax Error");
 380                                         }
 381
 382                                         e->accept();
 383                                 }
 384                         }
 385                 }
 386         }
 387
 388         // send command event directly to current action:
 389         if (!e->isAccepted())
 390         {
 391                 if (actionIndex >= 0 && currentActions[actionIndex] != NULL
 392                         && !currentActions[actionIndex]->isFinished())
 393                 {
 394                         currentActions[actionIndex]->commandEvent(e);
 395                         e->accept();
 396                 }
 397                 else
 398                 {
 399                         if (defaultAction != NULL)
 400                                 defaultAction->commandEvent(e);
 401                 }
 402         }
 403
 404         RS_DEBUG->print("RS_EventHandler::commandEvent: OK");
 405 }
 406
 407 /**
 408  * Enables coordinate input in the command line.
 409  */
 410 void RS_EventHandler::enableCoordinateInput()
 411 {
 412         coordinateInputEnabled = true;
 413 }
 414
 415 /**
 416  * Enables coordinate input in the command line.
 417  */
 418 void RS_EventHandler::disableCoordinateInput()
 419 {
 420         coordinateInputEnabled = false;
 421 }
 422
 423 /**
 424  * @return Current action.
 425  */
 426 RS_ActionInterface * RS_EventHandler::getCurrentAction()
 427 {
 428         if (actionIndex >= 0 && currentActions[actionIndex] != NULL
 429                 && !currentActions[actionIndex]->isFinished())
 430                 return currentActions[actionIndex];
 431
 432         return defaultAction;
 433 }
 434
 435 /**
 436  * @return The current default action.
 437  */
 438 RS_ActionInterface * RS_EventHandler::getDefaultAction()
 439 {
 440         return defaultAction;
 441 }
 442
 443 /**
 444  * Sets the default action.
 445  */
 446 void RS_EventHandler::setDefaultAction(RS_ActionInterface * action)
 447 {
 448         if (defaultAction != NULL)
 449         {
 450                 defaultAction->finish();
 451                 delete defaultAction;
 452                 defaultAction = NULL;
 453         }
 454
 455         defaultAction = action;
 456 }
 457
 458 /**
 459  * Sets the current action.
 460  */
 461 void RS_EventHandler::setCurrentAction(RS_ActionInterface * action)
 462 {
 463         RS_DEBUG->print("RS_EventHandler::setCurrentAction");
 464
 465         if (action == NULL)
 466                 return;
 467
 468         // Predecessor of the new action or NULL:
 469         RS_ActionInterface * predecessor = NULL;
 470
 471         // Suspend current action:
 472         if (actionIndex >= 0 && currentActions[actionIndex] != NULL
 473                 && !currentActions[actionIndex]->isFinished())
 474         {
 475                 predecessor = currentActions[actionIndex];
 476                 predecessor->suspend();
 477                 predecessor->hideOptions();
 478         }
 479         else
 480         {
 481                 if (defaultAction != NULL)
 482                 {
 483                         predecessor = defaultAction;
 484                         predecessor->suspend();
 485                         predecessor->hideOptions();
 486                 }
 487         }
 488
 489         // Forget about the oldest action and make space for the new action:
 490         if (actionIndex == RS_MAXACTIONS - 1)
 491         {
 492                 // delete oldest action if necessary (usually never happens):
 493                 if (currentActions[0] != NULL)
 494                 {
 495                         currentActions[0]->finish();
 496                         delete currentActions[0];
 497                         currentActions[0] = NULL;
 498                 }
 499
 500                 // Move up actionstack (optimize):
 501                 for(int i=0; i<RS_MAXACTIONS-1; ++i)
 502                         currentActions[i] = currentActions[i + 1];
 503         }
 504         else if (actionIndex < RS_MAXACTIONS - 1)
 505                 actionIndex++;
 506
 507         // Set current action:
 508         currentActions[actionIndex] = action;
 509         RS_DEBUG->print("RS_EventHandler::setCurrentAction: current action is: %s",
 510                 currentActions[actionIndex]->getName().toLatin1().data());
 511
 512         // Initialisation of our new action:
 513         RS_DEBUG->print("RS_EventHandler::setCurrentAction: init current action");
 514         action->init();
 515
 516         // ## new:
 517         if (action->isFinished() == false)
 518         {
 519                 RS_DEBUG->print("RS_EventHandler::setCurrentAction: show options");
 520                 currentActions[actionIndex]->showOptions();
 521                 RS_DEBUG->print("RS_EventHandler::setCurrentAction: set predecessor");
 522                 action->setPredecessor(predecessor);
 523         }
 524
 525         RS_DEBUG->print("RS_EventHandler::setCurrentAction: cleaning up..");
 526         cleanUp();
 527
 528         RS_DEBUG->print("RS_EventHandler::setCurrentAction: debugging actions");
 529         debugActions();
 530         RS_DEBUG->print("RS_GraphicView::setCurrentAction: OK");
 531 }
 532
 533 /**
 534  * Kills all running selection actions. Called when a selection action
 535  * is launched to reduce confusion.
 536  */
 537 void RS_EventHandler::killSelectActions()
 538 {
 539         for(int c=0; c<RS_MAXACTIONS; ++c)
 540         {
 541                 if (currentActions[c] != NULL)
 542                 {
 543                         if (currentActions[c]->rtti() == RS2::ActionSelectSingle
 544                                 || currentActions[c]->rtti() == RS2::ActionSelectContour
 545                                 || currentActions[c]->rtti() == RS2::ActionSelectWindow
 546                                 || currentActions[c]->rtti() == RS2::ActionSelectIntersected
 547                                 || currentActions[c]->rtti() == RS2::ActionSelectLayer)
 548                                 currentActions[c]->finish();
 549                 }
 550         }
 551 }
 552
 553 /**
 554  * Kills all running actions. Called when a window is closed.
 555  */
 556 void RS_EventHandler::killAllActions()
 557 {
 558         /*
 559     for (int c=0; c<RS_MAXACTIONS; ++c) {
 560         if (currentActions[c]!=NULL) {
 561             currentActions[c]->finish();
 562         }
 563     }
 564     cleanUp();
 565         */
 566 }
 567
 568 /**
 569  * @return true if there is at least one action in the action stack.
 570  */
 571 bool RS_EventHandler::hasAction()
 572 {
 573         if (actionIndex != -1 || defaultAction != NULL)
 574                 return true;
 575
 576         return false;
 577 }
 578
 579 /**
 580  * Garbage collector for actions.
 581  */
 582 void RS_EventHandler::cleanUp()
 583 {
 584         RS_DEBUG->print("RS_EventHandler::cleanUp");
 585
 586         int o = 0;                              // old index
 587         int n = 0;                              // new index
 588         int resume = 0;                 // index of action to resume
 589         bool doResume = false;  // do we need to resume an action
 590         actionIndex = -1;
 591
 592         debugActions();
 593
 594         do
 595         {
 596                 // search first used action (o)
 597                 while (currentActions[o] == NULL && o < RS_MAXACTIONS)
 598                         o++;
 599
 600                 // delete action if it is finished
 601                 if (o < RS_MAXACTIONS && currentActions[o] != NULL
 602                         && currentActions[o]->isFinished())
 603                 {
 604                         delete currentActions[o];
 605                         currentActions[o] = NULL;
 606                         doResume = true;
 607                 }
 608
 609                 // move a running action up in the stack
 610                 if (o < RS_MAXACTIONS && currentActions[o] != NULL)
 611                 {
 612                         if (n != o)
 613                         {
 614                                 currentActions[n] = currentActions[o];
 615                                 resume = n;
 616                                 currentActions[o] = NULL;
 617                         }
 618                         else
 619                         {
 620                                 if (o < RS_MAXACTIONS)
 621                                         o++;
 622                         }
 623
 624                         actionIndex = n;
 625
 626                         if (n < RS_MAXACTIONS - 1)
 627                                 n++;
 628                 }
 629         }
 630         while (o < RS_MAXACTIONS);
 631
 632         debugActions();
 633
 634         // Resume last used action:
 635         if (doResume)
 636         {
 637                 if (currentActions[resume] != NULL && !currentActions[resume]->isFinished())
 638                 {
 639                         currentActions[resume]->resume();
 640                         currentActions[resume]->showOptions();
 641                 }
 642                 else
 643                 {
 644                         if (defaultAction != NULL)
 645                         {
 646                                 defaultAction->resume();
 647                                 defaultAction->showOptions();
 648                         }
 649                 }
 650         }
 651
 652         RS_DEBUG->print("RS_EventHandler::cleanUp: OK");
 653 }
 654
 655 /**
 656  * Sets the snap mode for all currently active actions.
 657  */
 658 void RS_EventHandler::setSnapMode(RS2::SnapMode sm)
 659 {
 660         for(int c=0; c<RS_MAXACTIONS; ++c)
 661                 if (currentActions[c] != NULL)
 662                         currentActions[c]->setSnapMode(sm);
 663
 664         if (defaultAction!=NULL)
 665                 defaultAction->setSnapMode(sm);
 666 }
 667
 668 /**
 669  * Sets the snap restriction for all currently active actions.
 670  */
 671 void RS_EventHandler::setSnapRestriction(RS2::SnapRestriction sr)
 672 {
 673         for(int c=0; c<RS_MAXACTIONS; ++c)
 674                 if (currentActions[c] != NULL)
 675                         currentActions[c]->setSnapRestriction(sr);
 676
 677         if (defaultAction != NULL)
 678                 defaultAction->setSnapRestriction(sr);
 679 }
 680
 681 void RS_EventHandler::debugActions()
 682 {
 683         RS_DEBUG->print("---");
 684
 685         for(int c=0; c<RS_MAXACTIONS; ++c)
 686         {
 687                 if (c == actionIndex)
 688                         RS_DEBUG->print("Current");
 689
 690                 if (currentActions[c] != NULL)
 691                         RS_DEBUG->print("Action %03d: %s [%s]",
 692                                 c, currentActions[c]->getName().toLatin1().data(),
 693                                 currentActions[c]->isFinished() ? "finished" : "active");
 694                 else
 695                         RS_DEBUG->print("Action %03d: NULL", c);
 696         }
 697 }