kolourpaint/commands/kpCommandHistoryBase.cpp

   1
   2 /*
   3    Copyright (c) 2003-2007 Clarence Dang <dang@kde.org>
   4    All rights reserved.
   5
   6    Redistribution and use in source and binary forms, with or without
   7    modification, are permitted provided that the following conditions
   8    are met:
   9
  10    1. Redistributions of source code must retain the above copyright
  11       notice, this list of conditions and the following disclaimer.
  12    2. Redistributions in binary form must reproduce the above copyright
  13       notice, this list of conditions and the following disclaimer in the
  14       documentation and/or other materials provided with the distribution.
  15
  16    THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  17    IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  18    OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  19    IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  20    INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  21    NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  22    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  23    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  24    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  25    THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26 */
  27
  28
  29 #define DEBUG_KP_COMMAND_HISTORY 0
  30
  31
  32 #include <kpCommandHistoryBase.h>
  33
  34 #include <climits>
  35
  36 #include <qdatetime.h>
  37 #include <qlinkedlist.h>
  38
  39 #include <kapplication.h>
  40 #include <kconfig.h>
  41 #include <kdebug.h>
  42 #include <kglobal.h>
  43 #include <klocale.h>
  44 #include <kmenu.h>
  45 #include <kstandardshortcut.h>
  46 #include <kstandardaction.h>
  47 #include <ktoolbarpopupaction.h>
  48 #include <kactioncollection.h>
  49 #include <kconfiggroup.h>
  50
  51 #include <kpCommand.h>
  52 #include <kpCommandEnvironment.h>
  53 #include <kpDefs.h>
  54 #include <kpDocument.h>
  55 #include <kpMainWindow.h>
  56 #include <kpTool.h>
  57
  58
  59 //template <typename T>
  60 static void ClearPointerList (QLinkedList <kpCommand *> *listPtr)
  61 {
  62     if (!listPtr)
  63         return;
  64
  65     qDeleteAll (listPtr->begin (), listPtr->end ());
  66
  67     listPtr->clear ();
  68 }
  69
  70
  71 struct kpCommandHistoryBasePrivate
  72 {
  73 };
  74
  75
  76 kpCommandHistoryBase::kpCommandHistoryBase (bool doReadConfig,
  77                                             KActionCollection *ac)
  78     : d (new kpCommandHistoryBasePrivate ())
  79 {
  80     m_actionUndo = new KToolBarPopupAction (KIcon ("edit-undo"), undoActionText (), this);
  81     ac->addAction (KStandardAction::name (KStandardAction::Undo), m_actionUndo);
  82     m_actionUndo->setShortcuts (KStandardShortcut::shortcut (KStandardShortcut::Undo));
  83     connect (m_actionUndo, SIGNAL(triggered(bool)), this, SLOT (undo ()));
  84
  85     m_actionRedo = new KToolBarPopupAction (KIcon ("edit-redo"), redoActionText (), this);
  86     ac->addAction (KStandardAction::name (KStandardAction::Redo), m_actionRedo);
  87     m_actionRedo->setShortcuts (KStandardShortcut::shortcut (KStandardShortcut::Redo));
  88     connect (m_actionRedo, SIGNAL(triggered(bool)), this, SLOT (redo ()));
  89
  90
  91     m_actionUndo->setEnabled (false);
  92     m_actionRedo->setEnabled (false);
  93
  94
  95     connect (m_actionUndo->menu (), SIGNAL (triggered (QAction *)),
  96              this, SLOT (undoUpToNumber (QAction *)));
  97     connect (m_actionRedo->menu (), SIGNAL (triggered (QAction *)),
  98              this, SLOT (redoUpToNumber (QAction *)));
  99
 100
 101     m_undoMinLimit = 10;
 102     m_undoMaxLimit = 500;
 103     m_undoMaxLimitSizeLimit = 16 * 1048576;
 104
 105
 106     m_documentRestoredPosition = 0;
 107
 108
 109     if (doReadConfig)
 110         readConfig ();
 111 }
 112
 113 kpCommandHistoryBase::~kpCommandHistoryBase ()
 114 {
 115     ::ClearPointerList (&m_undoCommandList);
 116     ::ClearPointerList (&m_redoCommandList);
 117
 118     delete d;
 119 }
 120
 121
 122 // public
 123 int kpCommandHistoryBase::undoLimit () const
 124 {
 125     return undoMinLimit ();
 126 }
 127
 128 // public
 129 void kpCommandHistoryBase::setUndoLimit (int limit)
 130 {
 131     setUndoMinLimit (limit);
 132 }
 133
 134
 135 // public
 136 int kpCommandHistoryBase::undoMinLimit () const
 137 {
 138     return m_undoMinLimit;
 139 }
 140
 141 // public
 142 void kpCommandHistoryBase::setUndoMinLimit (int limit)
 143 {
 144 #if DEBUG_KP_COMMAND_HISTORY
 145     kDebug () << "kpCommandHistoryBase::setUndoMinLimit("
 146                << limit << ")"
 147                << endl;
 148 #endif
 149
 150     if (limit < 1 || limit > 5000/*"ought to be enough for anybody"*/)
 151     {
 152         kError () << "kpCommandHistoryBase::setUndoMinLimit("
 153                    << limit << ")"
 154                    << endl;
 155         return;
 156     }
 157
 158     if (limit == m_undoMinLimit)
 159         return;
 160
 161     m_undoMinLimit = limit;
 162     trimCommandListsUpdateActions ();
 163 }
 164
 165
 166 // public
 167 int kpCommandHistoryBase::undoMaxLimit () const
 168 {
 169     return m_undoMaxLimit;
 170 }
 171
 172 // public
 173 void kpCommandHistoryBase::setUndoMaxLimit (int limit)
 174 {
 175 #if DEBUG_KP_COMMAND_HISTORY
 176     kDebug () << "kpCommandHistoryBase::setUndoMaxLimit("
 177                << limit << ")"
 178                << endl;
 179 #endif
 180
 181     if (limit < 1 || limit > 5000/*"ought to be enough for anybody"*/)
 182     {
 183         kError () << "kpCommandHistoryBase::setUndoMaxLimit("
 184                    << limit << ")"
 185                    << endl;
 186         return;
 187     }
 188
 189     if (limit == m_undoMaxLimit)
 190         return;
 191
 192     m_undoMaxLimit = limit;
 193     trimCommandListsUpdateActions ();
 194 }
 195
 196
 197 // public
 198 kpCommandSize::SizeType kpCommandHistoryBase::undoMaxLimitSizeLimit () const
 199 {
 200     return m_undoMaxLimitSizeLimit;
 201 }
 202
 203 // public
 204 void kpCommandHistoryBase::setUndoMaxLimitSizeLimit (kpCommandSize::SizeType sizeLimit)
 205 {
 206 #if DEBUG_KP_COMMAND_HISTORY
 207     kDebug () << "kpCommandHistoryBase::setUndoMaxLimitSizeLimit("
 208                << sizeLimit << ")"
 209                << endl;
 210 #endif
 211
 212     if (sizeLimit < 0 ||
 213         sizeLimit > (500 * 1048576)/*"ought to be enough for anybody"*/)
 214     {
 215         kError () << "kpCommandHistoryBase::setUndoMaxLimitSizeLimit("
 216                    << sizeLimit << ")"
 217                    << endl;
 218         return;
 219     }
 220
 221     if (sizeLimit == m_undoMaxLimitSizeLimit)
 222         return;
 223
 224     m_undoMaxLimitSizeLimit = sizeLimit;
 225     trimCommandListsUpdateActions ();
 226 }
 227
 228
 229 // public
 230 void kpCommandHistoryBase::readConfig ()
 231 {
 232 #if DEBUG_KP_COMMAND_HISTORY
 233     kDebug () << "kpCommandHistoryBase::readConfig()";
 234 #endif
 235     KConfigGroup cfg (KGlobal::config (), kpSettingsGroupUndoRedo);
 236
 237     setUndoMinLimit (cfg.readEntry (kpSettingUndoMinLimit, undoMinLimit ()));
 238     setUndoMaxLimit (cfg.readEntry (kpSettingUndoMaxLimit, undoMaxLimit ()));
 239     setUndoMaxLimitSizeLimit (
 240         cfg.readEntry <kpCommandSize::SizeType> (kpSettingUndoMaxLimitSizeLimit,
 241                                                  undoMaxLimitSizeLimit ()));
 242
 243     trimCommandListsUpdateActions ();
 244 }
 245
 246 // public
 247 void kpCommandHistoryBase::writeConfig ()
 248 {
 249 #if DEBUG_KP_COMMAND_HISTORY
 250     kDebug () << "kpCommandHistoryBase::writeConfig()";
 251 #endif
 252     KConfigGroup cfg (KGlobal::config (), kpSettingsGroupUndoRedo);
 253
 254     cfg.writeEntry (kpSettingUndoMinLimit, undoMinLimit ());
 255     cfg.writeEntry (kpSettingUndoMaxLimit, undoMaxLimit ());
 256     cfg.writeEntry <kpCommandSize::SizeType> (
 257         kpSettingUndoMaxLimitSizeLimit, undoMaxLimitSizeLimit ());
 258
 259     cfg.sync ();
 260 }
 261
 262
 263 // public
 264 void kpCommandHistoryBase::addCommand (kpCommand *command, bool execute)
 265 {
 266 #if DEBUG_KP_COMMAND_HISTORY
 267     kDebug () << "kpCommandHistoryBase::addCommand("
 268                << command
 269                << ",execute=" << execute << ")"
 270                << endl;
 271 #endif
 272
 273     if (execute)
 274         command->execute ();
 275
 276     m_undoCommandList.push_front (command);
 277     ::ClearPointerList (&m_redoCommandList);
 278
 279 #if DEBUG_KP_COMMAND_HISTORY
 280     kDebug () << "\tdocumentRestoredPosition=" << m_documentRestoredPosition
 281                << endl;
 282 #endif
 283     if (m_documentRestoredPosition != INT_MAX)
 284     {
 285         if (m_documentRestoredPosition > 0)
 286             m_documentRestoredPosition = INT_MAX;
 287         else
 288             m_documentRestoredPosition--;
 289     #if DEBUG_KP_COMMAND_HISTORY
 290         kDebug () << "\t\tdocumentRestoredPosition=" << m_documentRestoredPosition
 291                 << endl;
 292     #endif
 293     }
 294
 295     trimCommandListsUpdateActions ();
 296 }
 297
 298 // public
 299 void kpCommandHistoryBase::clear ()
 300 {
 301 #if DEBUG_KP_COMMAND_HISTORY
 302     kDebug () << "kpCommandHistoryBase::clear()";
 303 #endif
 304
 305     ::ClearPointerList (&m_undoCommandList);
 306     ::ClearPointerList (&m_redoCommandList);
 307
 308     m_documentRestoredPosition = 0;
 309
 310     updateActions ();
 311 }
 312
 313
 314 // protected slot
 315 void kpCommandHistoryBase::undoInternal ()
 316 {
 317 #if DEBUG_KP_COMMAND_HISTORY
 318     kDebug () << "kpCommandHistoryBase::undoInternal()";
 319 #endif
 320
 321     kpCommand *undoCommand = nextUndoCommand ();
 322     if (!undoCommand)
 323         return;
 324
 325     undoCommand->unexecute ();
 326
 327
 328     m_undoCommandList.erase (m_undoCommandList.begin ());
 329     m_redoCommandList.push_front (undoCommand);
 330
 331
 332 #if DEBUG_KP_COMMAND_HISTORY
 333     kDebug () << "\tdocumentRestoredPosition=" << m_documentRestoredPosition
 334                << endl;
 335 #endif
 336     if (m_documentRestoredPosition != INT_MAX)
 337     {
 338         m_documentRestoredPosition++;
 339         if (m_documentRestoredPosition == 0)
 340             emit documentRestored ();
 341     #if DEBUG_KP_COMMAND_HISTORY
 342         kDebug () << "\t\tdocumentRestoredPosition=" << m_documentRestoredPosition
 343                    << endl;
 344     #endif
 345     }
 346 }
 347
 348 // protected slot
 349 void kpCommandHistoryBase::redoInternal ()
 350 {
 351 #if DEBUG_KP_COMMAND_HISTORY
 352     kDebug () << "kpCommandHistoryBase::redoInternal()";
 353 #endif
 354
 355     kpCommand *redoCommand = nextRedoCommand ();
 356     if (!redoCommand)
 357         return;
 358
 359     redoCommand->execute ();
 360
 361
 362     m_redoCommandList.erase (m_redoCommandList.begin ());
 363     m_undoCommandList.push_front (redoCommand);
 364
 365
 366 #if DEBUG_KP_COMMAND_HISTORY
 367     kDebug () << "\tdocumentRestoredPosition=" << m_documentRestoredPosition
 368                << endl;
 369 #endif
 370     if (m_documentRestoredPosition != INT_MAX)
 371     {
 372         m_documentRestoredPosition--;
 373         if (m_documentRestoredPosition == 0)
 374             emit documentRestored ();
 375     #if DEBUG_KP_COMMAND_HISTORY
 376         kDebug () << "\t\tdocumentRestoredPosition=" << m_documentRestoredPosition
 377                    << endl;
 378     #endif
 379     }
 380 }
 381
 382
 383 // public slot virtual
 384 void kpCommandHistoryBase::undo ()
 385 {
 386 #if DEBUG_KP_COMMAND_HISTORY
 387     kDebug () << "kpCommandHistoryBase::undo()";
 388 #endif
 389
 390     undoInternal ();
 391     trimCommandListsUpdateActions ();
 392 }
 393
 394 // public slot virtual
 395 void kpCommandHistoryBase::redo ()
 396 {
 397 #if DEBUG_KP_COMMAND_HISTORY
 398     kDebug () << "kpCommandHistoryBase::redo()";
 399 #endif
 400
 401     redoInternal ();
 402     trimCommandListsUpdateActions ();
 403 }
 404
 405
 406 // public slot virtual
 407 void kpCommandHistoryBase::undoUpToNumber (QAction *which)
 408 {
 409 #if DEBUG_KP_COMMAND_HISTORY
 410     kDebug () << "kpCommandHistoryBase::undoUpToNumber(" << which << ")";
 411 #endif
 412
 413     for (int i = 0;
 414          i <= which->data().toInt() && !m_undoCommandList.isEmpty ();
 415          i++)
 416     {
 417         undoInternal ();
 418     }
 419
 420     trimCommandListsUpdateActions ();
 421 }
 422
 423 // public slot virtual
 424 void kpCommandHistoryBase::redoUpToNumber (QAction *which)
 425 {
 426 #if DEBUG_KP_COMMAND_HISTORY
 427     kDebug () << "kpCommandHistoryBase::redoUpToNumber(" << which << ")";
 428 #endif
 429
 430     for (int i = 0;
 431          i <= which->data().toInt() && !m_redoCommandList.isEmpty ();
 432          i++)
 433     {
 434         redoInternal ();
 435     }
 436
 437     trimCommandListsUpdateActions ();
 438 }
 439
 440
 441 // protected
 442 QString kpCommandHistoryBase::undoActionText () const
 443 {
 444     kpCommand *undoCommand = nextUndoCommand ();
 445
 446     if (undoCommand)
 447         return i18n ("&Undo: %1", undoCommand->name ());
 448     else
 449         return i18n ("&Undo");
 450 }
 451
 452 // protected
 453 QString kpCommandHistoryBase::redoActionText () const
 454 {
 455     kpCommand *redoCommand = nextRedoCommand ();
 456
 457     if (redoCommand)
 458         return i18n ("&Redo: %1", redoCommand->name ());
 459     else
 460         return i18n ("&Redo");
 461 }
 462
 463
 464 // protected
 465 QString kpCommandHistoryBase::undoActionToolTip () const
 466 {
 467     kpCommand *undoCommand = nextUndoCommand ();
 468
 469     if (undoCommand)
 470         return i18n ("Undo: %1", undoCommand->name ());
 471     else
 472         return i18n ("Undo");
 473 }
 474
 475 // protected
 476 QString kpCommandHistoryBase::redoActionToolTip () const
 477 {
 478     kpCommand *redoCommand = nextRedoCommand ();
 479
 480     if (redoCommand)
 481         return i18n ("Redo: %1", redoCommand->name ());
 482     else
 483         return i18n ("Redo");
 484 }
 485
 486
 487 // protected
 488 void kpCommandHistoryBase::trimCommandListsUpdateActions ()
 489 {
 490 #if DEBUG_KP_COMMAND_HISTORY
 491     kDebug () << "kpCommandHistoryBase::trimCommandListsUpdateActions()";
 492 #endif
 493
 494     trimCommandLists ();
 495     updateActions ();
 496 }
 497
 498 // protected
 499 void kpCommandHistoryBase::trimCommandList (QLinkedList <kpCommand *> *commandList)
 500 {
 501 #if DEBUG_KP_COMMAND_HISTORY
 502     kDebug () << "kpCommandHistoryBase::trimCommandList()";
 503     QTime timer; timer.start ();
 504 #endif
 505
 506     if (!commandList)
 507     {
 508         kError () << "kpCommandHistoryBase::trimCommandList() passed 0 commandList"
 509                    << endl;
 510         return;
 511     }
 512
 513
 514 #if DEBUG_KP_COMMAND_HISTORY
 515     kDebug () << "\tsize=" << commandList->size ()
 516                << "    undoMinLimit=" << m_undoMinLimit
 517                << " undoMaxLimit=" << m_undoMaxLimit
 518                << " undoMaxLimitSizeLimit=" << m_undoMaxLimitSizeLimit
 519                << endl;
 520 #endif
 521     if ((int) commandList->size () <= m_undoMinLimit)
 522     {
 523     #if DEBUG_KP_COMMAND_HISTORY
 524         kDebug () << "\t\tsize under undoMinLimit - done";
 525     #endif
 526         return;
 527     }
 528
 529
 530 #if DEBUG_KP_COMMAND_HISTORY && 0
 531     kDebug () << "\tsize over undoMinLimit - iterating thru cmds:";
 532 #endif
 533
 534     QLinkedList <kpCommand *>::iterator it = commandList->begin ();
 535     int upto = 0;
 536
 537     kpCommandSize::SizeType sizeSoFar = 0;
 538
 539     while (it != commandList->end ())
 540     {
 541         bool advanceIt = true;
 542
 543         if (sizeSoFar <= m_undoMaxLimitSizeLimit)
 544         {
 545             sizeSoFar += (*it)->size ();
 546         }
 547
 548     #if DEBUG_KP_COMMAND_HISTORY && 0
 549         kDebug () << "\t\t" << upto << ":"
 550                    << " name='" << (*it)->name ()
 551                    << "' size=" << (*it)->size ()
 552                    << "    sizeSoFar=" << sizeSoFar
 553                    << endl;
 554     #endif
 555
 556         if (upto >= m_undoMinLimit)
 557         {
 558             if (upto >= m_undoMaxLimit ||
 559                 sizeSoFar > m_undoMaxLimitSizeLimit)
 560             {
 561             #if DEBUG_KP_COMMAND_HISTORY && 0
 562                 kDebug () << "\t\t\tkill";
 563             #endif
 564                 delete (*it);
 565                 it = m_undoCommandList.erase (it);
 566                 advanceIt = false;
 567             }
 568         }
 569
 570         if (advanceIt)
 571             it++;
 572         upto++;
 573     }
 574
 575 #if DEBUG_KP_COMMAND_HISTORY
 576     kDebug () << "\ttook " << timer.elapsed () << "ms";
 577 #endif
 578 }
 579
 580 // protected
 581 void kpCommandHistoryBase::trimCommandLists ()
 582 {
 583 #if DEBUG_KP_COMMAND_HISTORY
 584     kDebug () << "kpCommandHistoryBase::trimCommandLists()";
 585 #endif
 586
 587     trimCommandList (&m_undoCommandList);
 588     trimCommandList (&m_redoCommandList);
 589
 590 #if DEBUG_KP_COMMAND_HISTORY
 591     kDebug () << "\tdocumentRestoredPosition=" << m_documentRestoredPosition
 592                << endl;
 593 #endif
 594     if (m_documentRestoredPosition != INT_MAX)
 595     {
 596     #if DEBUG_KP_COMMAND_HISTORY
 597         kDebug () << "\t\tundoCmdList.size=" << m_undoCommandList.size ()
 598                    << " redoCmdList.size=" << m_redoCommandList.size ()
 599                    << endl;
 600     #endif
 601         if (m_documentRestoredPosition > (int) m_redoCommandList.size () ||
 602             -m_documentRestoredPosition > (int) m_undoCommandList.size ())
 603         {
 604         #if DEBUG_KP_COMMAND_HISTORY
 605             kDebug () << "\t\t\tinvalidate documentRestoredPosition";
 606         #endif
 607             m_documentRestoredPosition = INT_MAX;
 608         }
 609     }
 610 }
 611
 612
 613 static void populatePopupMenu (KMenu *popupMenu,
 614                                const QString &undoOrRedo,
 615                                const QLinkedList <kpCommand *> &commandList)
 616 {
 617     if (!popupMenu)
 618         return;
 619
 620     popupMenu->clear ();
 621
 622     QLinkedList <kpCommand *>::const_iterator it = commandList.begin ();
 623     int i = 0;
 624     while (i < 10 && it != commandList.end ())
 625     {
 626         QAction *action = new QAction(i18n ("%1: %2", undoOrRedo, (*it)->name ()), popupMenu);
 627         action->setData(i);
 628         popupMenu->addAction (action);
 629         i++, it++;
 630     }
 631
 632     if (it != commandList.end ())
 633     {
 634         // TODO: maybe have a scrollview show all the items instead, like KOffice in KDE 3
 635         // LOCOMPAT: should be centered text.
 636         popupMenu->addTitle (i18np ("%1 more item", "%1 more items",
 637                                     commandList.size () - i));
 638     }
 639 }
 640
 641
 642 // protected
 643 void kpCommandHistoryBase::updateActions ()
 644 {
 645 #if DEBUG_KP_COMMAND_HISTORY
 646     kDebug () << "kpCommandHistoryBase::updateActions()";
 647 #endif
 648
 649     m_actionUndo->setEnabled ((bool) nextUndoCommand ());
 650     // Don't want to keep changing toolbar text.
 651     // TODO: As a bad side-effect, the menu doesn't have "Undo: <action>"
 652     //       anymore.  In any case, the KDE4 KToolBarPopupAction
 653     //       sucks in menus as it forces the clicking of a submenu.  IMO,
 654     //       there should be no submenu in the menu.
 655     //m_actionUndo->setText (undoActionText ());
 656
 657     // But in icon mode, a tooltip with context is useful.
 658     m_actionUndo->setToolTip (undoActionToolTip ());
 659 #if DEBUG_KP_COMMAND_HISTORY
 660     QTime timer; timer.start ();
 661 #endif
 662     populatePopupMenu (qobject_cast<KMenu*> (m_actionUndo->menu ()),
 663                        i18n ("Undo"),
 664                        m_undoCommandList);
 665 #if DEBUG_KP_COMMAND_HISTORY
 666     kDebug () << "\tpopuplatePopupMenu undo=" << timer.elapsed ()
 667                << "ms" << endl;;
 668 #endif
 669
 670     m_actionRedo->setEnabled ((bool) nextRedoCommand ());
 671     // Don't want to keep changing toolbar text.
 672     // TODO: As a bad side-effect, the menu doesn't have "Undo: <action>"
 673     //       anymore.  In any case, the KDE4 KToolBarPopupAction
 674     //       sucks in menus as it forces the clicking of a submenu.  IMO,
 675     //       there should be no submenu in the menu.
 676     //m_actionRedo->setText (redoActionText ());
 677
 678     // But in icon mode, a tooltip with context is useful.
 679     m_actionRedo->setToolTip (redoActionToolTip ());
 680 #if DEBUG_KP_COMMAND_HISTORY
 681     timer.restart ();
 682 #endif
 683     populatePopupMenu (qobject_cast<KMenu*> (m_actionRedo->menu ()),
 684                        i18n ("Redo"),
 685                        m_redoCommandList);
 686 #if DEBUG_KP_COMMAND_HISTORY
 687     kDebug () << "\tpopuplatePopupMenu redo=" << timer.elapsed ()
 688                << "ms" << endl;
 689 #endif
 690 }
 691
 692
 693 // public
 694 kpCommand *kpCommandHistoryBase::nextUndoCommand () const
 695 {
 696     if (m_undoCommandList.isEmpty ())
 697         return 0;
 698
 699     return m_undoCommandList.first ();
 700 }
 701
 702 // public
 703 kpCommand *kpCommandHistoryBase::nextRedoCommand () const
 704 {
 705     if (m_redoCommandList.isEmpty ())
 706         return 0;
 707
 708     return m_redoCommandList.first ();
 709 }
 710
 711
 712 // public
 713 void kpCommandHistoryBase::setNextUndoCommand (kpCommand *command)
 714 {
 715 #if DEBUG_KP_COMMAND_HISTORY
 716     kDebug () << "kpCommandHistoryBase::setNextUndoCommand("
 717                << command
 718                << ")"
 719                << endl;
 720 #endif
 721
 722     if (m_undoCommandList.isEmpty ())
 723         return;
 724
 725
 726     delete *m_undoCommandList.begin ();
 727     *m_undoCommandList.begin () = command;
 728
 729
 730     trimCommandListsUpdateActions ();
 731 }
 732
 733
 734 // public slot virtual
 735 void kpCommandHistoryBase::documentSaved ()
 736 {
 737 #if DEBUG_KP_COMMAND_HISTORY
 738     kDebug () << "kpCommandHistoryBase::documentSaved()";
 739 #endif
 740
 741     m_documentRestoredPosition = 0;
 742 }
 743
 744
 745 #include <kpCommandHistoryBase.moc>