mainwindow.cpp

#include "mainwindow.h"
#include "ui_mainwindow.h"
#include "settings.h"
#include "configdialog.h"
#include "aboutDialog.h"
#include "htmlnote.h"
#include "notecreatewidget.h"
#include "shared.h"

#include <QMessageBox>
#include <QClipboard>
#include <QProcess>
#include <QCloseEvent>
#include <QTextCharFormat>
#include <QColorDialog>
#include <QFileDialog>
#include <QTextDocument>
#include <QPrintPreviewDialog>
#include <QPrintDialog>

/*
	Tray icon on windows is very small
*/
#if defined Q_WS_WIN /* Qt4 */ || defined Q_OS_WIN /* Qt5 */
	#define TRAY_ICON_FILE_NAME ":/res/znotes.png"
#elif defined Q_WS_MAC /* Qt4 */ || defined Q_OS_MAC /* Qt5 */
	#define TRAY_ICON_FILE_NAME ":/res/znotes32_bw.png"
#else
	#define TRAY_ICON_FILE_NAME ":/res/znotes32.png"
#endif

Settings settings;

//Function for fast generating actions
static inline QAction* generateAction(int item_id) {
    item_enum item = item_enum(item_id);
    ToolbarAction toolbar_action(item, settings.getIconsUseSystemTheme());
    QAction* action = new QAction(toolbar_action.icon(), toolbar_action.text(), 0);
    action->setCheckable(toolbar_action.isCheckable());
    return action;
}

static inline void regenerateAction(int item_id, QAction* action) {
    item_enum item = item_enum(item_id);
    ToolbarAction toolbar_action(item, settings.getIconsUseSystemTheme());
    action->setIcon(toolbar_action.icon());
}

MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent),
      ui(new Ui::MainWindow),
      note_create_widget(0)
{
    ui->setupUi(this);
    ui->wSearch->hide();
    //restoring window state
    restoreGeometry(settings.getDialogGeometry());
    restoreState(settings.getDialogState());
    windowStateChanged();

    notes = new NoteList(ui->centralWidget);
    ui->layout->addWidget(notes->getWidget());
    connect(notes, SIGNAL(currentNoteChanged(int,int)), this, SLOT(currentNoteChanged(int,int)));

    // Creating toolbar/menu actions
    for (int i = 0; i < itemMax ; ++i)
        actions[i] = generateAction(i);
    actShow =	new QAction(tr("Show"),	parent);
    actHide =	new QAction(tr("Hide"),	parent);
    //Connecting actions with slots
    actions[itemAdd]->setCheckable(true);
    connect(actions[itemAdd],              SIGNAL(triggered()),   this,  SLOT(NewNote()));
    connect(actions[itemAddText],          SIGNAL(triggered()),   this,  SLOT(NewNotePlain()));
    connect(actions[itemAddHtml],          SIGNAL(triggered()),   this,  SLOT(NewNoteHTML()));
    connect(actions[itemAddTodo],          SIGNAL(triggered()),   this,  SLOT(NewNoteTODO()));
    connect(actions[itemRemove],           SIGNAL(triggered()),   notes, SLOT(removeCurrentNote()));
    connect(actions[itemRename],           SIGNAL(triggered()),   notes, SLOT(renameCurrentNote()));
    connect(actions[itemPrev],             SIGNAL(triggered()),   this,  SLOT(PreviousNote()));
    connect(actions[itemNext],             SIGNAL(triggered()),   this,  SLOT(NextNote()));
    connect(actions[itemBack],	           SIGNAL(triggered()),   notes, SLOT(historyBack()));
    connect(actions[itemForward],	       SIGNAL(triggered()),   notes, SLOT(historyForward()));
    connect(actions[itemCopy],	           SIGNAL(triggered()),   this,  SLOT(CopyNote()));
    connect(actions[itemSetup],	           SIGNAL(triggered()),   this,  SLOT(showPrefDialog()));
    connect(actions[itemInfo],	           SIGNAL(triggered()),   this,  SLOT(showAboutDialog()));
    connect(actions[itemRun],		       SIGNAL(triggered()),   this,  SLOT(commandMenu()));
    connect(actions[itemSearch],	       SIGNAL(toggled(bool)), this,  SLOT(showSearchBar(bool)));
    connect(actions[itemExit],             SIGNAL(triggered()),   qApp,  SLOT(quit()));
    connect(actions[itemFormatBold],       SIGNAL(triggered()),   this,  SLOT(formatBold()));
    connect(actions[itemFormatItalic],	   SIGNAL(triggered()),   this,  SLOT(formatItalic()));
    connect(actions[itemFormatStrikeout],  SIGNAL(triggered()),   this,  SLOT(formatStrikeout()));
    connect(actions[itemFormatUnderline],  SIGNAL(triggered()),   this,  SLOT(formatUnderline()));
    connect(actions[itemFormatColor],	   SIGNAL(triggered()),   this,  SLOT(formatTextColor()));
    connect(actions[itemExportPdf],	       SIGNAL(triggered()),   this,  SLOT(notePrintPdf()));
    connect(actions[itemPrintNote],	       SIGNAL(triggered()),   this,  SLOT(notePrint()));
    connect(actions[itemPrintPreviewNote], SIGNAL(triggered()),   this,  SLOT(notePrintPreview()));
    //
    connect(actShow,	SIGNAL(triggered()), this, SLOT(show()));
    connect(actHide,	SIGNAL(triggered()), this, SLOT(hide()));

    // Adding toolbar's actions
    actions_changed();
    icons_size_changed();
    // Adding scripts
    cmd_changed();

    // Adding menu actions
    cmenu.addAction(actShow);
    cmenu.addAction(actHide);
    cmenu.addSeparator();
    cmenu.addAction(actions[itemAdd]);
    cmenu.addAction(actions[itemRemove]);
    cmenu.addAction(actions[itemRename]);
    cmenu.addSeparator();
    cmenu.addAction(actions[itemSetup]);
    cmenu.addAction(actions[itemInfo]);
    cmenu.addSeparator();
    cmenu.addAction(actions[itemExit]);
    tray.setIcon(QIcon(TRAY_ICON_FILE_NAME));
    tray.setContextMenu(&cmenu);
    connect(&tray, SIGNAL(activated(QSystemTrayIcon::ActivationReason)),
            this, SLOT(trayActivated(QSystemTrayIcon::ActivationReason)));
    tray.show();

    //Creating shortcuts
    Shared::addShortcut(new QShortcut(QKeySequence::New, this), tr("Create new note"));
        connect(Shared::shortcuts().last(), SIGNAL(activated()), this, SLOT(NewNote()));
    Shared::addShortcut(new QShortcut(QKeySequence::Close, this));
        connect(Shared::shortcuts().last(), SIGNAL(activated()), notes, SLOT(removeCurrentNote()));
    Shared::addShortcut(new QShortcut(Qt::Key_F2, this), tr("Rename current note"));
        connect(Shared::shortcuts().last(), SIGNAL(activated()), notes, SLOT(renameCurrentNote()));
    Shared::addShortcut(new QShortcut(QKeySequence::Back, this), tr("Go to previous note"));
        connect(Shared::shortcuts().last(), SIGNAL(activated()), this, SLOT(PreviousNote()));
    Shared::addShortcut(new QShortcut(QKeySequence::Forward, this), tr("Go to next note"));
        connect(Shared::shortcuts().last(), SIGNAL(activated()), this, SLOT(NextNote()));
    Shared::addShortcut(new QShortcut(QKeySequence::PreviousChild, this));
        connect(Shared::shortcuts().last(), SIGNAL(activated()), notes, SLOT(historyBack()));
    Shared::addShortcut(new QShortcut(QKeySequence::NextChild, this));
        connect(Shared::shortcuts().last(), SIGNAL(activated()), notes, SLOT(historyForward()));
    Shared::addShortcut(new QShortcut(QKeySequence::Find, this), tr("Search in the notes' text"));
        connect(Shared::shortcuts().last(), SIGNAL(activated()), actions[itemSearch], SLOT(toggle()));
    Shared::addShortcut(new QShortcut(Qt::Key_Escape, ui->edSearch, 0, 0, Qt::WidgetShortcut));
        connect(Shared::shortcuts().last(), SIGNAL(activated()), actions[itemSearch], SLOT(toggle()));
    Shared::addShortcut(new QShortcut(Qt::CTRL + Qt::Key_Q, this), tr("Exit program"));
        connect(Shared::shortcuts().last(), SIGNAL(activated()), qApp, SLOT(quit()));
    Shared::addShortcut(new QShortcut(QKeySequence::Bold, this), tr("Make selected text bold"));
        connect(Shared::shortcuts().last(), SIGNAL(activated()), this, SLOT(formatBold()));
    Shared::addShortcut(new QShortcut(QKeySequence::Italic, this), tr("Make selected text italic"));
        connect(Shared::shortcuts().last(), SIGNAL(activated()), this, SLOT(formatItalic()));
    Shared::addShortcut(new QShortcut(Qt::CTRL + Qt::Key_S, this), tr("Make selected text strikeout"));
        connect(Shared::shortcuts().last(), SIGNAL(activated()), this, SLOT(formatStrikeout()));
    Shared::addShortcut(new QShortcut(QKeySequence::Underline, this), tr("Make selected text underline"));
        connect(Shared::shortcuts().last(), SIGNAL(activated()), this, SLOT(formatUnderline()));

    for(int i=1; i<=9; ++i) //from Alt+1 to Alt+9
    {
        QShortcut* shortcut = new QShortcut(QKeySequence(Qt::ALT + Qt::Key_0+i), this);
        connect(shortcut, SIGNAL(activated()), &alt_mapper, SLOT(map()));
        alt_mapper.setMapping(shortcut, i-1);
    }
    connect(&alt_mapper, SIGNAL(mapped(int)), this, SLOT(ToNote(int)));
    //
    connect(&settings, SIGNAL(ShowHiddenChanged()), this, SLOT(warningSettingsChanged()));
    connect(&settings, SIGNAL(WindowStateChanged()), this, SLOT(windowStateChanged()));
    connect(&settings, SIGNAL(ToolbarItemsChanged()), this, SLOT(actions_changed()));
    connect(&settings, SIGNAL(IconsSizeChanged()), this, SLOT(icons_size_changed()));
    connect(&settings.getScriptModel(), SIGNAL(dataChanged(const QModelIndex&, const QModelIndex&)),
        this, SLOT(cmd_changed()));
    if(!settings.getHideStart()) show();
    //
    currentNoteChanged(-1, notes->currentIndex());
}

MainWindow::~MainWindow()
{
    // saving notes
    notes->saveAll();
    // saving title of last note
    if(notes->current()) {
        settings.setLastNote(notes->current()->fileName());
    }
    // saving dialog's params
    settings.setDialogGeometry(saveGeometry());
    settings.setDialogState(saveState());
    // saving scripts
    settings.setScripts();
    // syncing settings
    settings.save();
}

// Small little wrapper receiver for the note_create_widget signal
void MainWindow::SetCheckedInverse(bool checked)
{
	actions[itemAdd]->setChecked(!checked);
}

void MainWindow::NewNote()
{
	if(!note_create_widget)
	{
		note_create_widget = new NoteCreateWidget(this, notes);
		connect(note_create_widget, SIGNAL(closed(bool)), this, SLOT(SetCheckedInverse(bool)));
		note_create_widget->setWindowFlags(Qt::Dialog | Qt::FramelessWindowHint);
		note_create_widget->setFrameStyle(QFrame::StyledPanel | QFrame::Raised);
		note_create_widget->setFrameShadow(QFrame::Raised);
	}
	// TODO: Check if the toolbar is on the right side or bottom and 'flip' the note_create_widget
	if(ui->mainToolBar->orientation() == Qt::Horizontal)
		note_create_widget->move(ui->mainToolBar->mapToGlobal(QPoint(0,ui->mainToolBar->height())));
	else
		note_create_widget->move(ui->mainToolBar->mapToGlobal(QPoint(ui->mainToolBar->width(),0)));

	if(actions[itemAdd]->isChecked())
        note_create_widget->show();
	else
		note_create_widget->hide();
}

void MainWindow::NewNotePlain()
{
	notes->create(Note::type_text);
}

void MainWindow::NewNoteHTML()
{
	notes->create(Note::type_html);
}

void MainWindow::NewNoteTODO()
{
	notes->create(Note::type_todo);
}

void MainWindow::PreviousNote()
{
	if(notes->empty()) return;
	notes->getWidget()->setCurrentIndex(notes->currentIndex()-1);
}

void MainWindow::NextNote()
{
	if(notes->empty()) return;
	notes->getWidget()->setCurrentIndex(notes->currentIndex()+1);
}

void MainWindow::ToNote(int n)
{
	if(n>=notes->count()) return;
	notes->getWidget()->setCurrentIndex(n);
}

void MainWindow::CopyNote()
{
	if(notes->empty()) return;
    notes->current()->copy();
}

bool MainWindow::isNoteSupportsPrinting(const Note *note) const
{
    if (!note)
        return false;

    // Check printing support of note.
    if (note->isDocumentSupported() == false) {
        QMessageBox::warning(const_cast<MainWindow*>(this),
                             tr("Note printing"),
                             tr("There is not printing support for current note"));
        return false;
    }

    return true;
}

void MainWindow::notePrint()
{
    Note *currentNote = notes->current();

    if (!isNoteSupportsPrinting(currentNote))
        return;

#ifndef QT_NO_PRINTER
    QPrinter printer(QPrinter::HighResolution);
    QPrintDialog *dlg = new QPrintDialog(&printer, this);
    dlg->setWindowTitle(tr("Print note"));
    if (dlg->exec() == QDialog::Accepted) {
        if (!currentNote->document()) {
            QMessageBox::warning(this,
                                 tr("Note printing"),
                                 tr("Access error to note's text"));
            return;
        }
        currentNote->document()->print(&printer);
    }
    delete dlg;
#endif
}

void MainWindow::notePrintPdf()
{
    Note *currentNote = notes->current();

    if (!isNoteSupportsPrinting(currentNote))
        return;

    // Real printing of a note.
    QString defaultFileName = QDir::currentPath() + "/" + currentNote->title();
    QString fileName = QFileDialog::getSaveFileName(this, tr("Export PDF"),
                                                    defaultFileName, QString("*.pdf"));
    if (!fileName.isEmpty()) {
        if (QFileInfo(fileName).suffix().isEmpty())
            fileName.append(".pdf");
#ifndef QT_NO_PRINTER
        QPrinter printer(QPrinter::HighResolution);
        printer.setOutputFormat(QPrinter::PdfFormat);
        printer.setOutputFileName(fileName);
        if (!currentNote->document()) {
            QMessageBox::warning(this,
                                 tr("Note printing"),
                                 tr("Access error to note's text"));
            return;
        }
        currentNote->document()->print(&printer);
#endif
    }
}

void MainWindow::notePrintPreview()
{
    Note *currentNote = notes->current();

    if (!isNoteSupportsPrinting(currentNote))
        return;

#ifndef QT_NO_PRINTER
    QPrinter printer(QPrinter::HighResolution);
    QPrintPreviewDialog preview(&printer, this);
    connect(&preview, SIGNAL(paintRequested(QPrinter*)), SLOT(printPreview(QPrinter*)));
    preview.exec();
#endif
}

void MainWindow::printPreview(QPrinter *printer)
{
    Note *currentNote = notes->current();

    if (!isNoteSupportsPrinting(currentNote))
        return;

#ifndef QT_NO_PRINTER
    if (!currentNote->document()) {
        QMessageBox::warning(this,
                             tr("Note printing"),
                             tr("Access error to note's text"));
        return;
    }
    currentNote->document()->print(printer);
#endif
}

void MainWindow::trayActivated(QSystemTrayIcon::ActivationReason reason)
{
	switch(reason)
	{
		case QSystemTrayIcon::Trigger:
		{
			if(isHidden()) show();
			else hide();
			break;
		}
		default: break;
	}
}

void MainWindow::hideEvent(QHideEvent* event)
{
	Q_UNUSED(event)

	settings.setDialogGeometry(saveGeometry());
	actShow->setEnabled(true);
	actHide->setDisabled(true);
    if(notes->current()) {
        notes->saveAll();
    }

	if(note_create_widget && note_create_widget->isVisible())
	{
		actions[itemAdd]->setChecked(false);
		note_create_widget->hide();
	}
}

void MainWindow::showEvent(QShowEvent* event)
{
	Q_UNUSED(event)
	restoreGeometry(settings.getDialogGeometry());
	actShow->setEnabled(false);
	actHide->setDisabled(false);
}

void MainWindow::closeEvent(QCloseEvent *event)
{
	if(tray.isVisible())
	{
		hide();
		event->ignore();
	}

	if(note_create_widget && note_create_widget->isVisible())
	{
		actions[itemAdd]->setChecked(false);
		note_create_widget->hide();
	}
}

void MainWindow::moveEvent(QMoveEvent* event)
{
	Q_UNUSED(event)
	if(note_create_widget && note_create_widget->isVisible())
	{
		// TODO: Check if the toolbar is on the right side or bottom and 'flip' the note_create_widget
		if(ui->mainToolBar->orientation() == Qt::Horizontal)
			note_create_widget->move(ui->mainToolBar->mapToGlobal(QPoint(0,ui->mainToolBar->height())));
		else
			note_create_widget->move(ui->mainToolBar->mapToGlobal(QPoint(ui->mainToolBar->width(),0)));
	}
}

void MainWindow::showAboutDialog()
{
    aboutDialog dlg(this);
	dlg.exec();
}

void MainWindow::showPrefDialog()
{
    configDialog dlg(this);
	dlg.exec();
}

void MainWindow::windowStateChanged()
{
	Qt::WindowFlags flags = Qt::Window;
	if(settings.getHideFrame()) flags |= Qt::FramelessWindowHint;
	if(settings.getStayTop()) flags |= Qt::WindowStaysOnTopHint;
	bool window_is_visible = isVisible();
	setWindowFlags(flags);
	if(window_is_visible) show();
}

void MainWindow::warningSettingsChanged()
{
	QMessageBox::information(this, tr("Settings changed"),
			tr("You need restart application to get effect."));
}

void MainWindow::commandMenu()
{
	if(cmd_menu.actions().size()>0)
	{
		QPoint p = ui->mainToolBar->actionGeometry(actions[itemRun]).center()+pos();
		cmd_menu.exec(p);
	}
	else
	{
        QMessageBox(QMessageBox::Information,
                    tr("Commandlist is clear"),
                    tr("List of commands is clear!\nYou can add new commands in preferences.")).exec();
	}
}

void MainWindow::cmdExec(const QString & command)
{
	if(notes->empty()) return;
	QProcess p;
	QStringList args;
	args << notes->current()->absolutePath();
	p.start(command, args);
	if(p.waitForStarted())
	{
		if(p.waitForFinished(10000))
		{
			QByteArray result = p.readAll();
			if(settings.getScriptShowOutput()) tray.showMessage(command, QString::fromUtf8(result));
			if(settings.getScriptCopyOutput()) QApplication::clipboard()->setText(QString::fromUtf8(result));
		}
	}
}

void MainWindow::cmd_changed()
{
	cmd_menu.clear();
	ScriptModel& sm = settings.getScriptModel();
	for(int i=0; i<sm.rowCount(); ++i)
	{
		cmd_menu.addAction(QIcon(sm.getIcon(i)), sm.getName(i), &cmd_mapper, SLOT(map()));
		cmd_mapper.setMapping(cmd_menu.actions().last(), sm.getFile(i));
		connect(&cmd_mapper, SIGNAL(mapped(const QString &)), this, SLOT(cmdExec(const QString &)));
	}
	cmd_menu.addSeparator();
	cmd_menu.addAction(tr("Edit command list"), this, SLOT(edit_command_list()));
}

void MainWindow::actions_changed()
{
    // Build toolbar content according to toolbar configuration.
	ui->mainToolBar->clear();
	const QVector<int>& items = settings.getToolbarItems();
    for (int i = 0; i < items.size(); ++i)
	{
        if (items[i] == itemSeparator)
            ui->mainToolBar->addSeparator();
        else {
            QAction* action = actions[items[i]];
            regenerateAction(items[i], action);
            ui->mainToolBar->addAction(action);
        }
	}
}

void MainWindow::icons_size_changed() {
    QSize size(settings.getIconsSize(), settings.getIconsSize());
    ui->mainToolBar->setIconSize(size);
}

void MainWindow::edit_command_list()
{
    configDialog dlg(this);
	dlg.changeTabToCommands();
	dlg.exec();
}

void MainWindow::formatChanged(const QFont& font)
{
	actions[itemFormatBold]->setChecked(font.bold());
	actions[itemFormatItalic]->setChecked(font.italic());
	actions[itemFormatStrikeout]->setChecked(font.strikeOut());
	actions[itemFormatUnderline]->setChecked(font.underline());
}

void MainWindow::formatBold()
{
	if(notes->empty()) return;
	if(notes->current()->type()!=Note::type_html) return;
	QTextCharFormat format;
	bool is_bold = actions[itemFormatBold]->isChecked();
	format.setFontWeight(is_bold?QFont::Bold : QFont::Normal);
	notes->current()->setSelFormat(format);
}

void MainWindow::formatItalic()
{
	if(notes->empty()) return;
	if(notes->current()->type()!=Note::type_html) return;
	QTextCharFormat format;
	bool is_italic = actions[itemFormatItalic]->isChecked();
	format.setFontItalic(is_italic);
	notes->current()->setSelFormat(format);
}

void MainWindow::formatStrikeout()
{
	if(notes->empty()) return;
	if(notes->current()->type()!=Note::type_html) return;
	QTextCharFormat format;
	bool is_strikeout = actions[itemFormatStrikeout]->isChecked();
	format.setFontStrikeOut(is_strikeout);
	notes->current()->setSelFormat(format);
}

void MainWindow::formatUnderline()
{
	if(notes->empty()) return;
	if(notes->current()->type()!=Note::type_html) return;
	QTextCharFormat format;
	bool is_underline = actions[itemFormatUnderline]->isChecked();
	format.setFontUnderline(is_underline);
	notes->current()->setSelFormat(format);
}

void MainWindow::formatTextColor()
{
	if(notes->empty()) return;
	Note* note = notes->current();
	if(note->type()!=Note::type_html) return;
	QTextCharFormat format = note->getSelFormat();
	QColor color = format.foreground().color();
    QColorDialog dlg(color, this);
	if(dlg.exec()==QDialog::Accepted)
	{
		color = dlg.currentColor();
		format.setForeground(color);
		note->setSelFormat(format);
	}
}

//------------------------------------------------------------------------------
#include <QtDebug>

void MainWindow::currentNoteChanged(int old_index, int new_index)
{
	if(old_index!=-1)
	{
		Note* note = notes->get(old_index);
        //disconnecting old note
        if(note->type()==Note::type_html) disconnect(note, SIGNAL(formatChanged(QFont)), 0, 0);
	}
	//
	bool not_empty = !notes->empty();
	actions[itemPrev]->setEnabled(not_empty && new_index!=0); //if first note
	actions[itemNext]->setEnabled(not_empty && new_index!=notes->last()); //if last note
	actions[itemBack]->setEnabled(not_empty && notes->historyHasBack());
	actions[itemForward]->setEnabled(not_empty && notes->historyHasForward());
	actions[itemRemove]->setEnabled(not_empty);
	//
	Note* note = notes->current();
	if(note)
	{
		switch(note->type())
		{
	 case Note::type_html:
			{
				HtmlNote* htmlnote = dynamic_cast<HtmlNote*> (note);
				QFont font(htmlnote->getSelFormat().font());
				actions[itemFormatBold]->setChecked(font.bold());
				actions[itemFormatItalic]->setChecked(font.italic());
				actions[itemFormatStrikeout]->setChecked(font.strikeOut());
				actions[itemFormatUnderline]->setChecked(font.underline());
				connect(htmlnote, SIGNAL(formatChanged(QFont)), this, SLOT(formatChanged(QFont))); //connecting old note
				actions[itemFormatBold]->setEnabled(true);
				actions[itemFormatItalic]->setEnabled(true);
				actions[itemFormatStrikeout]->setEnabled(true);
				actions[itemFormatUnderline]->setEnabled(true);
				actions[itemFormatColor]->setEnabled(true);
			}
			break;
	 default:
			{
				actions[itemFormatBold]->setEnabled(false);
				actions[itemFormatItalic]->setEnabled(false);
				actions[itemFormatStrikeout]->setEnabled(false);
				actions[itemFormatUnderline]->setEnabled(false);
				actions[itemFormatColor]->setEnabled(false);
			}
			break;
		}
	}
	else
	{
		actions[itemFormatBold]->setEnabled(false);
		actions[itemFormatItalic]->setEnabled(false);
		actions[itemFormatStrikeout]->setEnabled(false);
		actions[itemFormatUnderline]->setEnabled(false);
		actions[itemFormatColor]->setEnabled(false);
	}
}

void MainWindow::showSearchBar(bool show)
{
	ui->wSearch->setVisible(show);
	if(show)
	{
		ui->edSearch->setFocus();
		if(!actions[itemSearch]->isChecked()) actions[itemSearch]->setChecked(true);
	}
	else ui->edSearch->clear();
}

/*
  Searching text in notes
*/
void MainWindow::Search(bool next)
{
	Q_UNUSED(next);
	if(notes->empty()) return;
	QString text(ui->edSearch->text());
	if(text.isEmpty()) return;
	notes->search(text);
}

void MainWindow::on_edSearch_textChanged(QString text)
{
	Q_UNUSED(text);
    Search(false);
}

void MainWindow::on_edSearch_returnPressed()
{
	Search(true);
}

//Retranslating ui on language change
void MainWindow::changeEvent(QEvent *e)
{
	QMainWindow::changeEvent(e);
	switch (e->type())
	{
	case QEvent::LanguageChange:
		ui->retranslateUi(this);
		//
		actions[itemAdd]->setText(ToolbarAction(itemAdd).text());
		actions[itemRemove]->setText(ToolbarAction(itemRemove).text());
		actions[itemRename]->setText(ToolbarAction(itemRename).text());
		actions[itemPrev]->setText(ToolbarAction(itemPrev).text());
		actions[itemNext]->setText(ToolbarAction(itemNext).text());
		actions[itemCopy]->setText(ToolbarAction(itemCopy).text());
		actions[itemSetup]->setText(ToolbarAction(itemSetup).text());
		actions[itemInfo]->setText(ToolbarAction(itemInfo).text());
		actions[itemRun]->setText(ToolbarAction(itemRun).text());
		actions[itemSearch]->setText(ToolbarAction(itemSearch).text());
		actions[itemExit]->setText(ToolbarAction(itemExit).text());
		actShow->setText(tr("Show"));
		actHide->setText(tr("Hide"));
		//
		notes->retranslate(settings.getLocaleCurrent());
		break;
	default: break;
    }
}

void MainWindow::on_btSearchClose_clicked()
{
	actions[itemSearch]->setChecked(false);
}