comparison main/MainWindow.cpp @ 162:9c9bce6440f5

* Add key reference window to Help menu (also needs mouse reference)

 #include "widgets/AudioDial.h"
 #include "widgets/LayerTree.h"
 #include "widgets/ListInputDialog.h"
 #include "widgets/SubdividingMenu.h"
 #include "widgets/NotifyingPushButton.h"
+#include "widgets/KeyReference.h"
 #include "audioio/AudioCallbackPlaySource.h"
 #include "audioio/AudioCallbackPlayTarget.h"
 #include "audioio/AudioTargetFactory.h"
 #include "audioio/PlaySpeedRangeMapper.h"
 #include "data/fileio/AudioFileReaderFactory.h"

     m_ffwdAction(0),
     m_rwdAction(0),
     m_documentModified(false),
     m_openingAudioFile(false),
     m_abandoning(false),
-    m_preferencesDialog(0)
+    m_preferencesDialog(0),
+    m_keyReference(new KeyReference())
 {
     setWindowTitle(tr("Sonic Visualiser"));
 
     UnitDatabase::getInstance()->registerUnit("Hz");
     UnitDatabase::getInstance()->registerUnit("dB");

     }
     delete m_playTarget;
     delete m_playSource;
     delete m_viewManager;
     delete m_oscQueue;
+    delete m_keyReference;
     Profiles::getInstance()->dump();
 }
 
 QString
 MainWindow::getOpenFileName(FileFinder::FileType type)

 
     QMenu *menu = menuBar()->addMenu(tr("&File"));
     menu->setTearOffEnabled(true);
     QToolBar *toolbar = addToolBar(tr("File Toolbar"));
 
+    m_keyReference->setCategory(tr("File and Session Management"));
+
     QIcon icon(":icons/filenew.png");
     icon.addFile(":icons/filenew-22.png");
     QAction *action = new QAction(icon, tr("&New Session"), this);
     action->setShortcut(tr("Ctrl+N"));
     action->setStatusTip(tr("Abandon the current Sonic Visualiser session and start a new one"));
     connect(action, SIGNAL(triggered()), this, SLOT(newSession()));
+    m_keyReference->registerShortcut(action);
     menu->addAction(action);
     toolbar->addAction(action);
 
     icon = QIcon(":icons/fileopensession.png");
     action = new QAction(icon, tr("&Open Session..."), this);
     action->setShortcut(tr("Ctrl+O"));
     action->setStatusTip(tr("Open a previously saved Sonic Visualiser session file"));
     connect(action, SIGNAL(triggered()), this, SLOT(openSession()));
+    m_keyReference->registerShortcut(action);
     menu->addAction(action);
 
     icon = QIcon(":icons/fileopen.png");
     icon.addFile(":icons/fileopen-22.png");
 

     action = new QAction(icon, tr("&Save Session"), this);
     action->setShortcut(tr("Ctrl+S"));
     action->setStatusTip(tr("Save the current session into a Sonic Visualiser session file"));
     connect(action, SIGNAL(triggered()), this, SLOT(saveSession()));
     connect(this, SIGNAL(canSave(bool)), action, SLOT(setEnabled(bool)));
+    m_keyReference->registerShortcut(action);
     menu->addAction(action);
     toolbar->addAction(action);
 	
     icon = QIcon(":icons/filesaveas.png");
     icon.addFile(":icons/filesaveas-22.png");

     icon = QIcon(":icons/fileopenaudio.png");
     action = new QAction(icon, tr("&Import Audio File..."), this);
     action->setShortcut(tr("Ctrl+I"));
     action->setStatusTip(tr("Import an existing audio file"));
     connect(action, SIGNAL(triggered()), this, SLOT(importAudio()));
+    m_keyReference->registerShortcut(action);
     menu->addAction(action);
 
     action = new QAction(tr("Import Secondary Audio File..."), this);
     action->setShortcut(tr("Ctrl+Shift+I"));
     action->setStatusTip(tr("Import an extra audio file as a separate layer"));
     connect(action, SIGNAL(triggered()), this, SLOT(importMoreAudio()));
     connect(this, SIGNAL(canImportMoreAudio(bool)), action, SLOT(setEnabled(bool)));
+    m_keyReference->registerShortcut(action);
     menu->addAction(action);
 
     action = new QAction(tr("&Export Audio File..."), this);
     action->setStatusTip(tr("Export selection as an audio file"));
     connect(action, SIGNAL(triggered()), this, SLOT(exportAudio()));

     action = new QAction(tr("Import Annotation &Layer..."), this);
     action->setShortcut(tr("Ctrl+L"));
     action->setStatusTip(tr("Import layer data from an existing file"));
     connect(action, SIGNAL(triggered()), this, SLOT(importLayer()));
     connect(this, SIGNAL(canImportLayer(bool)), action, SLOT(setEnabled(bool)));
+    m_keyReference->registerShortcut(action);
     menu->addAction(action);
 
     action = new QAction(tr("Export Annotation Layer..."), this);
     action->setStatusTip(tr("Export layer data to a file"));
     connect(action, SIGNAL(triggered()), this, SLOT(exportLayer()));

 
     action = new QAction(tr("Open Lo&cation..."), this);
     action->setShortcut(tr("Ctrl+Shift+O"));
     action->setStatusTip(tr("Open or import a file from a remote URL"));
     connect(action, SIGNAL(triggered()), this, SLOT(openLocation()));
+    m_keyReference->registerShortcut(action);
     menu->addAction(action);
 
     menu->addSeparator();
 
     m_recentFilesMenu = menu->addMenu(tr("&Recent Files"));

     action = new QAction(QIcon(":/icons/exit.png"),
                          tr("&Quit"), this);
     action->setShortcut(tr("Ctrl+Q"));
     action->setStatusTip(tr("Exit Sonic Visualiser"));
     connect(action, SIGNAL(triggered()), this, SLOT(close()));
+    m_keyReference->registerShortcut(action);
     menu->addAction(action);
 }
 
 void
 MainWindow::setupEditMenu()

     if (m_mainMenusCreated) return;
 
     QMenu *menu = menuBar()->addMenu(tr("&Edit"));
     menu->setTearOffEnabled(true);
     CommandHistory::getInstance()->registerMenu(menu);
+
+    m_keyReference->setCategory(tr("Editing"));
 
     menu->addSeparator();
 
     QAction *action = new QAction(QIcon(":/icons/editcut.png"),
                                   tr("Cu&t"), this);
     action->setShortcut(tr("Ctrl+X"));
     action->setStatusTip(tr("Cut the selection from the current layer to the clipboard"));
     connect(action, SIGNAL(triggered()), this, SLOT(cut()));
     connect(this, SIGNAL(canEditSelection(bool)), action, SLOT(setEnabled(bool)));
+    m_keyReference->registerShortcut(action);
     menu->addAction(action);
     m_rightButtonMenu->addAction(action);
 
     action = new QAction(QIcon(":/icons/editcopy.png"),
                          tr("&Copy"), this);
     action->setShortcut(tr("Ctrl+C"));
     action->setStatusTip(tr("Copy the selection from the current layer to the clipboard"));
     connect(action, SIGNAL(triggered()), this, SLOT(copy()));
     connect(this, SIGNAL(canEditSelection(bool)), action, SLOT(setEnabled(bool)));
+    m_keyReference->registerShortcut(action);
     menu->addAction(action);
     m_rightButtonMenu->addAction(action);
 
     action = new QAction(QIcon(":/icons/editpaste.png"),
                          tr("&Paste"), this);
     action->setShortcut(tr("Ctrl+V"));
     action->setStatusTip(tr("Paste from the clipboard to the current layer"));
     connect(action, SIGNAL(triggered()), this, SLOT(paste()));
     connect(this, SIGNAL(canPaste(bool)), action, SLOT(setEnabled(bool)));
+    m_keyReference->registerShortcut(action);
     menu->addAction(action);
     m_rightButtonMenu->addAction(action);
 
     action = new QAction(tr("&Delete Selected Items"), this);
     action->setShortcut(tr("Del"));
     action->setStatusTip(tr("Delete the selection from the current layer"));
     connect(action, SIGNAL(triggered()), this, SLOT(deleteSelected()));
     connect(this, SIGNAL(canEditSelection(bool)), action, SLOT(setEnabled(bool)));
+    m_keyReference->registerShortcut(action);
     menu->addAction(action);
     m_rightButtonMenu->addAction(action);
 
     menu->addSeparator();
     m_rightButtonMenu->addSeparator();
-	
+
+    m_keyReference->setCategory(tr("Selection"));
+
     action = new QAction(tr("Select &All"), this);
     action->setShortcut(tr("Ctrl+A"));
     action->setStatusTip(tr("Select the whole duration of the current session"));
     connect(action, SIGNAL(triggered()), this, SLOT(selectAll()));
     connect(this, SIGNAL(canSelect(bool)), action, SLOT(setEnabled(bool)));
+    m_keyReference->registerShortcut(action);
     menu->addAction(action);
     m_rightButtonMenu->addAction(action);
 	
     action = new QAction(tr("Select &Visible Range"), this);
     action->setShortcut(tr("Ctrl+Shift+A"));
     action->setStatusTip(tr("Select the time range corresponding to the current window width"));
     connect(action, SIGNAL(triggered()), this, SLOT(selectVisible()));
     connect(this, SIGNAL(canSelect(bool)), action, SLOT(setEnabled(bool)));
+    m_keyReference->registerShortcut(action);
     menu->addAction(action);
 	
     action = new QAction(tr("Select to &Start"), this);
     action->setShortcut(tr("Shift+Left"));
     action->setStatusTip(tr("Select from the start of the session to the current playback position"));
     connect(action, SIGNAL(triggered()), this, SLOT(selectToStart()));
     connect(this, SIGNAL(canSelect(bool)), action, SLOT(setEnabled(bool)));
+    m_keyReference->registerShortcut(action);
     menu->addAction(action);
 	
     action = new QAction(tr("Select to &End"), this);
     action->setShortcut(tr("Shift+Right"));
     action->setStatusTip(tr("Select from the current playback position to the end of the session"));
     connect(action, SIGNAL(triggered()), this, SLOT(selectToEnd()));
     connect(this, SIGNAL(canSelect(bool)), action, SLOT(setEnabled(bool)));
+    m_keyReference->registerShortcut(action);
     menu->addAction(action);
 
     action = new QAction(tr("C&lear Selection"), this);
     action->setShortcut(tr("Esc"));
     action->setStatusTip(tr("Clear the selection"));
     connect(action, SIGNAL(triggered()), this, SLOT(clearSelection()));
     connect(this, SIGNAL(canClearSelection(bool)), action, SLOT(setEnabled(bool)));
+    m_keyReference->registerShortcut(action);
     menu->addAction(action);
     m_rightButtonMenu->addAction(action);
 
     menu->addSeparator();
+
+    m_keyReference->setCategory(tr("Tapping Time Instants"));
 
     action = new QAction(tr("&Insert Instant at Playback Position"), this);
     action->setShortcut(tr("Enter"));
     action->setStatusTip(tr("Insert a new time instant at the current playback position, in a new layer if necessary"));
     connect(action, SIGNAL(triggered()), this, SLOT(insertInstant()));
     connect(this, SIGNAL(canInsertInstant(bool)), action, SLOT(setEnabled(bool)));
+    m_keyReference->registerShortcut(action);
     menu->addAction(action);
+
+    // Laptop shortcut (no keypad Enter key)
+    QString shortcut(tr(";"));
+    connect(new QShortcut(shortcut, this), SIGNAL(activated()),
+            this, SLOT(insertInstant()));
+    m_keyReference->registerAlternativeShortcut(action, shortcut);
 
     action = new QAction(tr("Insert Instants at Selection &Boundaries"), this);
     action->setShortcut(tr("Shift+Enter"));
     action->setStatusTip(tr("Insert new time instants at the start and end of the current selection, in a new layer if necessary"));
     connect(action, SIGNAL(triggered()), this, SLOT(insertInstantsAtBoundaries()));
     connect(this, SIGNAL(canInsertInstantsAtBoundaries(bool)), action, SLOT(setEnabled(bool)));
+    m_keyReference->registerShortcut(action);
     menu->addAction(action);
-
-    // Laptop shortcut (no keypad Enter key)
-    connect(new QShortcut(tr(";"), this), SIGNAL(activated()),
-            this, SLOT(insertInstant()));
 }
 
 void
 MainWindow::setupViewMenu()
 {
     if (m_mainMenusCreated) return;
 
     QAction *action = 0;
+
+    m_keyReference->setCategory(tr("Panning and Navigation"));
 
     QMenu *menu = menuBar()->addMenu(tr("&View"));
     menu->setTearOffEnabled(true);
     action = new QAction(tr("Scroll &Left"), this);
     action->setShortcut(tr("Left"));
     action->setStatusTip(tr("Scroll the current pane to the left"));
     connect(action, SIGNAL(triggered()), this, SLOT(scrollLeft()));
     connect(this, SIGNAL(canScroll(bool)), action, SLOT(setEnabled(bool)));
+    m_keyReference->registerShortcut(action);
     menu->addAction(action);
 	
     action = new QAction(tr("Scroll &Right"), this);
     action->setShortcut(tr("Right"));
     action->setStatusTip(tr("Scroll the current pane to the right"));
     connect(action, SIGNAL(triggered()), this, SLOT(scrollRight()));
     connect(this, SIGNAL(canScroll(bool)), action, SLOT(setEnabled(bool)));
+    m_keyReference->registerShortcut(action);
     menu->addAction(action);
 	
     action = new QAction(tr("&Jump Left"), this);
     action->setShortcut(tr("Ctrl+Left"));
     action->setStatusTip(tr("Scroll the current pane a big step to the left"));
     connect(action, SIGNAL(triggered()), this, SLOT(jumpLeft()));
     connect(this, SIGNAL(canScroll(bool)), action, SLOT(setEnabled(bool)));
+    m_keyReference->registerShortcut(action);
     menu->addAction(action);
 	
     action = new QAction(tr("J&ump Right"), this);
     action->setShortcut(tr("Ctrl+Right"));
     action->setStatusTip(tr("Scroll the current pane a big step to the right"));
     connect(action, SIGNAL(triggered()), this, SLOT(jumpRight()));
     connect(this, SIGNAL(canScroll(bool)), action, SLOT(setEnabled(bool)));
+    m_keyReference->registerShortcut(action);
     menu->addAction(action);
 
     menu->addSeparator();
+
+    m_keyReference->setCategory(tr("Zoom"));
 
     action = new QAction(QIcon(":/icons/zoom-in.png"),
                          tr("Zoom &In"), this);
     action->setShortcut(tr("Up"));
     action->setStatusTip(tr("Increase the zoom level"));
     connect(action, SIGNAL(triggered()), this, SLOT(zoomIn()));
     connect(this, SIGNAL(canZoom(bool)), action, SLOT(setEnabled(bool)));
+    m_keyReference->registerShortcut(action);
     menu->addAction(action);
 	
     action = new QAction(QIcon(":/icons/zoom-out.png"),
                          tr("Zoom &Out"), this);
     action->setShortcut(tr("Down"));
     action->setStatusTip(tr("Decrease the zoom level"));
     connect(action, SIGNAL(triggered()), this, SLOT(zoomOut()));
     connect(this, SIGNAL(canZoom(bool)), action, SLOT(setEnabled(bool)));
+    m_keyReference->registerShortcut(action);
     menu->addAction(action);
 	
     action = new QAction(tr("Restore &Default Zoom"), this);
     action->setStatusTip(tr("Restore the zoom level to the default"));
     connect(action, SIGNAL(triggered()), this, SLOT(zoomDefault()));

                          tr("Zoom to &Fit"), this);
     action->setShortcut(tr("F"));
     action->setStatusTip(tr("Zoom to show the whole file"));
     connect(action, SIGNAL(triggered()), this, SLOT(zoomToFit()));
     connect(this, SIGNAL(canZoom(bool)), action, SLOT(setEnabled(bool)));
+    m_keyReference->registerShortcut(action);
     menu->addAction(action);
 
     menu->addSeparator();
+
+    m_keyReference->setCategory(tr("Display Features"));
 
     QActionGroup *overlayGroup = new QActionGroup(this);
         
     action = new QAction(tr("Show &No Overlays"), this);
     action->setShortcut(tr("0"));
     action->setStatusTip(tr("Hide centre indicator, frame times, layer names and scale"));
     connect(action, SIGNAL(triggered()), this, SLOT(showNoOverlays()));
     action->setCheckable(true);
     action->setChecked(false);
     overlayGroup->addAction(action);
+    m_keyReference->registerShortcut(action);
     menu->addAction(action);
         
     action = new QAction(tr("Show &Minimal Overlays"), this);
     action->setShortcut(tr("9"));
     action->setStatusTip(tr("Show centre indicator only"));
     connect(action, SIGNAL(triggered()), this, SLOT(showMinimalOverlays()));
     action->setCheckable(true);
     action->setChecked(false);
     overlayGroup->addAction(action);
+    m_keyReference->registerShortcut(action);
     menu->addAction(action);
         
     action = new QAction(tr("Show &Standard Overlays"), this);
     action->setShortcut(tr("8"));
     action->setStatusTip(tr("Show centre indicator, frame times and scale"));
     connect(action, SIGNAL(triggered()), this, SLOT(showStandardOverlays()));
     action->setCheckable(true);
     action->setChecked(true);
     overlayGroup->addAction(action);
+    m_keyReference->registerShortcut(action);
     menu->addAction(action);
         
     action = new QAction(tr("Show &All Overlays"), this);
     action->setShortcut(tr("7"));
     action->setStatusTip(tr("Show all texts and scale"));
     connect(action, SIGNAL(triggered()), this, SLOT(showAllOverlays()));
     action->setCheckable(true);
     action->setChecked(false);
     overlayGroup->addAction(action);
+    m_keyReference->registerShortcut(action);
     menu->addAction(action);
         
     menu->addSeparator();
 
     action = new QAction(tr("Show &Zoom Wheels"), this);
     action->setShortcut(tr("Z"));
     action->setStatusTip(tr("Show thumbwheels for zooming horizontally and vertically"));
     connect(action, SIGNAL(triggered()), this, SLOT(toggleZoomWheels()));
     action->setCheckable(true);
     action->setChecked(m_viewManager->getZoomWheelsEnabled());
+    m_keyReference->registerShortcut(action);
     menu->addAction(action);
         
     action = new QAction(tr("Show Property Bo&xes"), this);
     action->setShortcut(tr("X"));
     action->setStatusTip(tr("Show the layer property boxes at the side of the main window"));
     connect(action, SIGNAL(triggered()), this, SLOT(togglePropertyBoxes()));
     action->setCheckable(true);
     action->setChecked(true);
+    m_keyReference->registerShortcut(action);
     menu->addAction(action);
 
     action = new QAction(tr("Show Status &Bar"), this);
     action->setStatusTip(tr("Show context help information in the status bar at the bottom of the window"));
     connect(action, SIGNAL(triggered()), this, SLOT(toggleStatusBar()));

 
     action = new QAction(tr("Show La&yer Hierarchy"), this);
     action->setShortcut(tr("H"));
     action->setStatusTip(tr("Open a window displaying the hierarchy of panes and layers in this session"));
     connect(action, SIGNAL(triggered()), this, SLOT(showLayerTree()));
+    m_keyReference->registerShortcut(action);
     menu->addAction(action);
 }
 
 void
 MainWindow::setupPaneAndLayerMenus()

         m_layerMenu->setTearOffEnabled(true);
     }
 
     QMenu *menu = m_paneMenu;
 
+    m_keyReference->setCategory(tr("Managing Panes and Layers"));
+
     QAction *action = new QAction(QIcon(":/icons/pane.png"), tr("Add &New Pane"), this);
     action->setShortcut(tr("N"));
     action->setStatusTip(tr("Add a new pane containing only a time ruler"));
     connect(action, SIGNAL(triggered()), this, SLOT(addPane()));
     connect(this, SIGNAL(canAddPane(bool)), action, SLOT(setEnabled(bool)));
     m_paneActions[action] = PaneConfiguration(LayerFactory::TimeRuler);
+    m_keyReference->registerShortcut(action);
     menu->addAction(action);
 
     menu->addSeparator();
 
     menu = m_layerMenu;

 	action = new QAction(icon, mainText, this);
 	action->setStatusTip(tipText);
 
 	if (type == LayerFactory::Text) {
 	    action->setShortcut(tr("T"));
+            m_keyReference->registerShortcut(action);
 	}
 
 	connect(action, SIGNAL(triggered()), this, SLOT(addLayer()));
 	connect(this, SIGNAL(canAddLayer(bool)), action, SLOT(setEnabled(bool)));
 	m_layerActions[action] = type;

                                     this, SLOT(addLayer()));
                             connect(this, SIGNAL(canAddLayer(bool)),
                                     action, SLOT(setEnabled(bool)));
                             m_layerActions[action] = type;
                         }
+                        if (shortcutText != "") {
+                            m_keyReference->registerShortcut(action);
+                        }
                         menu->addAction(action);
                         
                     } else {
                         
                         if (!submenu) {

                         }
 
                         if (isDefault) {
                             action = new QAction(icon, actionText, this);
                             if (!model || model == getMainModel()) {
-                                action->setShortcut(shortcutText);
+                                action->setShortcut(shortcutText); 
+                                m_keyReference->registerShortcut(action);
                             }
                         } else {
                             action = new QAction(actionText, this);
                         }
 

     action = new QAction(QIcon(":/icons/editdelete.png"), tr("&Delete Pane"), this);
     action->setShortcut(tr("Ctrl+Shift+D"));
     action->setStatusTip(tr("Delete the currently active pane"));
     connect(action, SIGNAL(triggered()), this, SLOT(deleteCurrentPane()));
     connect(this, SIGNAL(canDeleteCurrentPane(bool)), action, SLOT(setEnabled(bool)));
+    m_keyReference->registerShortcut(action);
     menu->addAction(action);
 
     menu = m_layerMenu;
 
     action = new QAction(QIcon(":/icons/timeruler.png"), tr("Add &Time Ruler"), this);

     action = new QAction(tr("&Rename Layer..."), this);
     action->setShortcut(tr("R"));
     action->setStatusTip(tr("Rename the currently active layer"));
     connect(action, SIGNAL(triggered()), this, SLOT(renameCurrentLayer()));
     connect(this, SIGNAL(canRenameLayer(bool)), action, SLOT(setEnabled(bool)));
+    m_keyReference->registerShortcut(action);
     menu->addAction(action);
     m_rightButtonLayerMenu->addAction(action);
 
     action = new QAction(QIcon(":/icons/editdelete.png"), tr("&Delete Layer"), this);
     action->setShortcut(tr("Ctrl+D"));
     action->setStatusTip(tr("Delete the currently active layer"));
     connect(action, SIGNAL(triggered()), this, SLOT(deleteCurrentLayer()));
     connect(this, SIGNAL(canDeleteCurrentLayer(bool)), action, SLOT(setEnabled(bool)));
+    m_keyReference->registerShortcut(action);
     menu->addAction(action);
     m_rightButtonLayerMenu->addAction(action);
 }
 
 void

 MainWindow::setupHelpMenu()
 {
     QMenu *menu = menuBar()->addMenu(tr("&Help"));
     menu->setTearOffEnabled(true);
     
+    m_keyReference->setCategory(tr("Help"));
+
     QAction *action = new QAction(QIcon(":icons/help.png"),
                                   tr("&Help Reference"), this); 
+    action->setShortcut(tr("F1"));
     action->setStatusTip(tr("Open the Sonic Visualiser reference manual")); 
     connect(action, SIGNAL(triggered()), this, SLOT(help()));
+    m_keyReference->registerShortcut(action);
     menu->addAction(action);
     
     action = new QAction(tr("Sonic Visualiser on the &Web"), this); 
     action->setStatusTip(tr("Open the Sonic Visualiser website")); 
     connect(action, SIGNAL(triggered()), this, SLOT(website()));
     menu->addAction(action);
+
+    action = new QAction(tr("&Key Reference"), this);
+    action->setShortcut(tr("F2"));
+    action->setStatusTip(tr("Open a window showing the keystrokes you can use in Sonic Visualiser"));
+    connect(action, SIGNAL(triggered()), this, SLOT(keyReference()));
+    m_keyReference->registerShortcut(action);
+    menu->addAction(action);
     
     action = new QAction(tr("&About Sonic Visualiser"), this); 
     action->setStatusTip(tr("Show information about Sonic Visualiser")); 
     connect(action, SIGNAL(triggered()), this, SLOT(about()));
     menu->addAction(action);

     m_recentFilesMenu->clear();
     vector<QString> files = m_recentFiles.getRecent();
     for (size_t i = 0; i < files.size(); ++i) {
 	QAction *action = new QAction(files[i], this);
 	connect(action, SIGNAL(triggered()), this, SLOT(openRecentFile()));
-        if (i == 0) action->setShortcut(tr("Ctrl+R"));
+        if (i == 0) {
+            action->setShortcut(tr("Ctrl+R"));
+            m_keyReference->registerShortcut
+                (action, tr("Re-open the most recently opened file"));
+        }
 	m_recentFilesMenu->addAction(action);
     }
 }
 
 void

             std::cerr << "WARNING: MainWindow::setupRecentTransformsMenu: "
                       << "Unknown transform \"" << transforms[i].toStdString()
                       << "\" in recent transforms list" << std::endl;
             continue;
         }
-        if (i == 0) ti->second->setShortcut(tr("Ctrl+T"));
+        if (i == 0) {
+            ti->second->setShortcut(tr("Ctrl+T"));
+            m_keyReference->registerShortcut
+                (tr("Re-run the most recently run transform"),
+                 ti->second->shortcut(),
+                 "");
+        }
 	m_recentTransformsMenu->addAction(ti->second);
     }
 }
 
 void

 }
 
 void
 MainWindow::setupToolbars()
 {
+    m_keyReference->setCategory(tr("Playback and Transport Controls"));
+
     QMenu *menu = m_playbackMenu = menuBar()->addMenu(tr("Play&back"));
     menu->setTearOffEnabled(true);
     m_rightButtonMenu->addSeparator();
     m_rightButtonPlaybackMenu = m_rightButtonMenu->addMenu(tr("Playback"));
 

     connect(m_viewManager, SIGNAL(playLoopModeChanged(bool)),
             plAction, SLOT(setChecked(bool)));
     connect(plAction, SIGNAL(triggered()), this, SLOT(playLoopToggled()));
     connect(this, SIGNAL(canPlay(bool)), plAction, SLOT(setEnabled(bool)));
 
+    m_keyReference->registerShortcut(playAction);
+    m_keyReference->registerShortcut(psAction);
+    m_keyReference->registerShortcut(plAction);
+    m_keyReference->registerShortcut(m_rwdAction);
+    m_keyReference->registerShortcut(m_ffwdAction);
+    m_keyReference->registerShortcut(rwdStartAction);
+    m_keyReference->registerShortcut(ffwdEndAction);
+
     menu->addAction(playAction);
     menu->addAction(psAction);
     menu->addAction(plAction);
     menu->addSeparator();
     menu->addAction(m_rwdAction);

     QAction *normalAction = menu->addAction(tr("Restore Normal Speed"));
     normalAction->setShortcut(tr("Ctrl+Home"));
     connect(normalAction, SIGNAL(triggered()), this, SLOT(restoreNormalPlayback()));
     connect(this, SIGNAL(canChangePlaybackSpeed(bool)), normalAction, SLOT(setEnabled(bool)));
 
+    m_keyReference->registerShortcut(fastAction);
+    m_keyReference->registerShortcut(slowAction);
+    m_keyReference->registerShortcut(normalAction);
+
     m_rightButtonPlaybackMenu->addAction(fastAction);
     m_rightButtonPlaybackMenu->addAction(slowAction);
     m_rightButtonPlaybackMenu->addAction(normalAction);
 
     toolbar = addToolBar(tr("Edit Toolbar"));
     CommandHistory::getInstance()->registerToolbar(toolbar);
+
+    m_keyReference->setCategory(tr("Tool Selection"));
 
     toolbar = addToolBar(tr("Tools Toolbar"));
     QActionGroup *group = new QActionGroup(this);
 
     QAction *action = toolbar->addAction(QIcon(":/icons/navigate.png"),

     action->setChecked(true);
     action->setShortcut(tr("1"));
     action->setStatusTip(tr("Navigate"));
     connect(action, SIGNAL(triggered()), this, SLOT(toolNavigateSelected()));
     group->addAction(action);
+    m_keyReference->registerShortcut(action);
     m_toolActions[ViewManager::NavigateMode] = action;
 
     action = toolbar->addAction(QIcon(":/icons/select.png"),
 				tr("Select"));
     action->setCheckable(true);
     action->setShortcut(tr("2"));
     action->setStatusTip(tr("Select ranges"));
     connect(action, SIGNAL(triggered()), this, SLOT(toolSelectSelected()));
     group->addAction(action);
+    m_keyReference->registerShortcut(action);
     m_toolActions[ViewManager::SelectMode] = action;
 
     action = toolbar->addAction(QIcon(":/icons/move.png"),
 				tr("Edit"));
     action->setCheckable(true);
     action->setShortcut(tr("3"));
     action->setStatusTip(tr("Edit items in layer"));
     connect(action, SIGNAL(triggered()), this, SLOT(toolEditSelected()));
     connect(this, SIGNAL(canEditLayer(bool)), action, SLOT(setEnabled(bool)));
     group->addAction(action);
+    m_keyReference->registerShortcut(action);
     m_toolActions[ViewManager::EditMode] = action;
 
     action = toolbar->addAction(QIcon(":/icons/draw.png"),
 				tr("Draw"));
     action->setCheckable(true);
     action->setShortcut(tr("4"));
     action->setStatusTip(tr("Draw new items in layer"));
     connect(action, SIGNAL(triggered()), this, SLOT(toolDrawSelected()));
     connect(this, SIGNAL(canEditLayer(bool)), action, SLOT(setEnabled(bool)));
     group->addAction(action);
+    m_keyReference->registerShortcut(action);
     m_toolActions[ViewManager::DrawMode] = action;
 
     action = toolbar->addAction(QIcon(":/icons/measure.png"),
 				tr("Measure"));
     action->setCheckable(true);
     action->setShortcut(tr("5"));
     action->setStatusTip(tr("Make measurements in layer"));
     connect(action, SIGNAL(triggered()), this, SLOT(toolMeasureSelected()));
     group->addAction(action);
+    m_keyReference->registerShortcut(action);
     m_toolActions[ViewManager::MeasureMode] = action;
 
 //    action = toolbar->addAction(QIcon(":/icons/text.png"),
 //				tr("Text"));
 //    action->setCheckable(true);

         "COPYING included with this distribution for more information.</p>";
     
     QMessageBox::about(this, tr("About Sonic Visualiser"), aboutText);
 }
 
+void
+MainWindow::keyReference()
+{
+    m_keyReference->show();
+}
+