EM_INIT(exExiting, "Exiting");

setAttribute(Qt::WA_DeleteOnClose);

setupUi(this);

// manual setup widgets not buildable with Qt designer

lineEditSHA = new QLineEdit(NULL);

lineEditFilter = new QLineEdit(NULL);

cmbSearch = new QComboBox(NULL);

QString list("Short log,Log msg,Author,SHA1,File,Patch,Patch (regExp)");

cmbSearch->addItems(list.split(","));

toolBar->addWidget(lineEditSHA);

QAction* act = toolBar->insertWidget(ActSearchAndFilter, lineEditFilter);

toolBar->insertWidget(act, cmbSearch);

connect(lineEditSHA, SIGNAL(returnPressed()), this, SLOT(lineEditSHA_returnPressed()));

connect(lineEditFilter, SIGNAL(returnPressed()), this, SLOT(lineEditFilter_returnPressed()));

// create light and dark colors for alternate background

ODD_LINE_COL = palette().color(QPalette::Base);

EVEN_LINE_COL = ODD_LINE_COL.dark(103);

// our interface to git world

git = new Git(this);

setupShortcuts();

qApp->installEventFilter(this);

// init native types

setRepositoryBusy = false;

// init filter match highlighters

shortLogRE.setMinimal(true);

shortLogRE.setCaseSensitivity(Qt::CaseInsensitive);

longLogRE.setMinimal(true);

longLogRE.setCaseSensitivity(Qt::CaseInsensitive);

// set-up standard revisions and files list font

QSettings settings;

QString font(settings.value(STD_FNT_KEY).toString());

if (font.isEmpty())

font = QApplication::font().toString();

QGit::STD_FONT.fromString(font);

// set-up typewriter (fixed width) font

font = settings.value(TYPWRT_FNT_KEY).toString();

if (font.isEmpty()) { // choose a sensible default

QFont fnt = QApplication::font();

fnt.setStyleHint(QFont::TypeWriter, QFont::PreferDefault);

fnt.setFixedPitch(true);

fnt.setFamily(fnt.defaultFamily()); // the family corresponding

font = fnt.toString(); // to current style hint

}

QGit::TYPE_WRITER_FONT.fromString(font);

// set-up tab view

delete tabWdg->currentWidget(); // cannot be done in Qt Designer

rv = new RevsView(this, git, true); // set has main domain

tabWdg->addTab(rv->tabPage(), "&Rev list");

// set-up tab corner widget ('close tab' button)

QToolButton* ct = new QToolButton(tabWdg);

ct->setIcon(QIcon(QString::fromUtf8(":/icons/resources/tab_remove.png")));

ct->setToolTip("Close tab");

ct->setEnabled(false);

tabWdg->setCornerWidget(ct);

connect(ct, SIGNAL(clicked()), this, SLOT(pushButtonCloseTab_clicked()));

connect(this, SIGNAL(closeTabButtonEnabled(bool)), ct, SLOT(setEnabled(bool)));

// set-up file names loading progress bar

pbFileNamesLoading = new QProgressBar(statusBar());

pbFileNamesLoading->setTextVisible(false);

pbFileNamesLoading->setToolTip("Background file names loading");

pbFileNamesLoading->hide();

statusBar()->addPermanentWidget(pbFileNamesLoading);

QVector<QSplitter*> v(1, treeSplitter);

QGit::restoreGeometrySetting(QGit::MAIN_GEOM_KEY, this, &v);

treeView->hide();

// set-up menu for recent visited repositories

connect(File, SIGNAL(triggered(QAction*)), this, SLOT(openRecent_triggered(QAction*)));

doUpdateRecentRepoMenu("");

// set-up menu for custom actions

connect(Actions, SIGNAL(triggered(QAction*)), this, SLOT(customAction_triggered(QAction*)));

doUpdateCustomActionMenu(settings.value(ACT_LIST_KEY).toStringList());

// manual adjust lineEditSHA width

QString tmp(41, '8');

int wd = lineEditSHA->fontMetrics().boundingRect(tmp).width();

lineEditSHA->setMinimumWidth(wd);

// disable all actions

updateGlobalActions(false);

connect(git, SIGNAL(fileNamesLoad(int, int)), this, SLOT(fileNamesLoad(int, int)));

connect(git, SIGNAL(newRevsAdded(const FileHistory*, const QVector<ShaString>&)),

this, SLOT(newRevsAdded(const FileHistory*, const QVector<ShaString>&)));

connect(this, SIGNAL(typeWriterFontChanged()), this, SIGNAL(updateRevDesc()));

connect(this, SIGNAL(changeFont(const QFont&)), git, SIGNAL(changeFont(const QFont&)));

// connect cross-domain update signals

connect(rv->tab()->listViewLog, SIGNAL(doubleClicked(const QModelIndex&)),

this, SLOT(listViewLog_doubleClicked(const QModelIndex&)));

connect(rv->tab()->fileList, SIGNAL(itemDoubleClicked(QListWidgetItem*)),

this, SLOT(fileList_itemDoubleClicked(QListWidgetItem*)));

connect(treeView, SIGNAL(itemDoubleClicked(QTreeWidgetItem*, int)),

this, SLOT(treeView_doubleClicked(QTreeWidgetItem*, int)));

// use most recent repo as startup dir if it exists and user opted to do so

QStringList recents(settings.value(REC_REP_KEY).toStringList());

QDir checkRepo;

if ( recents.size() >= 1

&& testFlag(REOPEN_REPO_F, FLAGS_KEY)

&& checkRepo.exists(recents.at(0)))

{

startUpDir = recents.at(0);

}

else {

startUpDir = (cd.isEmpty() ? QDir::current().absolutePath() : cd);

}

// MainImpl c'tor is called before to enter event loop,

// but some stuff requires event loop to init properly

QTimer::singleShot(10, this, SLOT(initWithEventLoopActive()));

git->checkEnvironment();

setRepository(startUpDir);

startUpDir = ""; // one shot

QVector<QSplitter*> v(1, treeSplitter);

QGit::saveGeometrySetting(QGit::MAIN_GEOM_KEY, this, &v);

// reset any previous highlight

if (ActSearchAndHighlight->isChecked())

ActSearchAndHighlight->toggle();

// set to highlight on SHA matching

cmbSearch->setCurrentIndex(CS_SHA1);

// set substring to search for

lineEditFilter->setText(abbrevSha);

// go with highlighting

ActSearchAndHighlight->toggle();

QString sha = git->getRefSha(lineEditSHA->text());

if (!sha.isEmpty()) // good, we can resolve to an unique sha

{

rv->st.setSha(sha);

UPDATE_DOMAIN(rv);

} else { // try a multiple match search

highlightAbbrevSha(lineEditSHA->text());

goMatch(0);

}

lineEditSHA->undo(); // first for insert(text)

if (lineEditSHA->text().isEmpty())

lineEditSHA->undo(); // double undo, see RevsView::updateLineEditSHA()

lineEditSHA_returnPressed();

lineEditSHA->redo();

if (lineEditSHA->text().isEmpty())

lineEditSHA->redo();

lineEditSHA_returnPressed();

QStringList args;

QStringList filenames;

getExternalDiffArgs(&args, &filenames);

ExternalDiffProc* externalDiff = new ExternalDiffProc(filenames, this);

externalDiff->setWorkingDirectory(curDir);

if (!QGit::startProcess(externalDiff, args)) {

QString text("Cannot start external viewer: ");

text.append(args[0]);

QMessageBox::warning(this, "Error - QGit", text);

delete externalDiff;

}

// save files to diff in working directory,

// will be removed by ExternalDiffProc on exit

QFileInfo f(rv->st.fileName());

QString prevRevSha(rv->st.diffToSha());

if (prevRevSha.isEmpty()) { // default to first parent

const Rev* r = git->revLookup(rv->st.sha());

prevRevSha = (r && r->parentsCount() > 0 ? r->parent(0) : rv->st.sha());

}

QFileInfo fi(f);

QString fName1(curDir + "/" + rv->st.sha().left(6) + "_" + fi.fileName());

QString fName2(curDir + "/" + prevRevSha.left(6) + "_" + fi.fileName());

QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));

QByteArray fileContent;

QString fileSha(git->getFileSha(rv->st.fileName(), rv->st.sha()));

git->getFile(fileSha, NULL, &fileContent, rv->st.fileName());

if (!writeToFile(fName1, QString(fileContent)))

statusBar()->showMessage("Unable to save " + fName1);

fileSha = git->getFileSha(rv->st.fileName(), prevRevSha);

git->getFile(fileSha, NULL, &fileContent, rv->st.fileName());

if (!writeToFile(fName2, QString(fileContent)))

statusBar()->showMessage("Unable to save " + fName2);

// get external diff viewer command

QSettings settings;

QString extDiff(settings.value(EXT_DIFF_KEY, EXT_DIFF_DEF).toString());

QApplication::restoreOverrideCursor();

// if command doesn't have %1 and %2 to denote filenames, add them to end

if (!extDiff.contains("%1")) {

extDiff.append(" %1");

}

if (!extDiff.contains("%2")) {

extDiff.append(" %2");

}

// set process arguments

QStringList extDiffArgs = extDiff.split(' ');

QString curArg;

for (int i = 0; i < extDiffArgs.count(); i++) {

curArg = extDiffArgs.value(i);

// perform any filename replacements that are necessary

// (done inside the loop to handle whitespace in paths properly)

curArg.replace("%1", fName2);

curArg.replace("%2", fName1);

args->append(curArg);

}

// set filenames so that they can be deleted when the process completes

filenames->append(fName1);

filenames->append(fName2);

const QStringList* passedArgs, bool overwriteArgs) {

/*

if (setRepositoryBusy)

return;

setRepositoryBusy = true;

// check for a refresh or open of a new repository while in filtered view

if (ActFilterTree->isChecked() && passedArgs == NULL)

// toggle() triggers a refresh and a following setRepository()

// call that is filtered out by setRepositoryBusy guard flag

ActFilterTree->toggle(); // triggers ActFilterTree_toggled()

try {

EM_REGISTER(exExiting);

bool archiveChanged;

git->getBaseDir(newDir, curDir, archiveChanged);

git->stop(archiveChanged); // stop all pending processes, non blocking

if (archiveChanged && refresh)

dbs("ASSERT in setRepository: different dir with no range select");

// now we can clear all our data

setWindowTitle(curDir + " - QGit");

bool complete = !refresh || !keepSelection;

rv->clear(complete);

if (archiveChanged)

emit closeAllTabs();

// disable all actions

updateGlobalActions(false);

updateContextActions("", "", false, false);

ActCommit_setEnabled(false);

if (ActFilterTree->isChecked())

setWindowTitle(windowTitle() + " - FILTER ON < " +

passedArgs->join(" ") + " >");

// tree name should be set before init because in case of

// StGIT archives the first revs are sent before init returns

QString n(curDir);

treeView->setTreeName(n.prepend('/').section('/', -1, -1));

bool quit;

bool ok = git->init(curDir, !refresh, passedArgs, overwriteArgs, &quit); // blocking call

if (quit)

goto exit;

updateCommitMenu(ok && git->isStGITStack());

ActCheckWorkDir->setChecked(testFlag(DIFF_INDEX_F)); // could be changed in Git::init()

if (ok) {

updateGlobalActions(true);

if (archiveChanged)

updateRecentRepoMenu(curDir);

} else

statusBar()->showMessage("Not a git archive");

exit:

setRepositoryBusy = false;

EM_REMOVE(exExiting);

if (quit && !startUpDir.isEmpty())

close();

} catch (int i) {

EM_REMOVE(exExiting);

if (EM_MATCH(i, exExiting, "loading repository")) {

EM_THROW_PENDING;

return;

}

const QString info("Exception \'" + EM_DESC(i) + "\' not "

"handled in setRepository...re-throw");

dbs(info);

throw;

}

ActRefresh->setEnabled(b);

ActCheckWorkDir->setEnabled(b);

ActViewRev->setEnabled(b);

ActViewDiff->setEnabled(b);

ActViewDiffNewTab->setEnabled(b && firstTab<PatchView>());

ActShowTree->setEnabled(b);

ActMailApplyPatch->setEnabled(b);

ActMailFormatPatch->setEnabled(b);

rv->setEnabled(b);

bool isDir, bool found) {

bool pathActionsEnabled = !newFileName.isEmpty();

bool fileActionsEnabled = (pathActionsEnabled && !isDir);

ActViewFile->setEnabled(fileActionsEnabled);

ActViewFileNewTab->setEnabled(fileActionsEnabled && firstTab<FileView>());

ActExternalDiff->setEnabled(fileActionsEnabled);

ActSaveFile->setEnabled(fileActionsEnabled);

ActFilterTree->setEnabled(pathActionsEnabled || ActFilterTree->isChecked());

bool isTag, isUnApplied, isApplied;

isTag = isUnApplied = isApplied = false;

if (found) {

const Rev* r = git->revLookup(newRevSha);

isTag = git->checkRef(newRevSha, Git::TAG);

isUnApplied = r->isUnApplied;

isApplied = r->isApplied;

}

ActBranch->setEnabled(found && (newRevSha != ZERO_SHA) && !isUnApplied);

ActTag->setEnabled(found && (newRevSha != ZERO_SHA) && !isUnApplied);

ActTagDelete->setEnabled(found && isTag && (newRevSha != ZERO_SHA) && !isUnApplied);

ActPush->setEnabled(found && isUnApplied && git->isNothingToCommit());

ActPop->setEnabled(found && isApplied && git->isNothingToCommit());

if (index.isValid() && ActViewDiff->isEnabled())

ActViewDiff->activate(QAction::Trigger);

if (index.isValid() && ActViewRev->isEnabled())

ActViewRev->activate(QAction::Trigger);

bool isFirst = (item && item->listWidget()->item(0) == item);

if (isFirst && rv->st.isMerge())

return;

bool isMainView = (item && item->listWidget() == rv->tab()->fileList);

if (isMainView && ActViewDiff->isEnabled())

ActViewDiff->activate(QAction::Trigger);

if (item && !isMainView && ActViewFile->isEnabled())

ActViewFile->activate(QAction::Trigger);

if (item && ActViewFile->isEnabled())

ActViewFile->activate(QAction::Trigger);

Domain* t;

switch (currentTabType(&t)) {

case TAB_REV:

break;

case TAB_PATCH:

t->deleteWhenDone();

ActViewDiffNewTab->setEnabled(ActViewDiff->isEnabled() && firstTab<PatchView>());

break;

case TAB_FILE:

t->deleteWhenDone();

ActViewFileNewTab->setEnabled(ActViewFile->isEnabled() && firstTab<FileView>());

break;

default:

dbs("ASSERT in pushButtonCloseTab_clicked: unknown current page");

break;

}

QString args;

RangeSelectImpl rs(this, &args, false, git);

bool quit = (rs.exec() == QDialog::Rejected); // modal execution

if (!quit) {

const QStringList l(args.split(" "));

setRepository(curDir, true, true, &l, true);

}

Domain* t;

if (currentTabType(&t) == TAB_FILE) {

rv->st = t->st;

UPDATE_DOMAIN(rv);

}

tabWdg->setCurrentWidget(rv->tabPage());

if (!fv) {

fv = new FileView(this, git);

tabWdg->addTab(fv->tabPage(), "File");

connect(fv->tab()->histListView, SIGNAL(doubleClicked(const QModelIndex&)),

this, SLOT(histListView_doubleClicked(const QModelIndex&)));

connect(this, SIGNAL(closeAllTabs()), fv, SLOT(on_closeAllTabs()));

ActViewFileNewTab->setEnabled(ActViewFile->isEnabled());

}

tabWdg->setCurrentWidget(fv->tabPage());

fv->st = rv->st;

UPDATE_DOMAIN(fv);

Domain* t;

if (currentTabType(&t) == TAB_FILE) {

rv->st = t->st;

UPDATE_DOMAIN(rv);

}

rv->viewPatch(false);

ActViewDiffNewTab->setEnabled(true);

if (ActSearchAndFilter->isChecked() || ActSearchAndHighlight->isChecked()) {

bool isRegExp = (cmbSearch->currentIndex() == CS_PATCH_REGEXP);

emit highlightPatch(lineEditFilter->text(), isRegExp);

}

if (ev->type() == QEvent::Wheel) {

QWheelEvent* e = static_cast<QWheelEvent*>(ev);

if (e->modifiers() == Qt::AltModifier) {

int idx = tabWdg->currentIndex();

if (e->delta() < 0)

idx = (++idx == tabWdg->count() ? 0 : idx);

else

idx = (--idx < 0 ? tabWdg->count() - 1 : idx);

tabWdg->setCurrentIndex(idx);

return true;

}

}

return QWidget::eventFilter(obj, ev);

const QString h(QString::fromLatin1("@") + curDir + '\n');

const QString dragRevs = selRevs.join(h).append(h).trimmed();

QDrag* drag = new QDrag(this);

QMimeData* mimeData = new QMimeData;

mimeData->setText(dragRevs);

drag->setMimeData(mimeData);

drag->start(); // blocking until drop event

if (rv->isDropping()) // avoid reentrancy

return;

QDir dr(curDir + QGit::PATCHES_DIR);

if (dr.exists()) {

const QString tmp("Please remove stale import directory " + dr.absolutePath());

statusBar()->showMessage(tmp);

return;

}

bool workDirOnly, fold;

if (!askApplyPatchParameters(&workDirOnly, &fold))

return;

// ok, let's go

rv->setDropping(true);

dr.setFilter(QDir::Files);

QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));

raise();

EM_PROCESS_EVENTS;

uint revNum = 0;

QStringList::const_iterator it(remoteRevs.constEnd());

do {

--it;

QString tmp("Importing revision %1 of %2");

statusBar()->showMessage(tmp.arg(++revNum).arg(remoteRevs.count()));

SCRef sha((*it).section('@', 0, 0));

SCRef remoteRepo((*it).section('@', 1));

if (!dr.exists(remoteRepo))

break;

// we create patches one by one

if (!git->formatPatch(QStringList(sha), dr.absolutePath(), remoteRepo))

break;

dr.refresh();

if (dr.count() != 1) {

qDebug("ASSERT in on_droppedRevisions: found %i files "

"in %s", dr.count(), QGit::PATCHES_DIR.toLatin1().constData());

break;

}

SCRef fn(dr.absoluteFilePath(dr[0]));

bool is_applied = git->applyPatchFile(fn, fold, Git::optDragDrop);

dr.remove(fn);

if (!is_applied)

break;

} while (it != remoteRevs.constBegin());

if (it == remoteRevs.constBegin())

statusBar()->clearMessage();

else

statusBar()->showMessage("Failed to import revision " + QString::number(revNum--));

if (workDirOnly && (revNum > 0))

git->resetCommits(revNum);

dr.rmdir(dr.absolutePath()); // 'dr' must be already empty

QApplication::restoreOverrideCursor();

rv->setDropping(false);

refreshRepo();

if (!git->isMainHistory(fh))

return;

if (ActSearchAndFilter->isChecked())

ActSearchAndFilter_toggled(true); // filter again on new arrived data

if (ActSearchAndHighlight->isChecked())

ActSearchAndHighlight_toggled(true); // filter again on new arrived data

// first rev could be a StGIT unapplied patch so check more then once

if ( !ActCommit->isEnabled()

&& (!git->isNothingToCommit() || git->isUnknownFiles())

&& !git->isCommittingMerge())

ActCommit_setEnabled(true);

ActSearchAndHighlight->setEnabled(!isOn);

ActSearchAndFilter->setEnabled(false);

filterList(isOn, false); // blocking call

ActSearchAndFilter->setEnabled(true);

ActSearchAndFilter->setEnabled(!isOn);

ActSearchAndHighlight->setEnabled(false);

filterList(isOn, true); // blocking call

ActSearchAndHighlight->setEnabled(true);

lineEditFilter->setEnabled(!isOn);

cmbSearch->setEnabled(!isOn);

SCRef filter(lineEditFilter->text());

if (filter.isEmpty())

return;

ShaSet shaSet;

bool patchNeedsUpdate, isRegExp;

patchNeedsUpdate = isRegExp = false;

int idx = cmbSearch->currentIndex(), colNum = 0;

if (isOn) {

switch (idx) {

case CS_SHORT_LOG:

colNum = LOG_COL;

shortLogRE.setPattern(filter);

break;

case CS_LOG_MSG:

colNum = LOG_MSG_COL;

longLogRE.setPattern(filter);

break;

case CS_AUTHOR:

colNum = AUTH_COL;

break;

case CS_SHA1:

colNum = COMMIT_COL;

break;

case CS_FILE:

case CS_PATCH:

case CS_PATCH_REGEXP:

colNum = SHA_MAP_COL;

QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));

EM_PROCESS_EVENTS; // to paint wait cursor

if (idx == CS_FILE)

git->getFileFilter(filter, shaSet);

else {

isRegExp = (idx == CS_PATCH_REGEXP);

if (!git->getPatchFilter(filter, isRegExp, shaSet)) {

QApplication::restoreOverrideCursor();

ActSearchAndFilter->toggle();

return;

}

patchNeedsUpdate = (shaSet.count() > 0);

}

QApplication::restoreOverrideCursor();

break;

}

} else {

patchNeedsUpdate = (idx == CS_PATCH || idx == CS_PATCH_REGEXP);

shortLogRE.setPattern("");

longLogRE.setPattern("");

}

QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));

ListView* lv = rv->tab()->listViewLog;

int matchedCnt = lv->filterRows(isOn, onlyHighlight, filter, colNum, &shaSet);

QApplication::restoreOverrideCursor();

emit updateRevDesc(); // could be highlighted

if (patchNeedsUpdate)

emit highlightPatch(isOn ? filter : "", isRegExp);

QString msg;

if (isOn && !onlyHighlight)

msg = QString("Found %1 matches. Toggle filter/highlight "

"button to remove the filter").arg(matchedCnt);

QApplication::postEvent(rv, new MessageEvent(msg)); // deferred message, after update

BaseEvent* de = dynamic_cast<BaseEvent*>(e);

if (!de)

return QWidget::event(e);

SCRef data = de->myData();

bool ret = true;

switch ((EventType)e->type()) {

case ERROR_EV: {

QApplication::setOverrideCursor(QCursor(Qt::ArrowCursor));

EM_PROCESS_EVENTS;

MainExecErrorEvent* me = (MainExecErrorEvent*)e;

QString text("An error occurred while executing command:\n\n");

text.append(me->command() + "\n\nGit says: \n\n" + me->report());

QMessageBox::warning(this, "Error - QGit", text);

QApplication::restoreOverrideCursor(); }

break;

case MSG_EV:

statusBar()->showMessage(data);

break;

case POPUP_LIST_EV:

doContexPopup(data);

break;

case POPUP_FILE_EV:

case POPUP_TREE_EV:

doFileContexPopup(data, e->type());

break;

default:

dbp("ASSERT in MainImpl::event unhandled event %1", e->type());

ret = false;

break;

}

return ret;

*t = NULL;

QWidget* curPage = tabWdg->currentWidget();

if (curPage == rv->tabPage()) {

*t = rv;

return TAB_REV;

}

QList<PatchView*>* l = getTabs<PatchView>(curPage);

if (l->count() > 0) {

*t = l->first();

delete l;

return TAB_PATCH;

}

delete l;

QList<FileView*>* l2 = getTabs<FileView>(curPage);

if (l2->count() > 0) {

*t = l2->first();

delete l2;

return TAB_FILE;

}

if (l2->count() > 0)

dbs("ASSERT in tabType file not found");

delete l2;

return -1;

if (w == -1)

return;

// set correct focus for keyboard browsing

Domain* t;

switch (currentTabType(&t)) {

case TAB_REV:

static_cast<RevsView*>(t)->tab()->listViewLog->setFocus();

emit closeTabButtonEnabled(false);

break;

case TAB_PATCH:

static_cast<PatchView*>(t)->tab()->textEditDiff->setFocus();

emit closeTabButtonEnabled(true);

break;

case TAB_FILE:

static_cast<FileView*>(t)->tab()->histListView->setFocus();

emit closeTabButtonEnabled(true);

break;

default:

dbs("ASSERT in tabWdg_currentChanged: unknown current page");

break;

}

new QShortcut(Qt::Key_I, this, SLOT(shortCutActivated()));

new QShortcut(Qt::Key_K, this, SLOT(shortCutActivated()));

new QShortcut(Qt::Key_N, this, SLOT(shortCutActivated()));

new QShortcut(Qt::Key_Left, this, SLOT(shortCutActivated()));

new QShortcut(Qt::Key_Right, this, SLOT(shortCutActivated()));

new QShortcut(Qt::Key_Delete, this, SLOT(shortCutActivated()));

new QShortcut(Qt::Key_Backspace, this, SLOT(shortCutActivated()));

new QShortcut(Qt::Key_Space, this, SLOT(shortCutActivated()));

new QShortcut(Qt::Key_B, this, SLOT(shortCutActivated()));

new QShortcut(Qt::Key_D, this, SLOT(shortCutActivated()));

new QShortcut(Qt::Key_F, this, SLOT(shortCutActivated()));

new QShortcut(Qt::Key_P, this, SLOT(shortCutActivated()));

new QShortcut(Qt::Key_R, this, SLOT(shortCutActivated()));

new QShortcut(Qt::Key_U, this, SLOT(shortCutActivated()));

new QShortcut(Qt::SHIFT | Qt::Key_Up, this, SLOT(shortCutActivated()));

new QShortcut(Qt::SHIFT | Qt::Key_Down, this, SLOT(shortCutActivated()));

new QShortcut(Qt::CTRL | Qt::Key_Plus, this, SLOT(shortCutActivated()));

new QShortcut(Qt::CTRL | Qt::Key_Minus, this, SLOT(shortCutActivated()));

QShortcut* se = dynamic_cast<QShortcut*>(sender());

if (!se)

return;

bool isKey_P = false;

switch (se->key()) {

case Qt::Key_I:

rv->tab()->listViewLog->on_keyUp();

break;

case Qt::Key_K:

case Qt::Key_N:

rv->tab()->listViewLog->on_keyDown();

break;

case Qt::SHIFT | Qt::Key_Up:

goMatch(-1);

break;

case Qt::SHIFT | Qt::Key_Down:

goMatch(1);

break;

case Qt::Key_Left:

ActBack_activated();

break;

case Qt::Key_Right:

ActForward_activated();

break;

case Qt::CTRL | Qt::Key_Plus:

adjustFontSize(1);

break;

case Qt::CTRL | Qt::Key_Minus:

adjustFontSize(-1);

break;

case Qt::Key_U:

scrollTextEdit(-18);

break;

case Qt::Key_D:

scrollTextEdit(18);

break;

case Qt::Key_Delete:

case Qt::Key_B:

case Qt::Key_Backspace:

scrollTextEdit(-1);

break;

case Qt::Key_Space:

scrollTextEdit(1);

break;

case Qt::Key_R:

tabWdg->setCurrentWidget(rv->tabPage());

break;

case Qt::Key_P:

isKey_P = true;

case Qt::Key_F: {

QWidget* cp = tabWdg->currentWidget();

Domain* d = isKey_P ? static_cast<Domain*>(firstTab<PatchView>(cp)) :

static_cast<Domain*>(firstTab<FileView>(cp));

if (d)