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

   1 // rs_actioninterface.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/22/2010  Added this text. :-)
  13 //
  14
  15 #include "rs_actioninterface.h"
  16
  17 /**
  18  * Constructor.
  19  *
  20  * Sets the entity container on which the action class inherited
  21  * from this interface operates.
  22  *
  23  * @param name Action name. This can be used internally for
  24  *             debugging mainly.
  25  * @param container Entity container this action operates on.
  26  * @param graphicView Graphic view instance this action operates on.
  27  *                    Please note that an action belongs to this
  28  *                    view.
  29  * @param cursor Default mouse cursor for this action. If the action
  30  *               is suspended and resumed again the cursor will always
  31  *               be reset to the one given here.
  32  */
  33 RS_ActionInterface::RS_ActionInterface(const char * name,
  34         RS_EntityContainer & container, RS_GraphicView & graphicView):
  35         RS_Snapper(container, graphicView)
  36 {
  37         RS_DEBUG->print("RS_ActionInterface::RS_ActionInterface: Setting up action: \"%s\"", name);
  38
  39         this->name = name;
  40         status = 0;
  41         finished = false;
  42         //triggerOnResume = false;
  43
  44         // graphic provides a pointer to the graphic if the
  45         // entity container is a graphic (i.e. can also hold
  46         // layers).
  47         graphic = container.getGraphic();
  48
  49         // document pointer will be used for undo / redo
  50         document = container.getDocument();
  51
  52         //this->cursor = cursor;
  53         //setSnapMode(graphicView.getDefaultSnapMode());
  54
  55         RS_DEBUG->print("RS_ActionInterface::RS_ActionInterface: Setting up action: \"%s\": OK", name);
  56 }
  57
  58 /**
  59  * Destructor.
  60  */
  61 RS_ActionInterface::~RS_ActionInterface()
  62 {
  63 //JLH: Only it isn't pure virtual...
  64         // would be pure virtual now:
  65         // hideOptions();
  66 }
  67
  68 /**
  69  * Must be implemented to return the ID of this action.
  70 *
  71 * @todo no default implementation
  72  */
  73 RS2::ActionType RS_ActionInterface::rtti()
  74 {
  75         return RS2::ActionNone;
  76 }
  77
  78 /**
  79  * @return name of this action
  80  */
  81 QString RS_ActionInterface::getName()
  82 {
  83         return name;
  84 }
  85
  86 /**
  87  * Called to initiate an action. This funtcion is often
  88  * overwritten by the implementing action.
  89  *
  90  * @param status The status on which to initiate this action.
  91  * default is 0 to begin the action.
  92  */
  93 void RS_ActionInterface::init(int status)
  94 {
  95         RS_Snapper::init();
  96         setStatus(status);
  97
  98         if (status >= 0)
  99         {
 100                 //graphicView->setMouseCursor(cursor);
 101                 updateMouseButtonHints();
 102                 updateMouseCursor();
 103                 updateToolBar();
 104         }
 105 }
 106
 107 /**
 108  * Called when the mouse moves and this is the current action.
 109  * This function can be overwritten by the implementing action.
 110  * The default implementation keeps track of the mouse position.
 111  */
 112 void RS_ActionInterface::mouseMoveEvent(QMouseEvent *)
 113 {
 114 }
 115
 116 /**
 117  * Called when the left mouse button is pressed and this is the
 118  * current action.
 119  * This function can be overwritten by the implementing action.
 120  * The default implementation does nothing.
 121  */
 122 void RS_ActionInterface::mousePressEvent(QMouseEvent *)
 123 {
 124 }
 125
 126 /**
 127  * Called when the left mouse button is released and this is
 128  * the current action.
 129  * This function can be overwritten by the implementing action.
 130  * The default implementation does nothing.
 131  */
 132 void RS_ActionInterface::mouseReleaseEvent(QMouseEvent *)
 133 {
 134 }
 135
 136 /**
 137  * Called when a key is pressed and this is the current action.
 138  * This function can be overwritten by the implementing action.
 139  * The default implementation does nothing.
 140  */
 141 void RS_ActionInterface::keyPressEvent(QKeyEvent * e)
 142 {
 143     e->ignore();
 144 }
 145
 146 /**
 147  * Called when a key is released and this is the current action.
 148  * This function can be overwritten by the implementing action.
 149  * The default implementation does nothing.
 150  */
 151 void RS_ActionInterface::keyReleaseEvent(QKeyEvent * e)
 152 {
 153     e->ignore();
 154 }
 155
 156 /**
 157  * Coordinate event. Triggered usually from a command line.
 158  * This function can be overwritten by the implementing action.
 159  * The default implementation does nothing.
 160  */
 161 void RS_ActionInterface::coordinateEvent(RS_CoordinateEvent *)
 162 {
 163 }
 164
 165 /**
 166  * Called when a command from the command line is launched.
 167  * and this is the current action.
 168  * This function can be overwritten by the implementing action.
 169  * The default implementation does nothing.
 170  */
 171 void RS_ActionInterface::commandEvent(RS_CommandEvent *)
 172 {
 173 }
 174
 175 /**
 176  * Must be implemented to return the currently available commands
 177  *  for the command line.
 178  */
 179 QStringList RS_ActionInterface::getAvailableCommands()
 180 {
 181         QStringList l;
 182         return l;
 183 }
 184
 185 /**
 186  * Sets the current status (progress) of this action.
 187  * The default implementation sets the class variable 'status' to the
 188  * given value and finishes the action if 'status' is negative.
 189  *
 190  * @param status Status number. It's up to the action implementor
 191  *               what the action uses the status for. However, a
 192  *               negative status number finishes the action. Usually
 193  *               the status of an action increases for every step
 194  *               of progress and decreases when the user goes one
 195  *               step back (i.e. presses the right mouse button).
 196  */
 197 void RS_ActionInterface::setStatus(int status)
 198 {
 199         this->status = status;
 200
 201         if (status < 0)
 202         {
 203                 finish();
 204                 status = 0;
 205         }
 206
 207         updateMouseButtonHints();
 208         updateToolBar();
 209         updateMouseCursor();
 210 }
 211
 212 /**
 213  * @return Current status of this action.
 214  */
 215 int RS_ActionInterface::getStatus()
 216 {
 217         return status;
 218 }
 219
 220 /**
 221  * Triggers this action. This should be called after all
 222  * data needed for this action was collected / set.
 223  * The default implementation does nothing.
 224  */
 225 void RS_ActionInterface::trigger()
 226 {
 227 }
 228
 229 /**
 230  * Should be overwritten to update the mouse button hints
 231  * wherever they might needed.
 232  */
 233 void RS_ActionInterface::updateMouseButtonHints()
 234 {
 235 }
 236
 237 /**
 238  * Should be overwritten to set the mouse cursor for this action.
 239  */
 240 void RS_ActionInterface::updateMouseCursor()
 241 {
 242 }
 243
 244 /**
 245  * Should be overwritten to set the toolbar for this action.
 246  */
 247 void RS_ActionInterface::updateToolBar()
 248 {
 249 }
 250
 251 /**
 252  * @return true, if the action is finished and can be deleted.
 253  */
 254 bool RS_ActionInterface::isFinished()
 255 {
 256         return finished;
 257 }
 258
 259 /**
 260  * Forces a termination of the action without any cleanup.
 261  */
 262 void RS_ActionInterface::setFinished()
 263 {
 264         status = -1;
 265 }
 266
 267 /**
 268  * Finishes this action.
 269  */
 270 void RS_ActionInterface::finish()
 271 {
 272         RS_DEBUG->print("RS_ActionInterface::finish");
 273         status = -1;
 274         graphicView->setMouseCursor(RS2::ArrowCursor);
 275         //graphicView->requestToolBar(RS2::ToolBarMain);
 276         updateToolBar();
 277 //jlh:  deleteSnapper();
 278         hideOptions();
 279         finished = true;
 280         RS_Snapper::finish();
 281         RS_DEBUG->print("RS_ActionInterface::finish: OK");
 282 }
 283
 284 /**
 285  * Called by the event handler to give this action a chance to
 286  * communicate with its predecessor.
 287  */
 288 void RS_ActionInterface::setPredecessor(RS_ActionInterface * pre)
 289 {
 290         predecessor = pre;
 291 }
 292
 293 /**
 294  * Suspends this action while another action takes place.
 295  */
 296 void RS_ActionInterface::suspend()
 297 {
 298         graphicView->setMouseCursor(RS2::ArrowCursor);
 299         RS_Snapper::suspend();
 300 }
 301
 302 /**
 303  * Resumes an action after it was suspended.
 304  */
 305 void RS_ActionInterface::resume()
 306 {
 307         updateMouseCursor();
 308         updateToolBar();
 309         RS_Snapper::resume();
 310 }
 311
 312 /**
 313  * Hides the tool options. Default implementation does nothing.
 314  */
 315 void RS_ActionInterface::hideOptions()
 316 {
 317         RS_Snapper::hideOptions();
 318 }
 319
 320 /**
 321  * Shows the tool options. Default implementation does nothing.
 322  */
 323 void RS_ActionInterface::showOptions()
 324 {
 325         RS_Snapper::showOptions();
 326 }
 327
 328 /**
 329  * Calls checkCommand() from the RS_COMMANDS module.
 330  */
 331 bool RS_ActionInterface::checkCommand(const QString & cmd, const QString & str,
 332         RS2::ActionType action)
 333 {
 334         return RS_COMMANDS->checkCommand(cmd, str, action);
 335 }
 336
 337 /**
 338  * Calls command() from the RS_COMMANDS module.
 339  */
 340 QString RS_ActionInterface::command(const QString & cmd)
 341 {
 342         return RS_COMMANDS->command(cmd);
 343 }
 344
 345 /**
 346  * Calls msgAvailableCommands() from the RS_COMMANDS module.
 347  */
 348 QString RS_ActionInterface::msgAvailableCommands()
 349 {
 350         return RS_COMMANDS->msgAvailableCommands();
 351 }