NotepadWindow::NotepadWindow(QWidget *parent)
: QMainWindow(parent)
{
txtEditor_= new QTextEdit(this);
setCentralWidget(txtEditor_);
//Establecemos el tamaño inicial de la ventana
this->setGeometry(30, 30, 800, 600);
//Establecemos el título de la ventana
this->setWindowTitle(tr("MI EDITOR DE TEXTO"));
//Inicializamos los menus
mainMenu_=new QMenuBar(this);
mnuArchivo_=new QMenu(tr("&Archivo"),this);
mainMenu_->addMenu(mnuArchivo_);
//creamos el toolbar
toolbar_=new QToolBar();
addToolBar(toolbar_);
setMenuBar(mainMenu_);
// Definimos las acciones del menu
actArchivoAbrir_=new QAction(tr("&Abrir"),this);
actArchivoAbrir_->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_O));
mnuArchivo_->addAction(actArchivoAbrir_);
actArchivoGuardar_=new QAction(tr("&Guardar"),this);
actArchivoGuardar_->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_S));
mnuArchivo_->addAction(actArchivoGuardar_);
actArchivoCerrar_=new QAction(tr("&Cerrar"),this);
actArchivoCerrar_->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_W));
mnuArchivo_->addAction(actArchivoCerrar_);
mnuEditar_ = new QMenu(tr("&Editar"));
mainMenu_->addMenu(mnuEditar_);
actEditarCopiar_ = new QAction(tr("&Copiar"), this);
actEditarCopiar_->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_C));
mnuEditar_->addAction(actEditarCopiar_);
actEditarPegar_ = new QAction(tr("&Pegar"), this);
actEditarPegar_->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_V));
mnuEditar_->addAction(actEditarPegar_);
actEditarCortar_ = new QAction(tr("&Cortar"), this);
actEditarCortar_->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_X));
mnuEditar_->addAction(actEditarCortar_);
actEditarDeshacer_ = new QAction(tr("&Deshacer"), this);
actEditarDeshacer_->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_Z));
mnuEditar_->addAction(actEditarDeshacer_);
actEditarRehacer_ = new QAction(tr("&Rehacer"), this);
actEditarRehacer_->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_I));
mnuEditar_->addAction(actEditarRehacer_);
mnuFormato_ = new QMenu(tr("&Formato"));
mainMenu_->addMenu(mnuFormato_);
actFormatoFuente_ = new QAction(tr("&Fuente"), this);
mnuFormato_->addAction(actFormatoFuente_);
mnuAyuda_=new QMenu(tr("&Ayuda"),this);
mainMenu_->addMenu(mnuAyuda_);
actAyudaAcercaDe_= new QAction(tr("&Acerca de"),this);
mnuAyuda_->addAction(actAyudaAcercaDe_);
// Las agregamos al toolbar
toolbar_->addAction(actArchivoAbrir_);
toolbar_->addAction(actArchivoGuardar_);
toolbar_->addAction(actArchivoCerrar_);
toolbar_->addAction(actEditarCopiar_ );
toolbar_->addAction(actEditarPegar_ );
toolbar_->addAction(actEditarCortar_ );
toolbar_->addAction(actEditarDeshacer_ );
toolbar_->addAction(actEditarRehacer_ );
toolbar_->addAction(actAyudaAcercaDe_);
//Agregamos la barra de menú a la ventana
this->setMenuBar(mainMenu_);
//Inicializamos el editor de texto
txtEditor_ = new QTextEdit(this);
//Agregamos el editor de texto a la ventana
this->setCentralWidget(txtEditor_);
// Mantenemos el toolbar fijo arriba
toolbar_->setAllowedAreas(Qt::TopToolBarArea);
toolbar_->setMovable(false);
// Definimos que el texto se muestre a la derecha del icono
toolbar_->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
// Definimos iconos para las acciones del toolbar
actArchivoAbrir_->setIcon(QIcon(":/new/prefix1/imagenes/abrir.png"));
actArchivoCerrar_->setIcon(QIcon(":/new/prefix1/imagenes/cerrar.png"));
actArchivoGuardar_->setIcon(QIcon(":/new/prefix1/imagenes/guardar.png"));
actEditarDeshacer_->setIcon(QIcon(":/new/prefix1/imagenes/deshacer.png"));
actEditarRehacer_->setIcon(QIcon(":/new/prefix1/imagenes/rehacer.png"));
actEditarCortar_->setIcon(QIcon(":/new/prefix1/imagenes/cortar.png"));
actEditarCopiar_->setIcon(QIcon(":/new/prefix1/imagenes/copiar.png"));
actEditarPegar_->setIcon(QIcon(":/new/prefix1/imagenes/pegar.png"));
actAyudaAcercaDe_->setIcon(QIcon(":/new/prefix1/imagenes/ayuda.png"));
actFormatoFuente_->setIcon(QIcon(":/new/prefix1/imagenes/fuente.jpg"));
// Nuevo toolbar para negrita subrayado y cursiva
addToolBarBreak();
newToolbar_ = new QToolBar(this);
newToolbar_->setAllowedAreas(Qt::TopToolBarArea);
newToolbar_->setMovable(false);
addToolBar(newToolbar_);
// Definimos las acciones
actEditarNegrita_ = new QAction(QIcon(":/new/prefix1/imagenes/negrita.jpg"), tr("Negrita"), this);
actEditarCursiva_ = new QAction(QIcon(":/new/prefix1/imagenes/cursiva.jpg"), tr("Cursiva"), this);
actEditarSubrayado_ = new QAction(QIcon(":/new/prefix1/imagenes/subrayado.jpg"), tr("Subrayado"), this);
// Las agregamos al toolbar
newToolbar_->addAction(actEditarNegrita_);
newToolbar_->addAction(actEditarCursiva_);
newToolbar_->addAction(actEditarSubrayado_);
//Conectamos las acciones de los menus con nuestros slots
connect(actArchivoAbrir_, SIGNAL(triggered()),this,SLOT(alAbrir()));
connect(actArchivoGuardar_, SIGNAL(triggered()),this,SLOT(alGuardar()));
connect(actArchivoCerrar_, SIGNAL(triggered()),this,SLOT(alCerrar()));
connect(actEditarCopiar_, SIGNAL(triggered()), txtEditor_, SLOT(copy()));
connect(actEditarPegar_, SIGNAL(triggered()), txtEditor_, SLOT(paste()));
connect(actEditarCortar_, SIGNAL(triggered()), txtEditor_, SLOT(cut()));
connect(actEditarDeshacer_, SIGNAL(triggered()), txtEditor_, SLOT(undo()));
connect(actEditarRehacer_, SIGNAL(triggered()), txtEditor_, SLOT(redo()));
connect(actFormatoFuente_, SIGNAL(triggered()), this,SLOT(alFuente()));
connect(actAyudaAcercaDe_, SIGNAL(triggered()), this,SLOT(alAcercaDe()));
connect(actEditarNegrita_, SIGNAL(triggered()), this, SLOT(alNegrita()));
connect(actEditarCursiva_, SIGNAL(triggered()), this, SLOT(alCursiva()));
connect(actEditarSubrayado_, SIGNAL(triggered()), this, SLOT(alSubrayado()));
}
//! [17]
void MainWindow::createActions()
//! [17] //! [18]
{
newAct = new QAction(QIcon(":/images/new.png"), tr("&New"), this);
newAct->setShortcuts(QKeySequence::New);
newAct->setStatusTip(tr("Create a new file"));
connect(newAct, SIGNAL(triggered()), this, SLOT(newFile()));
//! [19]
openAct = new QAction(QIcon(":/images/open.png"), tr("&Open..."), this);
openAct->setShortcuts(QKeySequence::Open);
openAct->setStatusTip(tr("Open an existing file"));
connect(openAct, SIGNAL(triggered()), this, SLOT(open()));
//! [18] //! [19]
saveAct = new QAction(QIcon(":/images/save.png"), tr("&Save"), this);
saveAct->setShortcuts(QKeySequence::Save);
saveAct->setStatusTip(tr("Save the document to disk"));
connect(saveAct, SIGNAL(triggered()), this, SLOT(save()));
saveAsAct = new QAction(tr("Save &As..."), this);
saveAsAct->setShortcuts(QKeySequence::SaveAs);
saveAsAct->setStatusTip(tr("Save the document under a new name"));
connect(saveAsAct, SIGNAL(triggered()), this, SLOT(saveAs()));
//! [20]
exitAct = new QAction(tr("E&xit"), this);
exitAct->setShortcuts(QKeySequence::Quit);
//! [20]
exitAct->setStatusTip(tr("Exit the application"));
connect(exitAct, SIGNAL(triggered()), this, SLOT(close()));
//! [21]
cutAct = new QAction(QIcon(":/images/cut.png"), tr("Cu&t"), this);
//! [21]
cutAct->setShortcuts(QKeySequence::Cut);
cutAct->setStatusTip(tr("Cut the current selection's contents to the "
"clipboard"));
connect(cutAct, SIGNAL(triggered()), textEdit, SLOT(cut()));
copyAct = new QAction(QIcon(":/images/copy.png"), tr("&Copy"), this);
copyAct->setShortcuts(QKeySequence::Copy);
copyAct->setStatusTip(tr("Copy the current selection's contents to the "
"clipboard"));
connect(copyAct, SIGNAL(triggered()), textEdit, SLOT(copy()));
pasteAct = new QAction(QIcon(":/images/paste.png"), tr("&Paste"), this);
pasteAct->setShortcuts(QKeySequence::Paste);
pasteAct->setStatusTip(tr("Paste the clipboard's contents into the current "
"selection"));
connect(pasteAct, SIGNAL(triggered()), textEdit, SLOT(paste()));
aboutAct = new QAction(tr("&About"), this);
aboutAct->setStatusTip(tr("Show the application's About box"));
connect(aboutAct, SIGNAL(triggered()), this, SLOT(about()));
//! [22]
aboutQtAct = new QAction(tr("About &Qt"), this);
aboutQtAct->setStatusTip(tr("Show the Qt library's About box"));
connect(aboutQtAct, SIGNAL(triggered()), qApp, SLOT(aboutQt()));
//! [22]
//! [23]
cutAct->setEnabled(false);
//! [23] //! [24]
copyAct->setEnabled(false);
connect(textEdit, SIGNAL(copyAvailable(bool)),
cutAct, SLOT(setEnabled(bool)));
connect(textEdit, SIGNAL(copyAvailable(bool)),
copyAct, SLOT(setEnabled(bool)));
}
void SCgView::createActions()
{
QAction* sep = new QAction(this);
sep->setSeparator(true);
mActionsList.append(sep);
mActionChangeContent = new QAction(mWindow->findIcon("edit-content-change.png"),tr("Set content"),mWindow);
mActionChangeContent->setShortcut(QKeySequence( tr("C") ));
connect(mActionChangeContent, SIGNAL(triggered()), this, SLOT(changeContent()));
mActionShowContent = new QAction(tr("Show content"),mWindow);
mActionShowContent->setCheckable(true);
mActionShowContent->setShortcut(QKeySequence( tr("H") ));
connect(mActionShowContent, SIGNAL(triggered(bool)), this, SLOT(setContentVisible(bool)));
mActionShowAllContent = new QAction(tr("Show all content"), mWindow);
connect(mActionShowAllContent, SIGNAL(triggered(bool)), this, SLOT(setContentVisible(bool)));
mActionHideAllContent = new QAction(tr("Hide all content"), mWindow);
connect(mActionHideAllContent, SIGNAL(triggered(bool)), this, SLOT(setContentVisible(bool)));
mActionDeleteContent = new QAction(mWindow->findIcon("edit-content-delete.png"), tr("Delete content"), mWindow);
mActionDeleteContent->setShortcut(QKeySequence( tr("D") ));
connect(mActionDeleteContent, SIGNAL(triggered()), this, SLOT(deleteContent()));
mActionChangeIdtf = new QAction(mWindow->findIcon("edit-change-idtf.png"), tr("Change identifier"), mWindow);
mActionChangeIdtf->setShortcut(QKeySequence( tr("I") ));
connect(mActionChangeIdtf, SIGNAL(triggered()), this, SLOT(changeIdentifier()));
mActionDelete = new QAction(QIcon::fromTheme("edit-delete", mWindow->findIcon("edit-delete.png")), tr("Delete"), mWindow);
mActionDelete->setShortcut(QKeySequence::Delete);
connect(mActionDelete, SIGNAL(triggered()), this, SLOT(deleteSelected()));
mActionContourDelete = new QAction(mWindow->findIcon("edit-delete.png"), tr("Delete contour"), mWindow);
mActionContourDelete->setShortcut( QKeySequence(tr("Backspace")) );
connect(mActionContourDelete, SIGNAL(triggered()), this, SLOT(deleteJustContour()));
mActionSwapPairOrient = new QAction(mWindow->findIcon("edit-swap-pair.png"), tr("Swap orientation"), mWindow);
mActionSwapPairOrient->setShortcut( QKeySequence(tr("S")));
connect(mActionSwapPairOrient, SIGNAL(triggered()), this, SLOT(swapPairOrient()));
mActionCopy = new QAction(QIcon::fromTheme("edit-copy", mWindow->findIcon("edit-copy.png")), tr("Copy"),this);
mActionCopy->setShortcut(QKeySequence::Copy);
connect(mActionCopy, SIGNAL(triggered()), mWindow, SLOT(copy()));
mActionCut = new QAction(QIcon::fromTheme("edit-cut", mWindow->findIcon("edit-cut.png")), tr("Cut"),this);
mActionCut->setShortcut(QKeySequence::Cut);
connect(mActionCut, SIGNAL(triggered()), mWindow, SLOT(cut()));
mActionPaste = new QAction(QIcon::fromTheme("edit-paste", mWindow->findIcon("edit-paste.png")), tr("Paste"),this);
mActionPaste->setShortcut(QKeySequence::Paste);
connect(mActionPaste, SIGNAL(triggered()), mWindow, SLOT(paste()));
mActionSelectAll = new QAction(QIcon::fromTheme("edit-select-all", mWindow->findIcon("edit-select-all.png")), tr("Select All"),this);
mActionSelectAll->setShortcut(QKeySequence::SelectAll);
connect(mActionSelectAll, SIGNAL(triggered()), this, SLOT(selectAllCommand()));
mActionChangeConstPair=new QAction(tr("Change const pair"),mWindow);
mActionChangeConstPair->setShortcut(QKeySequence( tr("Alt+T") ));
connect(mActionChangeConstPair, SIGNAL(triggered()), this, SLOT(changeConstPair()));
mActionChangeVarPair=new QAction(tr("Change variant pair"),mWindow);
mActionChangeVarPair->setShortcut(QKeySequence( tr("Alt+P") ));
connect(mActionChangeVarPair, SIGNAL(triggered()), this, SLOT(changeVarPair()));
mActionChangeConstNode=new QAction(tr("Change const node"),mWindow);
mActionChangeConstNode->setShortcut(QKeySequence( tr("Alt+C") ));
connect(mActionChangeConstNode, SIGNAL(triggered()), this, SLOT(changeConstNode()));
mActionChangeVarNode=new QAction(tr("Change variant node"),mWindow);
mActionChangeVarNode->setShortcut(QKeySequence( tr("Alt+S") ));
connect(mActionChangeVarNode, SIGNAL(triggered()), this, SLOT(changeVarNode()));
mActionsList.append(mActionChangeContent);
mActionsList.append(mActionShowContent);
mActionsList.append(mActionShowAllContent);
mActionsList.append(mActionHideAllContent);
mActionsList.append(mActionDeleteContent);
sep = new QAction(this);
sep->setSeparator(true);
mActionsList.append(sep);
mActionsList.append(mActionChangeIdtf);
mActionsList.append(mActionSwapPairOrient);
sep = new QAction(this);
sep->setSeparator(true);
mActionsList.append(sep);
mActionsList.append(mActionCopy);
mActionsList.append(mActionCut);
mActionsList.append(mActionPaste);
sep = new QAction(this);
sep->setSeparator(true);
mActionsList.append(sep);
mActionsList.append(mActionSelectAll);
sep = new QAction(this);
sep->setSeparator(true);
mActionsList.append(sep);
mActionsList.append(mActionContourDelete);
mActionsList.append(mActionDelete);
mActionsList.append(mActionChangeConstPair);
mActionsList.append(mActionChangeVarPair);
mActionsList.append(mActionChangeConstNode);
mActionsList.append(mActionChangeVarNode);
}
void ProgramWindow::setup()
{
if (parentWidget() == NULL) {
resize(500,700);
setAttribute(Qt::WA_DeleteOnClose, true);
}
QFrame * mainFrame = new QFrame(this);
QFrame * headerFrame = createHeader();
QFrame * centerFrame = createCenter();
layout()->setMargin(0);
layout()->setSpacing(0);
QGridLayout *layout = new QGridLayout(mainFrame);
layout->setMargin(0);
layout->setSpacing(0);
layout->addWidget(headerFrame,0,0);
layout->addWidget(centerFrame,1,0);
setCentralWidget(mainFrame);
setSizePolicy(QSizePolicy::Expanding,QSizePolicy::Expanding);
QSettings settings;
if (!settings.value("programwindow/state").isNull()) {
restoreState(settings.value("programwindow/state").toByteArray());
}
if (!settings.value("programwindow/geometry").isNull()) {
restoreGeometry(settings.value("programwindow/geometry").toByteArray());
}
installEventFilter(this);
// Setup new menu bar for the programming window
QMenuBar * menubar = NULL;
if (parentWidget()) {
QMainWindow * mainWindow = qobject_cast<QMainWindow *>(parentWidget());
if (mainWindow) menubar = mainWindow->menuBar();
}
if (menubar == NULL) menubar = menuBar();
m_fileMenu = menubar->addMenu(tr("&File"));
QAction *currentAction = new QAction(tr("New Code File"), this);
currentAction->setShortcut(tr("Ctrl+N"));
currentAction->setStatusTip(tr("Create a new program"));
connect(currentAction, SIGNAL(triggered()), this, SLOT(addTab()));
m_fileMenu->addAction(currentAction);
currentAction = new QAction(tr("&Open Code File..."), this);
currentAction->setShortcut(tr("Ctrl+O"));
currentAction->setStatusTip(tr("Open a program"));
connect(currentAction, SIGNAL(triggered()), this, SLOT(loadProgramFile()));
m_fileMenu->addAction(currentAction);
m_fileMenu->addSeparator();
m_saveAction = new QAction(tr("&Save Code File"), this);
m_saveAction->setShortcut(tr("Ctrl+S"));
m_saveAction->setStatusTip(tr("Save the current program"));
connect(m_saveAction, SIGNAL(triggered()), this, SLOT(save()));
m_fileMenu->addAction(m_saveAction);
currentAction = new QAction(tr("Rename Code File"), this);
currentAction->setStatusTip(tr("Rename the current program"));
connect(currentAction, SIGNAL(triggered()), this, SLOT(rename()));
m_fileMenu->addAction(currentAction);
currentAction = new QAction(tr("Duplicate tab"), this);
currentAction->setStatusTip(tr("Copies the current program into a new tab"));
connect(currentAction, SIGNAL(triggered()), this, SLOT(duplicateTab()));
m_fileMenu->addAction(currentAction);
m_fileMenu->addSeparator();
currentAction = new QAction(tr("Remove tab"), this);
currentAction->setShortcut(tr("Ctrl+W"));
currentAction->setStatusTip(tr("Remove the current program from the sketch"));
connect(currentAction, SIGNAL(triggered()), this, SLOT(closeCurrentTab()));
m_fileMenu->addAction(currentAction);
m_fileMenu->addSeparator();
m_printAction = new QAction(tr("&Print..."), this);
m_printAction->setShortcut(tr("Ctrl+P"));
m_printAction->setStatusTip(tr("Print the current program"));
connect(m_printAction, SIGNAL(triggered()), this, SLOT(print()));
m_fileMenu->addAction(m_printAction);
m_fileMenu->addSeparator();
currentAction = new QAction(tr("&Quit"), this);
currentAction->setShortcut(tr("Ctrl+Q"));
currentAction->setStatusTip(tr("Quit the application"));
currentAction->setMenuRole(QAction::QuitRole);
connect(currentAction, SIGNAL(triggered()), qApp, SLOT(closeAllWindows2()));
m_fileMenu->addAction(currentAction);
m_editMenu = menubar->addMenu(tr("&Edit"));
m_undoAction = new QAction(tr("Undo"), this);
m_undoAction->setShortcuts(QKeySequence::Undo);
m_undoAction->setEnabled(false);
connect(m_undoAction, SIGNAL(triggered()), this, SLOT(undo()));
m_editMenu->addAction(m_undoAction);
m_redoAction = new QAction(tr("Redo"), this);
m_redoAction->setShortcuts(QKeySequence::Redo);
m_redoAction->setEnabled(false);
connect(m_redoAction, SIGNAL(triggered()), this, SLOT(redo()));
m_editMenu->addAction(m_redoAction);
m_editMenu->addSeparator();
m_cutAction = new QAction(tr("&Cut"), this);
m_cutAction->setShortcut(tr("Ctrl+X"));
m_cutAction->setStatusTip(tr("Cut selection"));
m_cutAction->setEnabled(false);
connect(m_cutAction, SIGNAL(triggered()), this, SLOT(cut()));
m_editMenu->addAction(m_cutAction);
m_copyAction = new QAction(tr("&Copy"), this);
m_copyAction->setShortcut(tr("Ctrl+C"));
m_copyAction->setStatusTip(tr("Copy selection"));
m_copyAction->setEnabled(false);
connect(m_copyAction, SIGNAL(triggered()), this, SLOT(copy()));
m_editMenu->addAction(m_copyAction);
currentAction = new QAction(tr("&Paste"), this);
currentAction->setShortcut(tr("Ctrl+V"));
currentAction->setStatusTip(tr("Paste clipboard contents"));
// TODO: Check clipboard status and disable appropriately here
connect(currentAction, SIGNAL(triggered()), this, SLOT(paste()));
m_editMenu->addAction(currentAction);
m_editMenu->addSeparator();
currentAction = new QAction(tr("&Select All"), this);
currentAction->setShortcut(tr("Ctrl+A"));
currentAction->setStatusTip(tr("Select all text"));
connect(currentAction, SIGNAL(triggered()), this, SLOT(selectAll()));
m_editMenu->addAction(currentAction);
m_programMenu = menubar->addMenu(tr("&Code"));
QMenu *languageMenu = new QMenu(tr("Select language"), this);
m_programMenu->addMenu(languageMenu);
QString currentLanguage = settings.value("programwindow/language", "").toString();
QStringList languages = getAvailableLanguages();
QActionGroup *languageActionGroup = new QActionGroup(this);
foreach (QString language, languages) {
currentAction = new QAction(language, this);
currentAction->setCheckable(true);
m_languageActions.insert(language, currentAction);
languageActionGroup->addAction(currentAction);
languageMenu->addAction(currentAction);
if (!currentLanguage.isEmpty()) {
if (language.compare(currentLanguage) == 0) {
currentAction->setChecked(true);
}
}
}
QFESPIMB040ScriptedAcquisition::QFESPIMB040ScriptedAcquisition(QFESPIMB040MainWindow2* mainWindow, QFESPIMB040AcquisitionTools* acqTools, QFPluginLogService* log, QWidget* parent, QFPluginServices* pluginServices, QFESPIMB040OpticsSetupBase* opticsSetup, QFESPIMB040AcquisitionDescription* acqDescription, QFESPIMB040ExperimentDescription* expDescription, QString /*configDirectory*/) :
QWidget(parent),
ui(new Ui::QFESPIMB040ScriptedAcquisition)
{
this->m_pluginServices=pluginServices;
this->opticsSetup=opticsSetup;
this->acqDescription=acqDescription;
this->expDescription=expDescription;
this->log=log;
this->acqTools=acqTools;
this->mainWindow=mainWindow;
acquisitionTools=new QFESPIMB040ScriptedAcquisitionTools(this, mainWindow, acqTools, log, this, pluginServices, opticsSetup, acqDescription, expDescription);
instrumentControl=new QFESPIMB040ScriptedAcquisitionInstrumentControl(this, mainWindow, acqTools, log, this, pluginServices, opticsSetup, acqDescription, expDescription);
acquisitionControl=new QFESPIMB040ScriptedAcquisitionAcquisitionControl(this, mainWindow, acqTools, log, this, pluginServices, opticsSetup, acqDescription, expDescription);
engine=new QScriptEngine();
ui->setupUi(this);
findDlg=new QFESPIMB040FindDialog(this);
replaceDlg=new QFESPIMB040ReplaceDialog(this);
highlighter=new QFQtScriptHighlighter("", ui->edtScript->getEditor()->document());
completer = new QCompleter(ui->edtScript->getEditor());
completermodel=modelFromFile(ProgramOptions::getInstance()->getAssetsDirectory()+"/qtscript/completer.txt");
completer->setModel(completermodel);
completer->setModelSorting(QCompleter::CaseInsensitivelySortedModel);
completer->setCaseSensitivity(Qt::CaseInsensitive);
completer->setWrapAround(false);
ui->edtScript->getEditor()->setCompleter(completer);
recentMaskFiles=new QRecentFilesMenu(this);
recentMaskFiles->setUseSystemFileIcons(false);
recentMaskFiles->setAlwaysEnabled(true);
connect(recentMaskFiles, SIGNAL(openRecentFile(QString)), this, SLOT(openScriptNoAsk(QString)));
ui->btnOpen->setMenu(recentMaskFiles);
connect(ui->edtScript->getEditor(), SIGNAL(cursorPositionChanged()), this, SLOT(edtScript_cursorPositionChanged()));
cutAct = new QFActionWithNoMenuRole(QIcon(":/spimb040/script_cut.png"), tr("Cu&t"), this);
cutAct->setShortcut(tr("Ctrl+X"));
cutAct->setStatusTip(tr("Cut the current selection's contents to the "
"clipboard"));
connect(cutAct, SIGNAL(triggered()), ui->edtScript->getEditor(), SLOT(cut()));
copyAct = new QFActionWithNoMenuRole(QIcon(":/spimb040/script_copy.png"), tr("&Copy"), this);
copyAct->setShortcut(tr("Ctrl+C"));
copyAct->setStatusTip(tr("Copy the current selection's contents to the "
"clipboard"));
connect(copyAct, SIGNAL(triggered()), ui->edtScript->getEditor(), SLOT(copy()));
pasteAct = new QFActionWithNoMenuRole(QIcon(":/spimb040/script_paste.png"), tr("&Paste"), this);
pasteAct->setShortcut(tr("Ctrl+V"));
pasteAct->setStatusTip(tr("Paste the clipboard's contents into the current "
"selection"));
connect(pasteAct, SIGNAL(triggered()), ui->edtScript->getEditor(), SLOT(paste()));
undoAct = new QFActionWithNoMenuRole(QIcon(":/spimb040/script_undo.png"), tr("&Undo"), this);
undoAct->setShortcut(tr("Ctrl+Z"));
undoAct->setStatusTip(tr("Undo the last change "));
connect(undoAct, SIGNAL(triggered()), ui->edtScript->getEditor(), SLOT(undo()));
redoAct = new QFActionWithNoMenuRole(QIcon(":/spimb040/script_redo.png"), tr("&Redo"), this);
redoAct->setShortcut(tr("Ctrl+Shift+Z"));
redoAct->setStatusTip(tr("Redo the last undone change "));
connect(redoAct, SIGNAL(triggered()), ui->edtScript->getEditor(), SLOT(redo()));
findAct = new QFActionWithNoMenuRole(QIcon(":/spimb040/script_find.png"), tr("&Find ..."), this);
findAct->setShortcut(tr("Ctrl+F"));
findAct->setStatusTip(tr("Find a string in sequence "));
connect(findAct, SIGNAL(triggered()), this, SLOT(findFirst()));
findNextAct = new QFActionWithNoMenuRole(QIcon(":/spimb040/script_find_next.png"), tr("Find &next"), this);
findNextAct->setShortcut(tr("F3"));
findNextAct->setStatusTip(tr("Find the next occurence "));
connect(findNextAct, SIGNAL(triggered()), this, SLOT(findNext()));
findNextAct->setEnabled(false);
replaceAct = new QFActionWithNoMenuRole(QIcon(":/spimb040/script_find_replace.png"), tr("Find && &replace ..."), this);
replaceAct->setShortcut(tr("Ctrl+R"));
replaceAct->setStatusTip(tr("Find a string in sequence and replace it with another string "));
connect(replaceAct, SIGNAL(triggered()), this, SLOT(replaceFirst()));
commentAct = new QFActionWithNoMenuRole(tr("&Comment text"), this);
commentAct->setShortcut(tr("Ctrl+B"));
commentAct->setStatusTip(tr("add (single line) comment at the beginning of each line "));
connect(commentAct, SIGNAL(triggered()), ui->edtScript->getEditor(), SLOT(comment()));
unCommentAct = new QFActionWithNoMenuRole(tr("&Uncomment text"), this);
unCommentAct->setShortcut(tr("Ctrl+Shift+B"));
unCommentAct->setStatusTip(tr("remove (single line) comment at the beginning of each line "));
connect(unCommentAct, SIGNAL(triggered()), ui->edtScript->getEditor(), SLOT(uncomment()));
indentAct = new QFActionWithNoMenuRole(QIcon(":/spimb040/script_indent.png"), tr("&Increase indention"), this);
commentAct->setShortcut(tr("Ctrl+I"));
indentAct->setStatusTip(tr("increase indention "));
connect(indentAct, SIGNAL(triggered()), ui->edtScript->getEditor(), SLOT(indentInc()));
unindentAct = new QFActionWithNoMenuRole(QIcon(":/spimb040/script_unindent.png"), tr("&Decrease indention"), this);
unindentAct->setShortcut(tr("Ctrl+Shift+I"));
unindentAct->setStatusTip(tr("decrease indention "));
connect(unindentAct, SIGNAL(triggered()), ui->edtScript->getEditor(), SLOT(indentDec()));
gotoLineAct = new QFActionWithNoMenuRole(tr("&Goto line ..."), this);
gotoLineAct->setShortcut(tr("Alt+G"));
gotoLineAct->setStatusTip(tr("goto a line in the opened file "));
connect(gotoLineAct, SIGNAL(triggered()), this, SLOT(gotoLine()));
printAct = new QFActionWithNoMenuRole(QIcon(":/spimb040/script_print.png"), tr("&Print ..."), this);
printAct->setStatusTip(tr("print the current SDFF file "));
connect(printAct, SIGNAL(triggered()), this, SLOT(print()));
cutAct->setEnabled(false);
copyAct->setEnabled(false);
undoAct->setEnabled(false);
redoAct->setEnabled(false);
connect(ui->edtScript->getEditor(), SIGNAL(copyAvailable(bool)), cutAct, SLOT(setEnabled(bool)));
connect(ui->edtScript->getEditor(), SIGNAL(copyAvailable(bool)), copyAct, SLOT(setEnabled(bool)));
connect(ui->edtScript->getEditor(), SIGNAL(undoAvailable(bool)), undoAct, SLOT(setEnabled(bool)));
connect(ui->edtScript->getEditor(), SIGNAL(redoAvailable(bool)), redoAct, SLOT(setEnabled(bool)));
connect(ui->edtScript->getEditor(), SIGNAL(findNextAvailable(bool)), findNextAct, SLOT(setEnabled(bool)));
QMenu* menuMore=new QMenu(ui->tbMoreOptions);
menuMore->addAction(indentAct);
menuMore->addAction(unindentAct);
menuMore->addAction(commentAct);
menuMore->addAction(unCommentAct);
menuMore->addSeparator();
menuMore->addAction(gotoLineAct);
menuMore->addAction(findAct);
menuMore->addAction(replaceAct);
menuMore->addAction(findNextAct);
ui->tbMoreOptions->setMenu(menuMore);
ui->tbFind->setDefaultAction(findAct);
ui->tbFindNext->setDefaultAction(findNextAct);
ui->tbReplace->setDefaultAction(replaceAct);
ui->tbPrint->setDefaultAction(printAct);
ui->tbCopy->setDefaultAction(copyAct);
ui->tbCut->setDefaultAction(cutAct);
ui->tbPaste->setDefaultAction(pasteAct);
ui->tbRedo->setDefaultAction(redoAct);
ui->tbUndo->setDefaultAction(undoAct);
updateReplaces();
//bindLineEdit(ui->edtPrefix1);
ui->btnCancel->setVisible(false);
ui->widProgress->setVisible(false);
ui->labStatus->setVisible(false);
setScriptFilename(tr("new_acquisition_script.js"));
QDir d(QFPluginServices::getInstance()->getPluginHelpDirectory("ext_spimb040")+"acquisition_script/");
QStringList filter;
filter<<"*.html"<<"*.htm"<<"*.txt";
QStringList files=d.entryList(filter, QDir::Files);
threadsFinished=0;
maxThreads=2;
QList<QStringList> absFiles;
for (int i=0; i<maxThreads; i++) {
QStringList sl;
absFiles.push_back(sl);
}
for (int i=0; i<files.size(); i++) {
QString file=d.absoluteFilePath(files[i]);
absFiles[i%maxThreads].append(file);
}
for (int i=0; i<maxThreads; i++) {
threads.append(new QFESPIMB040ScriptedAcquisitionDocSearchThread(absFiles[i], this));
connect(threads[i], SIGNAL(finished()), this, SLOT(threadFinished()));
connect(threads[i], SIGNAL(foundFunction(QString,QString,QString)), this, SLOT(addFunction(QString,QString,QString)));
}
QTimer::singleShot(10, this, SLOT(delayedStartSearchThreads()));
}
void MainWindow::initMenus()
{
/*Create Actions*/
newFileAction=new QAction(tr("&New"), this);
newFileAction->setToolTip("Create a new file");
newFileAction->setStatusTip("New Document");
newFileAction->setIcon(QIcon(":/images/filenew.png"));
newFileAction->setShortcut(QKeySequence("Ctrl+N"));
newFileAction->showStatusText(this->statusBar());
// newFileAction->setShortcutContext(Qt::ShortcutContext);
openFileAction=new QAction(tr("O&pen"), this);
openFileAction->setToolTip("Open an existing file");
openFileAction->setIcon(QIcon(":/images/fileopen.png"));
openFileAction->setShortcut(QKeySequence("Ctrl+O"));
saveFileAction=new QAction(tr("&Save"), this);
saveFileAction->setToolTip("Save current file");
saveFileAction->setIcon(QIcon(":/images/filesave.png"));
saveAsFileAction=new QAction(tr("Save &As"), this);
saveAsFileAction->setIcon(QIcon(":/images/filesaveas.png"));
exitFileAction=new QAction(tr("E&xit"),this);
exitFileAction->setToolTip("Exit the Application");
exitFileAction->setIcon(QIcon(":/images/fileexit.png"));
copyEditAction=new QAction(tr("&Copy"), this);
copyEditAction->setToolTip("Copy");
copyEditAction->setIcon(QIcon(":/images/editcopy.png"));
pasteEditAction=new QAction(tr("P&aste"), this);
pasteEditAction->setToolTip("Paste");
pasteEditAction->setIcon(QIcon(":/images/editpaste.png"));
fontEditAction=new QAction(tr("F&ont"), this);
fontEditAction->setToolTip("Change Font");
fontEditAction->setIcon(QIcon(":/images/editfont.png"));
cutEditAction=new QAction(tr("C&ut"), this);
cutEditAction->setToolTip("Cut");
cutEditAction->setIcon(QIcon(":/images/editcut.png"));
toolEditAction=new QAction(tr("Tool &Bar"),this);
toolEditAction->setIcon(QIcon(":/images/edittool.png"));
selectEditAction=new QAction(tr("Select All"),this);
selectEditAction->setIcon(QIcon(":/images/editselect.png"));
aboutHelpAction=new QAction(tr("&About"), this);
aboutHelpAction->setToolTip("About this application");
aboutHelpAction->setIcon(QIcon(":/images/helpabout.png"));
/*Connections*/
connect(fontEditAction,SIGNAL(triggered()),this,SLOT(changeFont()));
connect(exitFileAction,SIGNAL(triggered()),this,SLOT(close()));
connect(aboutHelpAction,SIGNAL(triggered()),this,SLOT(aboutMe()));
connect(copyEditAction,SIGNAL(triggered()),textArea,SLOT(copy()));
connect(cutEditAction,SIGNAL(triggered()),textArea,SLOT(cut()));
connect(pasteEditAction,SIGNAL(triggered()),textArea,SLOT(paste()));
connect(selectEditAction,SIGNAL(triggered()),textArea,SLOT(selectAll()));
connect(openFileAction,SIGNAL(triggered()),this,SLOT(openFileSlot()));
connect(saveFileAction,SIGNAL(triggered()),this,SLOT(saveFileSlot()));
connect(newFileAction,SIGNAL(triggered()),this,SLOT(newFileSlot()));
connect(saveAsFileAction,SIGNAL(triggered()),this,SLOT(saveAsFileSlot()));
connect(textArea,SIGNAL(textChanged()),this,SLOT(isModified()));
connect(textArea,SIGNAL(pasteAvailable(bool)),pasteEditAction,SLOT(setEnabled(bool)));
toolEditAction->setCheckable(true);
toolEditAction->setChecked(true);
/*Menu Init*/
fileMenu = menuBar()->addMenu(tr("&File"));
//fileMenu->setStyle();
fileMenu->addAction(newFileAction);
fileMenu->addAction(openFileAction);
fileMenu->addAction(saveFileAction);
fileMenu->addAction(saveAsFileAction);
fileMenu->addAction(exitFileAction);
/*---*/
editMenu = menuBar()->addMenu(tr("&Edit"));
editMenu->addAction(cutEditAction);
editMenu->addAction(copyEditAction);
editMenu->addAction(pasteEditAction);
editMenu->addAction(selectEditAction);
editMenu->addSeparator();
editMenu->addAction(fontEditAction);
editMenu->addAction(toolEditAction);
/*---*/
helpMenu = menuBar()->addMenu(tr("&Help"));
helpMenu->addAction(aboutHelpAction);
}
void sample :: sum(const sample& s, int start) {
paste(s, start, false);
} // sum()
int main(int argc, char ** argv)
{
clock_t t0;
t0 = clock();
bool print = true;
if (argc==1)
{
help();
exit(0);
}
std::string cmd(argv[1]);
//primitive programs that do not require help pages and summary statistics by default
if (argc>1 && cmd=="view")
{
print = view(argc-1, ++argv);
}
else if (argc>1 && cmd=="index")
{
print = index(argc-1, ++argv);
}
else if (argc>1 && cmd=="merge")
{
print = merge(argc-1, ++argv);
}
else if (argc>1 && cmd=="paste")
{
print = paste(argc-1, ++argv);
}
else if (argc>1 && cmd=="concat")
{
print = concat(argc-1, ++argv);
}
else if (argc>1 && cmd=="subset")
{
subset(argc-1, ++argv);
}
else if (argc>1 && cmd=="decompose")
{
decompose(argc-1, ++argv);
}
else if (argc>1 && cmd=="normalize")
{
print = normalize(argc-1, ++argv);
}
else if (argc>1 && cmd=="config")
{
config(argc-1, ++argv);
}
else if (argc>1 && cmd=="mergedups")
{
merge_duplicate_variants(argc-1, ++argv);
}
else if (argc>1 && cmd=="remove_overlap")
{
remove_overlap(argc-1, ++argv);
}
else if (argc>1 && cmd=="peek")
{
peek(argc-1, ++argv);
}
else if (argc>1 && cmd=="partition")
{
partition(argc-1, ++argv);
}
else if (argc>1 && cmd=="annotate_variants")
{
annotate_variants(argc-1, ++argv);
}
else if (argc>1 && cmd=="annotate_regions")
{
annotate_regions(argc-1, ++argv);
}
else if (argc>1 && cmd=="annotate_dbsnp_rsid")
{
annotate_dbsnp_rsid(argc-1, ++argv);
}
else if (argc>1 && cmd=="discover")
{
discover(argc-1, ++argv);
}
else if (argc>1 && cmd=="merge_candidate_variants")
{
merge_candidate_variants(argc-1, ++argv);
}
else if (argc>1 && cmd=="union_variants")
{
union_variants(argc-1, ++argv);
}
else if (argc>1 && cmd=="genotype")
{
genotype2(argc-1, ++argv);
}
else if (argc>1 && cmd=="characterize")
{
genotype(argc-1, ++argv);
}
else if (argc>1 && cmd=="construct_probes")
{
construct_probes(argc-1, ++argv);
}
else if (argc>1 && cmd=="profile_indels")
{
profile_indels(argc-1, ++argv);
}
else if (argc>1 && cmd=="profile_snps")
{
profile_snps(argc-1, ++argv);
}
else if (argc>1 && cmd=="profile_mendelian")
{
profile_mendelian(argc-1, ++argv);
}
else if (argc>1 && cmd=="profile_na12878")
{
profile_na12878(argc-1, ++argv);
}
else if (argc>1 && cmd=="profile_chrom")
{
profile_chrom(argc-1, ++argv);
}
else if (argc>1 && cmd=="align")
{
align(argc-1, ++argv);
}
else if (argc>1 && cmd=="compute_features")
{
compute_features(argc-1, ++argv);
}
else if (argc>1 && cmd=="profile_afs")
{
profile_afs(argc-1, ++argv);
}
else if (argc>1 && cmd=="profile_hwe")
{
profile_hwe(argc-1, ++argv);
}
else if (argc>1 && cmd=="profile_len")
{
profile_len(argc-1, ++argv);
}
else if (argc>1 && cmd=="annotate_str")
{
annotate_str(argc-1, ++argv);
}
else if (argc>1 && cmd=="consolidate_variants")
{
consolidate_variants(argc-1, ++argv);
}
else
{
std::clog << "Command not found: " << argv[1] << "\n\n";
help();
exit(1);
}
if (print)
{
clock_t t1;
t1 = clock();
print_time((float)(t1-t0)/CLOCKS_PER_SEC);
}
return 0;
}
void Note::UIsetup()
{
sLabel = new QLabel;
sLabel->setText(tr("Loading "));
sProg = new QProgressBar;
textEdit = new QTextEdit(this);
setCentralWidget(textEdit);
args = QCoreApplication::arguments();
if(args.count()==2)
argsC=1;
else
argsC=0;
ui->actionCut->setEnabled(false);
ui->actionCopy->setEnabled(false);
ui->statusBar->addWidget(sLabel, 1);
ui->statusBar->addWidget(sProg, 1);
sProg->setValue(1);
Note::connect(ui->actionCopy, SIGNAL(triggered()), textEdit, SLOT(copy()));
Note::connect(ui->actionCut, SIGNAL(triggered()), textEdit, SLOT(cut()));
Note::connect(ui->actionPaste, SIGNAL(triggered()), textEdit, SLOT(paste()));
Note::connect(ui->actionZoomIn, SIGNAL(triggered()), textEdit, SLOT(zoomIn()));
Note::connect(ui->actionZoom_Out, SIGNAL(triggered()), textEdit, SLOT(zoomOut()));
Note::connect(ui->actionBold, SIGNAL(triggered()), this, SLOT(textBold()));
sProg->setValue(10);
Note::connect(ui->actionItalics, SIGNAL(triggered()), this, SLOT(textItalic()));
Note::connect(ui->actionUnderline, SIGNAL(triggered()), this, SLOT(textUnderline()));
Note::connect(ui->actionExport, SIGNAL(triggered()), this, SLOT(filePDF()));
Note::connect(ui->actionPrint, SIGNAL(triggered()), this, SLOT(filePrintPreview()));
Note::connect(ui->action_About, SIGNAL(triggered()), this, SLOT(about()));
sProg->setValue(50);
Note::connect(textEdit, SIGNAL(copyAvailable(bool)), ui->actionCut, SLOT(setEnabled(bool)));
Note::connect(textEdit, SIGNAL(copyAvailable(bool)), ui->actionCopy, SLOT(setEnabled(bool)));
Note::connect(ui->actionNew, SIGNAL(triggered()), this, SLOT(newFile()));
Note::connect(ui->actionSave, SIGNAL(triggered()), this, SLOT(save()));
Note::connect(ui->actionSave_As, SIGNAL(triggered()), this, SLOT(saveAs()));
Note::connect(ui->actionOpen, SIGNAL(triggered()), this, SLOT(open()));
Note::connect(ui->action_Quit, SIGNAL(triggered()), this, SLOT(close()));
sProg->setValue(75);
ui->toolBar->addAction(ui->actionNew);
ui->toolBar->addSeparator();
ui->toolBar->addAction(ui->actionWarp_Text);
Note::fontBox = new QFontComboBox;
ui->toolBar->addSeparator();
ui->toolBar->addWidget(fontBox);
ui->toolBar->addSeparator();
Note::sizeBox = new QComboBox;
ui->toolBar->addWidget(sizeBox);
sizeBox->setObjectName("comboSize");
sizeBox->setEditable(true);
ui->toolBar->addSeparator();
ui->toolBar->addAction(ui->action_Quit);
QFontDatabase db;
foreach(int size, db.standardSizes())
sizeBox->addItem(QString::number(size));
sizeBox->setCurrentIndex(sizeBox->findText(QString::number(QApplication::font()
.pointSize())));
sProg->setValue(100);
wrapcheck = 0;
ui->statusBar->removeWidget(sLabel);
ui->statusBar->removeWidget(sProg);
ui->statusBar->showMessage(tr("Ideal"));
//font and text size
Note::connect(sizeBox, SIGNAL(activated(int)), this, SLOT(textSize(int)));
Note::connect(fontBox, SIGNAL(currentFontChanged(QFont)), this, SLOT(fontChanged(QFont)));
}
//----------------------------------------------------------------------
// KJOTSMAIN
//----------------------------------------------------------------------
KJotsComponent::KJotsComponent(QWidget* parent, KActionCollection *collection) : QWidget(parent)
{
actionCollection = collection;
searchDialog = 0;
activeAnchor.clear();
QDBusConnection dbus = QDBusConnection::sessionBus();
dbus.registerObject("/KJotsComponent", this, QDBusConnection::ExportScriptableSlots);
//
// Main widget
//
splitter = new QSplitter(this);
splitter->setOpaqueResize( KGlobalSettings::opaqueResize() );
bookshelf = new Bookshelf(splitter);
stackedWidget = new QStackedWidget(splitter);
editor = new KJotsEdit(stackedWidget);
editor->createActions(actionCollection);
editor->setEnabled(false);
stackedWidget->addWidget(editor);
browser = new KJotsBrowser(stackedWidget);
browser->setEnabled(false);
stackedWidget->addWidget(browser);
QVBoxLayout *bookGrid = new QVBoxLayout(this);
bookGrid->setMargin(KDialog::marginHint());
bookGrid->setSpacing(KDialog::spacingHint());
bookGrid->addWidget(splitter, 0, 0);
bookGrid->setMargin(0);
splitter->setStretchFactor(1, 1);
// I've moved as much I could into DelayedInitialization(), but the XML
// gui builder won't insert things properly if they don't get in there early.
KAction *action;
action = actionCollection->addAction( "go_next_book");
action->setText( i18n("Next Book") );
action->setIcon(KIcon("go-down"));
action->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_D));
connect(action, SIGNAL(triggered()), bookshelf, SLOT(nextBook()));
action = actionCollection->addAction( "go_prev_book");
action->setText( i18n("Previous Book") );
action->setIcon(KIcon("go-up"));
action->setShortcut(QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_D));
connect(action, SIGNAL(triggered()), bookshelf, SLOT(prevBook()));
action = actionCollection->addAction( "go_next_page");
action->setText( i18n("Next Page") );
action->setIcon(KIcon("go-next"));
action->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_PageDown));
connect(action, SIGNAL(triggered()), bookshelf, SLOT(nextPage()));
action = actionCollection->addAction( "go_prev_page" );
action->setText( i18n("Previous Page") );
action->setIcon(KIcon("go-previous"));
action->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_PageUp));
connect(action, SIGNAL(triggered()), bookshelf, SLOT(prevPage()));
action = actionCollection->addAction( "new_page");
action->setText( i18n("&New Page") );
action->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_N));
action->setIcon(KIcon("document-new"));
connect(action, SIGNAL(triggered()), SLOT(newPage()));
action = actionCollection->addAction("new_book");
action->setText(i18n("New &Book..."));
action->setShortcut(QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_N));
action->setIcon(KIcon("address-book-new"));
connect(action, SIGNAL(triggered()), SLOT(createNewBook()));
exportMenu = actionCollection->add<KActionMenu>("save_to");
exportMenu->setText(i18n("Export"));
exportMenu->setIcon(KIcon("document-export"));
action = actionCollection->addAction("save_to_ascii");
action->setText(i18n("To Text File..."));
action->setIcon(KIcon("text-plain"));
connect(action, SIGNAL(triggered()), SLOT(saveAscii()));
exportMenu->menu()->addAction( action );
action = actionCollection->addAction("save_to_html");
action->setText(i18n("To HTML File..."));
action->setIcon(KIcon("text-html"));
connect(action, SIGNAL(triggered()), SLOT(saveHtml()));
exportMenu->menu()->addAction( action );
action = actionCollection->addAction("save_to_book");
action->setText(i18n("To Book File..."));
action->setIcon(KIcon("x-office-address-book"));
connect(action, SIGNAL(triggered()), SLOT(saveNative()));
exportMenu->menu()->addAction( action );
action = actionCollection->addAction("import");
action->setText(i18n("Import..."));
action->setIcon(KIcon("document-import"));
connect(action, SIGNAL(triggered()), SLOT(importBook()));
action = actionCollection->addAction("del_page");
action->setText(i18n("&Delete Page"));
action->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_Delete));
action->setIcon(KIcon("edit-delete-page"));
connect(action, SIGNAL(triggered()), SLOT(deletePage()));
action = actionCollection->addAction("del_folder");
action->setText(i18n("Delete Boo&k"));
action->setShortcut(QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_Delete));
action->setIcon(KIcon("edit-delete"));
connect(action, SIGNAL(triggered()), SLOT(deleteBook()));
action = actionCollection->addAction("del_mult");
action->setText(i18n("Delete Selected"));
action->setIcon(KIcon("edit-delete"));
connect(action, SIGNAL(triggered()), SLOT(deleteMultiple()));
action = actionCollection->addAction("manual_save");
action->setText(i18n("Manual Save"));
action->setIcon(KIcon("document-save"));
action->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_S));
connect(action, SIGNAL(triggered()), SLOT(saveAll()));
action = actionCollection->addAction("auto_bullet");
action->setText(i18n("Auto Bullets"));
action->setIcon(KIcon("format-list-unordered"));
action->setCheckable(true);
action = actionCollection->addAction("auto_decimal");
action->setText(i18n("Auto Decimal List"));
action->setIcon(KIcon("format-list-ordered"));
action->setCheckable(true);
action = actionCollection->addAction("manage_link");
action->setText(i18n("Link"));
action->setIcon(KIcon("insert-link"));
action = actionCollection->addAction("insert_checkmark");
action->setText(i18n("Insert Checkmark"));
action->setIcon(KIcon("checkmark"));
action->setEnabled(false);
KStandardAction::print(this, SLOT(onPrint()), actionCollection);
action = KStandardAction::cut(editor, SLOT(cut()), actionCollection);
connect(editor, SIGNAL(copyAvailable(bool)), action, SLOT(setEnabled(bool)));
action->setEnabled(false);
action = KStandardAction::copy(this, SLOT(copy()), actionCollection);
connect(editor, SIGNAL(copyAvailable(bool)), action, SLOT(setEnabled(bool)));
connect(browser, SIGNAL(copyAvailable(bool)), action, SLOT(setEnabled(bool)));
action->setEnabled(false);
action = actionCollection->addAction("copyIntoTitle");
action->setText(i18n("Copy &into Page Title"));
action->setShortcut(QKeySequence(Qt::CTRL+Qt::Key_T));
action->setIcon(KIcon("edit-copy"));
connect(action, SIGNAL(triggered()), SLOT(copySelection()));
connect(editor, SIGNAL(copyAvailable(bool)), action, SLOT(setEnabled(bool)));
action->setEnabled(false);
KStandardAction::pasteText(editor, SLOT(paste()), actionCollection);
KStandardAction::find( this, SLOT( onShowSearch() ), actionCollection );
action = KStandardAction::findNext( this, SLOT( onRepeatSearch() ), actionCollection );
action->setEnabled(false);
KStandardAction::replace( this, SLOT( onShowReplace() ), actionCollection );
action = actionCollection->addAction("rename_entry");
action->setText(i18n("Rename..."));
action->setIcon(KIcon("edit-rename"));
action->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_M));
connect(action, SIGNAL(triggered()), SLOT(onRenameEntry()));
action = actionCollection->addAction("insert_date");
action->setText(i18n("Insert Date"));
action->setShortcut(QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_I));
action->setIcon(KIcon("view-calendar-time-spent"));
connect(action, SIGNAL(triggered()), SLOT(insertDate()));
action = actionCollection->addAction("change_color");
action->setIcon(KIcon("format-fill-color"));
action->setText(i18n("Change Color..."));
// connected to protected slot in bookshelf.cpp
action = actionCollection->addAction("copy_link_address");
action->setText(i18n("Copy Link Address"));
// connected to protected slot in bookshelf.cpp
action = actionCollection->addAction("paste_plain_text");
action->setText(i18nc("@action Paste the text in the clipboard without rich text formatting.", "Paste Plain Text"));
connect(action, SIGNAL(triggered()), editor, SLOT(pastePlainText()));
KStandardAction::preferences(this, SLOT(configure()), actionCollection);
bookmarkMenu = actionCollection->add<KActionMenu>("bookmarks");
bookmarkMenu->setText(i18n("&Bookmarks"));
KJotsBookmarks* bookmarks = new KJotsBookmarks(bookshelf);
/*KBookmarkMenu *bmm =*/ new KBookmarkMenu(
KBookmarkManager::managerForFile(KStandardDirs::locateLocal("data","kjots/bookmarks.xml"), "kjots"),
bookmarks, bookmarkMenu->menu(), actionCollection);
m_autosaveTimer = new QTimer(this);
//
// Set startup size.
//
if (!KJotsSettings::splitterSizes().isEmpty())
{
splitter->setSizes(KJotsSettings::splitterSizes());
}
updateConfiguration();
QTimer::singleShot(0, this, SLOT(DelayedInitialization()));
//connect new slots
connect(bookshelf, SIGNAL(itemSelectionChanged()), SLOT(updateCaption()));
connect(bookshelf, SIGNAL(itemSelectionChanged()), SLOT(updateMenu()));
connect(bookshelf, SIGNAL(itemChanged(QTreeWidgetItem*, int)), SLOT(onItemRenamed(QTreeWidgetItem*, int)));
connect(m_autosaveTimer, SIGNAL(timeout()), SLOT(autoSave()));
}
void LocationBar::pasteAndGo()
{
clear();
paste();
requestLoadUrl();
}
ExtendedTableWidget::ExtendedTableWidget(QWidget* parent) :
QTableView(parent)
{
setHorizontalScrollMode(ExtendedTableWidget::ScrollPerPixel);
// Force ScrollPerItem, so scrolling shows all table rows
setVerticalScrollMode(ExtendedTableWidget::ScrollPerItem);
connect(verticalScrollBar(), SIGNAL(valueChanged(int)), this, SLOT(vscrollbarChanged(int)));
connect(this, SIGNAL(clicked(QModelIndex)), this, SLOT(cellClicked(QModelIndex)));
// Set up filter row
m_tableHeader = new FilterTableHeader(this);
setHorizontalHeader(m_tableHeader);
// Set up vertical header context menu
verticalHeader()->setContextMenuPolicy(Qt::CustomContextMenu);
// Set up table view context menu
m_contextMenu = new QMenu(this);
QAction* nullAction = new QAction(tr("Set to NULL"), m_contextMenu);
QAction* copyAction = new QAction(QIcon(":/icons/copy"), tr("Copy"), m_contextMenu);
QAction* copyWithHeadersAction = new QAction(QIcon(":/icons/special_copy"), tr("Copy with Headers"), m_contextMenu);
QAction* pasteAction = new QAction(QIcon(":/icons/paste"), tr("Paste"), m_contextMenu);
QAction* filterAction = new QAction(tr("Use as Filter"), m_contextMenu);
m_contextMenu->addAction(filterAction);
m_contextMenu->addSeparator();
m_contextMenu->addAction(nullAction);
m_contextMenu->addSeparator();
m_contextMenu->addAction(copyAction);
m_contextMenu->addAction(copyWithHeadersAction);
m_contextMenu->addAction(pasteAction);
setContextMenuPolicy(Qt::CustomContextMenu);
// Create and set up delegate
m_editorDelegate = new ExtendedTableWidgetEditorDelegate(this);
setItemDelegate(m_editorDelegate);
// This is only for displaying the shortcut in the context menu.
// An entry in keyPressEvent is still needed.
nullAction->setShortcut(QKeySequence(tr("Alt+Del")));
copyAction->setShortcut(QKeySequence::Copy);
copyWithHeadersAction->setShortcut(QKeySequence(tr("Ctrl+Shift+C")));
pasteAction->setShortcut(QKeySequence::Paste);
// Set up context menu actions
connect(this, &QTableView::customContextMenuRequested,
[=](const QPoint& pos)
{
// Deactivate context menu options if there is no model set
bool enabled = model();
filterAction->setEnabled(enabled);
copyAction->setEnabled(enabled);
copyWithHeadersAction->setEnabled(enabled);
// Try to find out whether the current view is editable and (de)activate menu options according to that
bool editable = editTriggers() != QAbstractItemView::NoEditTriggers;
nullAction->setEnabled(enabled && editable);
pasteAction->setEnabled(enabled && editable);
// Show menu
m_contextMenu->popup(viewport()->mapToGlobal(pos));
});
connect(filterAction, &QAction::triggered, [&]() {
useAsFilter();
});
connect(nullAction, &QAction::triggered, [&]() {
for(const QModelIndex& index : selectedIndexes())
model()->setData(index, QVariant());
});
connect(copyAction, &QAction::triggered, [&]() {
copy(false);
});
connect(copyWithHeadersAction, &QAction::triggered, [&]() {
copy(true);
});
connect(pasteAction, &QAction::triggered, [&]() {
paste();
});
}
/**
MainWindow represents, not surprisingly, the main window of the application.
It handles all the menu items and the UI.
*/
MainWindow::MainWindow( ) : QMainWindow( 0 )
{
setupUi(this);
// add the file dropdown to the toolbar...can't do this in Designer for some reason
QWidget *stretch = new QWidget(toolBar);
stretch->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
toolBar->addWidget(stretch);
currentFileDropDown = new QComboBox(toolBar);
currentFileDropDown->setSizeAdjustPolicy(QComboBox::AdjustToContents);
toolBar->addWidget(currentFileDropDown);
QWidget *pad = new QWidget(toolBar); // this doesn't pad as much as it should...to be fixed...
toolBar->addWidget(pad);
//initialization
buildLog = new BuildLog();
highlighter = new Highlighter( editor->document() );
prefs = new Preferences(this);
projInfo = new ProjectInfo(this);
uploader = new Uploader(this);
builder = new Builder(this, projInfo, buildLog);
usbConsole = new UsbConsole();
findReplace = new FindReplace(this);
about = new About();
updater = new AppUpdater();
// load
boardTypeGroup = new QActionGroup(menuBoard_Type);
loadBoardProfiles( );
loadExamples( );
loadLibraries( );
loadRecentProjects( );
readSettings( );
// misc. signals
connect(editor, SIGNAL(cursorPositionChanged()), this, SLOT(onCursorMoved()));
connect(actionPreferences, SIGNAL(triggered()), prefs, SLOT(loadAndShow()));
connect(actionUsb_Monitor, SIGNAL(triggered()), usbConsole, SLOT(loadAndShow()));
connect(currentFileDropDown, SIGNAL(currentIndexChanged(int)), this, SLOT(onFileSelection(int)));
connect(editor->document(), SIGNAL(contentsChanged()),this, SLOT(onDocumentModified()));
connect(outputConsole, SIGNAL(itemDoubleClicked(QListWidgetItem*)),this, SLOT(onConsoleDoubleClick(QListWidgetItem*)));
connect(projInfo, SIGNAL(projectInfoUpdated()), builder, SLOT(onProjectUpdated()));
// menu actions
connect(actionNew, SIGNAL(triggered()), this, SLOT(onNewFile()));
connect(actionAdd_Existing_File, SIGNAL(triggered()), this, SLOT(onAddExistingFile()));
connect(actionNew_Project, SIGNAL(triggered()), this, SLOT(onNewProject()));
connect(actionOpen, SIGNAL(triggered()), this, SLOT(onOpen()));
connect(actionSave, SIGNAL(triggered()), this, SLOT(onSave()));
connect(actionSave_As, SIGNAL(triggered()), this, SLOT(onSaveAs()));
connect(actionBuild, SIGNAL(triggered()), this, SLOT(onBuild()));
connect(actionStop, SIGNAL(triggered()), this, SLOT(onStop()));
connect(actionClean, SIGNAL(triggered()), this, SLOT(onClean()));
connect(actionProperties, SIGNAL(triggered()), this, SLOT(onProperties()));
connect(actionUpload, SIGNAL(triggered()), this, SLOT(onUpload()));
connect(actionUndo, SIGNAL(triggered()), editor, SLOT(undo()));
connect(actionRedo, SIGNAL(triggered()), editor, SLOT(redo()));
connect(actionCut, SIGNAL(triggered()), editor, SLOT(cut()));
connect(actionCopy, SIGNAL(triggered()), editor, SLOT(copy()));
connect(actionPaste, SIGNAL(triggered()), editor, SLOT(paste()));
connect(actionSelect_All, SIGNAL(triggered()), editor, SLOT(selectAll()));
connect(actionFind, SIGNAL(triggered()), findReplace, SLOT(show()));
connect(actionAbout, SIGNAL(triggered()), about, SLOT(show()));
connect(actionUpdate, SIGNAL(triggered()), this, SLOT(onUpdate()));
connect(actionBuildLog, SIGNAL(triggered()), buildLog, SLOT(show()));
connect(actionVisitForum, SIGNAL(triggered()), this, SLOT(onVisitForum()));
connect(actionClear_Output_Console, SIGNAL(triggered()), outputConsole, SLOT(clear()));
connect(actionUpload_File_to_Board, SIGNAL(triggered()), this, SLOT(onUploadFile()));
connect(actionMake_Controller_Reference, SIGNAL(triggered()), this, SLOT(openMCReference()));
connect(actionMcbuilder_User_Manual, SIGNAL(triggered()), this, SLOT(openManual()));
connect(menuExamples, SIGNAL(triggered(QAction*)), this, SLOT(onExample(QAction*)));
connect(menuLibraries, SIGNAL(triggered(QAction*)), this, SLOT(onLibrary(QAction*)));
connect(actionSave_Project_As, SIGNAL(triggered()), this, SLOT(onSaveProjectAs()));
connect(menuRecent_Projects, SIGNAL(triggered(QAction*)), this, SLOT(openRecentProject(QAction*)));
}
void QWERTYEditor::createActions() {
/*
Функция загрузки файла
Некторые функции опущены, ибо идентичны.
Инициализируем QAction, придаем им иконки, устанавливаем им
шорткаты (быстрые клавишы) и подсказку в тулбаре.
Соединиям их со слотами.
В конце отключили действия вырезать и скопировать , которые
должны быть доступны только тогда, когда theQPlainTextEdit содержит
выделенный текст. Подключили сигнал copyAvailable, для их(функций)
включения, если есть выделенный текст
*/
actionNewFile = new QAction( QIcon(":/images/img_new.png"), tr("&New"), this );
actionNewFile -> setShortcuts (QKeySequence::New);
actionNewFile -> setStatusTip (tr("Create a new file"));
connect ( actionNewFile, SIGNAL(triggered()), this, SLOT( newFile() ) );
actionOpenFile = new QAction ( QIcon( ":/images/img_open.png" ), tr( "&Open" ), this );
actionOpenFile -> setShortcuts( QKeySequence::Open );
actionOpenFile -> setStatusTip( tr( "Open a file" ) );
connect( actionOpenFile, SIGNAL( triggered() ), this, SLOT( open() ) );
actionSaveFile = new QAction(QIcon(":/images/img_save.png"), tr("&Save"), this);
actionSaveFile->setShortcuts(QKeySequence::Save);
actionSaveFile->setStatusTip(tr("Save the document"));
connect(actionSaveFile, SIGNAL(triggered()), this, SLOT(save()));
actionSaveAsFile = new QAction(QIcon(":/images/img_saveas.png"), tr("Save &As"), this);
actionSaveAsFile->setShortcuts(QKeySequence::SaveAs);
actionSaveAsFile->setStatusTip(tr("Save the document with a new name"));
connect(actionSaveAsFile, SIGNAL(triggered()), this, SLOT(saveAs()));
actionExit = new QAction(QIcon(":/images/img_exit.png"), tr("&Exit"), this);
actionExit->setShortcuts(QKeySequence::Quit);
actionExit->setStatusTip(tr("Exit the application"));
connect(actionExit, SIGNAL(triggered()), this, SLOT(close()));
actionCut = new QAction(QIcon(":/images/img_cut.png"), tr("&Cut"), this);
actionCut->setShortcuts(QKeySequence::Cut);
actionCut->setStatusTip(tr("Cut the selection's to the clipboard"));
connect(actionCut, SIGNAL(triggered()), textEdit, SLOT(cut()));
actionCopy = new QAction(QIcon(":/images/img_copy.png"), tr("&Copy"), this);
actionCopy->setShortcuts(QKeySequence::Copy);
actionCopy->setStatusTip(tr("Copy the selection's to the clipboard"));
connect(actionCopy, SIGNAL(triggered()), textEdit, SLOT(copy()));
actionPaste = new QAction(QIcon(":/images/img_paste.png"), tr("&Paste"), this);
actionPaste->setShortcuts(QKeySequence::Paste);
actionPaste->setStatusTip(tr("Paste the clipboard's content into the selection"));
connect(actionPaste, SIGNAL(triggered()), textEdit, SLOT(paste()));
actionAbout = new QAction(QIcon(":/images/img_about.png"), tr("&About"), this);
actionAbout -> setStatusTip(tr("Show the About message"));
connect(actionAbout, SIGNAL(triggered()), this, SLOT(about()));
actionCut->setEnabled(false);
actionCopy->setEnabled(false);
connect (
textEdit,
SIGNAL(copyAvailable(bool)),
actionCut,
SLOT(setEnabled(bool))
);
connect (
textEdit,
SIGNAL(copyAvailable(bool)),
actionCopy,
SLOT(setEnabled(bool))
);
}
void MainWindow::createActions()
{
newAction = new QAction(tr("&New"), this);
newAction->setIcon(QIcon(":/images/new.png"));
newAction->setShortcut(tr("Ctrl+N"));
newAction->setStatusTip(tr("Create a new spreadsheet file"));
connect(newAction, SIGNAL(triggered()), this, SLOT(newFile()));
openAction = new QAction(tr("&Open..."), this);
openAction->setIcon(QIcon(":/images/open.png"));
openAction->setShortcut(tr("Ctrl+O"));
openAction->setStatusTip(tr("Open an existing spreadsheet file"));
connect(openAction, SIGNAL(triggered()), this, SLOT(open()));
saveAction = new QAction(tr("&Save"), this);
saveAction->setIcon(QIcon(":/images/save.png"));
saveAction->setShortcut(tr("Ctrl+S"));
saveAction->setStatusTip(tr("Save the spreadsheet to disk"));
connect(saveAction, SIGNAL(triggered()), this, SLOT(save()));
saveAsAction = new QAction(tr("Save &As..."), this);
saveAsAction->setStatusTip(tr("Save the spreadsheet under a new "
"name"));
connect(saveAsAction, SIGNAL(triggered()), this, SLOT(saveAs()));
for (int i = 0; i < MaxRecentFiles; ++i) {
recentFileActions[i] = new QAction(this);
recentFileActions[i]->setVisible(false);
connect(recentFileActions[i], SIGNAL(triggered()),
this, SLOT(openRecentFile()));
}
exitAction = new QAction(tr("E&xit"), this);
exitAction->setShortcut(tr("Ctrl+Q"));
exitAction->setStatusTip(tr("Exit the application"));
connect(exitAction, SIGNAL(triggered()), this, SLOT(close()));
cutAction = new QAction(tr("Cu&t"), this);
cutAction->setIcon(QIcon(":/images/cut.png"));
cutAction->setShortcut(tr("Ctrl+X"));
cutAction->setStatusTip(tr("Cut the current selection's contents "
"to the clipboard"));
connect(cutAction, SIGNAL(triggered()), spreadsheet, SLOT(cut()));
copyAction = new QAction(tr("&Copy"), this);
copyAction->setIcon(QIcon(":/images/copy.png"));
copyAction->setShortcut(tr("Ctrl+C"));
copyAction->setStatusTip(tr("Copy the current selection's contents "
"to the clipboard"));
connect(copyAction, SIGNAL(triggered()), spreadsheet, SLOT(copy()));
pasteAction = new QAction(tr("&Paste"), this);
pasteAction->setIcon(QIcon(":/images/paste.png"));
pasteAction->setShortcut(tr("Ctrl+V"));
pasteAction->setStatusTip(tr("Paste the clipboard's contents into "
"the current selection"));
connect(pasteAction, SIGNAL(triggered()),
spreadsheet, SLOT(paste()));
deleteAction = new QAction(tr("&Delete"), this);
deleteAction->setShortcut(tr("Del"));
deleteAction->setStatusTip(tr("Delete the current selection's "
"contents"));
connect(deleteAction, SIGNAL(triggered()),
spreadsheet, SLOT(del()));
selectRowAction = new QAction(tr("&Row"), this);
selectRowAction->setStatusTip(tr("Select all the cells in the "
"current row"));
connect(selectRowAction, SIGNAL(triggered()),
spreadsheet, SLOT(selectCurrentRow()));
selectColumnAction = new QAction(tr("&Column"), this);
selectColumnAction->setStatusTip(tr("Select all the cells in the "
"current column"));
connect(selectColumnAction, SIGNAL(triggered()),
spreadsheet, SLOT(selectCurrentColumn()));
selectAllAction = new QAction(tr("&All"), this);
selectAllAction->setShortcut(tr("Ctrl+A"));
selectAllAction->setStatusTip(tr("Select all the cells in the "
"spreadsheet"));
connect(selectAllAction, SIGNAL(triggered()),
spreadsheet, SLOT(selectAll()));
findAction = new QAction(tr("&Find..."), this);
findAction->setIcon(QIcon(":/images/find.png"));
findAction->setShortcut(tr("Ctrl+F"));
findAction->setStatusTip(tr("Find a matching cell"));
connect(findAction, SIGNAL(triggered()), this, SLOT(find()));
goToCellAction = new QAction(tr("&Go to Cell..."), this);
goToCellAction->setIcon(QIcon(":/images/gotocell.png"));
goToCellAction->setShortcut(tr("F5"));
goToCellAction->setStatusTip(tr("Go to the specified cell"));
connect(goToCellAction, SIGNAL(triggered()),
this, SLOT(goToCell()));
recalculateAction = new QAction(tr("&Recalculate"), this);
recalculateAction->setShortcut(tr("F9"));
recalculateAction->setStatusTip(tr("Recalculate all the "
"spreadsheet's formulas"));
connect(recalculateAction, SIGNAL(triggered()),
spreadsheet, SLOT(recalculate()));
sortAction = new QAction(tr("&Sort..."), this);
sortAction->setStatusTip(tr("Sort the selected cells or all the "
"cells"));
connect(sortAction, SIGNAL(triggered()), this, SLOT(sort()));
showGridAction = new QAction(tr("&Show Grid"), this);
showGridAction->setCheckable(true);
showGridAction->setChecked(spreadsheet->showGrid());
showGridAction->setStatusTip(tr("Show or hide the spreadsheet's "
"grid"));
connect(showGridAction, SIGNAL(toggled(bool)),
spreadsheet, SLOT(setShowGrid(bool)));
#if QT_VERSION < 0x040102
// workaround for a QTableWidget bug in Qt 4.1.1
connect(showGridAction, SIGNAL(toggled(bool)),
spreadsheet->viewport(), SLOT(update()));
#endif
autoRecalcAction = new QAction(tr("&Auto-Recalculate"), this);
autoRecalcAction->setCheckable(true);
autoRecalcAction->setChecked(spreadsheet->autoRecalculate());
autoRecalcAction->setStatusTip(tr("Switch auto-recalculation on or "
"off"));
connect(autoRecalcAction, SIGNAL(toggled(bool)),
spreadsheet, SLOT(setAutoRecalculate(bool)));
aboutAction = new QAction(tr("&About"), this);
aboutAction->setStatusTip(tr("Show the application's About box"));
connect(aboutAction, SIGNAL(triggered()), this, SLOT(about()));
aboutQtAction = new QAction(tr("About &Qt"), this);
aboutQtAction->setStatusTip(tr("Show the Qt library's About box"));
connect(aboutQtAction, SIGNAL(triggered()), qApp, SLOT(aboutQt()));
}
void LiteEditor::createActions()
{
LiteApi::IActionContext *actionContext = m_liteApp->actionManager()->getActionContext(this,"Editor");
m_undoAct = new QAction(QIcon("icon:liteeditor/images/undo.png"),tr("Undo"),this);
actionContext->regAction(m_undoAct,"Undo",QKeySequence::Undo);
m_redoAct = new QAction(QIcon("icon:liteeditor/images/redo.png"),tr("Redo"),this);
actionContext->regAction(m_redoAct,"Redo","Ctrl+Shift+Z; Ctrl+Y");
m_cutAct = new QAction(QIcon("icon:liteeditor/images/cut.png"),tr("Cut"),this);
actionContext->regAction(m_cutAct,"Cut",QKeySequence::Cut);
m_copyAct = new QAction(QIcon("icon:liteeditor/images/copy.png"),tr("Copy"),this);
actionContext->regAction(m_copyAct,"Copy",QKeySequence::Copy);
m_pasteAct = new QAction(QIcon("icon:liteeditor/images/paste.png"),tr("Paste"),this);
actionContext->regAction(m_pasteAct,"Paste",QKeySequence::Paste);
m_selectAllAct = new QAction(tr("Select All"),this);
actionContext->regAction(m_selectAllAct,"SelectAll",QKeySequence::SelectAll);
m_exportHtmlAct = new QAction(QIcon("icon:liteeditor/images/exporthtml.png"),tr("Export HTML..."),this);
#ifndef QT_NO_PRINTER
m_exportPdfAct = new QAction(QIcon("icon:liteeditor/images/exportpdf.png"),tr("Export PDF..."),this);
m_filePrintAct = new QAction(QIcon("icon:liteeditor/images/fileprint.png"),tr("Print..."),this);
m_filePrintPreviewAct = new QAction(QIcon("icon:liteeditor/images/fileprintpreview.png"),tr("Print Preview..."),this);
#endif
m_gotoPrevBlockAct = new QAction(tr("Go To Previous Block"),this);
actionContext->regAction(m_gotoPrevBlockAct,"GotoPreviousBlock","Ctrl+[");
m_gotoNextBlockAct = new QAction(tr("Go To Next Block"),this);
actionContext->regAction(m_gotoNextBlockAct,"GotoNextBlock","Ctrl+]");
m_selectBlockAct = new QAction(tr("Select Block"),this);
actionContext->regAction(m_selectBlockAct,"SelectBlock","Ctrl+U");
m_gotoMatchBraceAct = new QAction(tr("Go To Matching Brace"),this);
actionContext->regAction(m_gotoMatchBraceAct,"GotoMatchBrace","Ctrl+E");
m_foldAct = new QAction(tr("Fold"),this);
actionContext->regAction(m_foldAct,"Fold","Ctrl+<");
m_unfoldAct = new QAction(tr("Unfold"),this);
actionContext->regAction(m_unfoldAct,"Unfold","Ctrl+>");
m_foldAllAct = new QAction(tr("Fold All"),this);
actionContext->regAction(m_foldAllAct,"FoldAll","");
m_unfoldAllAct = new QAction(tr("Unfold All"),this);
actionContext->regAction(m_unfoldAllAct,"UnfoldAll","");
connect(m_foldAct,SIGNAL(triggered()),m_editorWidget,SLOT(fold()));
connect(m_unfoldAct,SIGNAL(triggered()),m_editorWidget,SLOT(unfold()));
connect(m_foldAllAct,SIGNAL(triggered()),m_editorWidget,SLOT(foldAll()));
connect(m_unfoldAllAct,SIGNAL(triggered()),m_editorWidget,SLOT(unfoldAll()));
m_gotoLineAct = new QAction(tr("Go To Line"),this);
actionContext->regAction(m_gotoLineAct,"GotoLine","Ctrl+L");
m_lockAct = new QAction(QIcon("icon:liteeditor/images/lock.png"),tr("Locked"),this);
m_lockAct->setEnabled(false);
m_duplicateAct = new QAction(tr("Duplicate"),this);
actionContext->regAction(m_duplicateAct,"Duplicate","Ctrl+D");
connect(m_duplicateAct,SIGNAL(triggered()),m_editorWidget,SLOT(duplicate()));
m_deleteLineAct = new QAction(tr("Delete Line"),this);
actionContext->regAction(m_deleteLineAct,"DeleteLine","Ctrl+Shift+K");
connect(m_deleteLineAct,SIGNAL(triggered()),m_editorWidget,SLOT(deleteLine()));
m_insertLineBeforeAct = new QAction(tr("Insert Line Before"),this);
actionContext->regAction(m_insertLineBeforeAct,"InsertLineBefore","Ctrl+Shift+Return");
connect(m_insertLineBeforeAct,SIGNAL(triggered()),m_editorWidget,SLOT(insertLineBefore()));
m_insertLineAfterAct = new QAction(tr("Insert Line After"),this);
actionContext->regAction(m_insertLineAfterAct,"InsertLineAfter","Ctrl+Return");
connect(m_insertLineAfterAct,SIGNAL(triggered()),m_editorWidget,SLOT(insertLineAfter()));
m_increaseFontSizeAct = new QAction(tr("Increase Font Size"),this);
actionContext->regAction(m_increaseFontSizeAct,"IncreaseFontSize","Ctrl++;Ctrl+=");
m_decreaseFontSizeAct = new QAction(tr("Decrease Font Size"),this);
actionContext->regAction(m_decreaseFontSizeAct,"DecreaseFontSize","Ctrl+-");
m_resetFontSizeAct = new QAction(tr("Reset Font Size"),this);
actionContext->regAction(m_resetFontSizeAct,"ResetFontSize","Ctrl+0");
m_cleanWhitespaceAct = new QAction(tr("Clean Whitespace"),this);
actionContext->regAction(m_cleanWhitespaceAct,"CleanWhitespace","");
m_wordWrapAct = new QAction(tr("Word Wrap"),this);
m_wordWrapAct->setCheckable(true);
actionContext->regAction(m_wordWrapAct,"WordWrap","");
m_codeCompleteAct = new QAction(tr("Code Complete"),this);
#ifdef Q_OS_MAC
actionContext->regAction(m_codeCompleteAct,"CodeComplete","Meta+Space");
#else
actionContext->regAction(m_codeCompleteAct,"CodeComplete","Ctrl+Space");
#endif
connect(m_codeCompleteAct,SIGNAL(triggered()),m_editorWidget,SLOT(codeCompleter()));
// m_widget->addAction(m_foldAct);
// m_widget->addAction(m_unfoldAct);
// m_widget->addAction(m_gotoLineAct);
// m_widget->addAction(m_gotoPrevBlockAct);
// m_widget->addAction(m_gotoNextBlockAct);
// m_widget->addAction(m_selectBlockAct);
// m_widget->addAction(m_gotoMatchBraceAct);
connect(m_editorWidget,SIGNAL(undoAvailable(bool)),m_undoAct,SLOT(setEnabled(bool)));
connect(m_editorWidget,SIGNAL(redoAvailable(bool)),m_redoAct,SLOT(setEnabled(bool)));
connect(m_editorWidget,SIGNAL(copyAvailable(bool)),m_cutAct,SLOT(setEnabled(bool)));
connect(m_editorWidget,SIGNAL(copyAvailable(bool)),m_copyAct,SLOT(setEnabled(bool)));
connect(m_editorWidget,SIGNAL(wordWrapChanged(bool)),m_wordWrapAct,SLOT(setChecked(bool)));
connect(m_undoAct,SIGNAL(triggered()),m_editorWidget,SLOT(undo()));
connect(m_redoAct,SIGNAL(triggered()),m_editorWidget,SLOT(redo()));
connect(m_cutAct,SIGNAL(triggered()),m_editorWidget,SLOT(cut()));
connect(m_copyAct,SIGNAL(triggered()),m_editorWidget,SLOT(copy()));
connect(m_pasteAct,SIGNAL(triggered()),m_editorWidget,SLOT(paste()));
connect(m_selectAllAct,SIGNAL(triggered()),m_editorWidget,SLOT(selectAll()));
connect(m_selectBlockAct,SIGNAL(triggered()),m_editorWidget,SLOT(selectBlock()));
connect(m_exportHtmlAct,SIGNAL(triggered()),this,SLOT(exportHtml()));
#ifndef QT_NO_PRINTER
connect(m_exportPdfAct,SIGNAL(triggered()),this,SLOT(exportPdf()));
connect(m_filePrintAct,SIGNAL(triggered()),this,SLOT(filePrint()));
connect(m_filePrintPreviewAct,SIGNAL(triggered()),this,SLOT(filePrintPreview()));
#endif
connect(m_gotoPrevBlockAct,SIGNAL(triggered()),m_editorWidget,SLOT(gotoPrevBlock()));
connect(m_gotoNextBlockAct,SIGNAL(triggered()),m_editorWidget,SLOT(gotoNextBlock()));
connect(m_gotoMatchBraceAct,SIGNAL(triggered()),m_editorWidget,SLOT(gotoMatchBrace()));
connect(m_gotoLineAct,SIGNAL(triggered()),this,SLOT(gotoLine()));
connect(m_increaseFontSizeAct,SIGNAL(triggered()),this,SLOT(increaseFontSize()));
connect(m_decreaseFontSizeAct,SIGNAL(triggered()),this,SLOT(decreaseFontSize()));
connect(m_resetFontSizeAct,SIGNAL(triggered()),this,SLOT(resetFontSize()));
connect(m_cleanWhitespaceAct,SIGNAL(triggered()),m_editorWidget,SLOT(cleanWhitespace()));
connect(m_wordWrapAct,SIGNAL(triggered(bool)),m_editorWidget,SLOT(setWordWrapOverride(bool)));
#ifdef Q_OS_WIN
QClipboard *clipboard = QApplication::clipboard();
connect(clipboard,SIGNAL(dataChanged()),this,SLOT(clipbordDataChanged()));
clipbordDataChanged();
#endif
}
void HKStringEntryLogic::Update()
{
bool shiftL = !!MFInput_Read(Key_LShift, IDD_Keyboard);
bool shiftR = !!MFInput_Read(Key_RShift, IDD_Keyboard);
bool ctrlL = !!MFInput_Read(Key_LControl, IDD_Keyboard);
bool ctrlR = !!MFInput_Read(Key_RControl, IDD_Keyboard);
int keyPressed = 0;
bool shift = shiftL || shiftR;
bool ctrl = ctrlL || ctrlR;
#if defined(MF_WINDOWS)
if(ctrl && MFInput_WasPressed(Key_C, IDD_Keyboard) && selectionStart != selectionEnd)
{
BOOL opened = OpenClipboard(apphWnd);
if(opened)
{
int selMin = MFMin(selectionStart, selectionEnd);
int selMax = MFMax(selectionStart, selectionEnd);
int numChars = selMax-selMin;
HANDLE hData = GlobalAlloc(GMEM_MOVEABLE, numChars + 1);
char *pString = (char*)GlobalLock(hData);
MFString_Copy(pString, GetRenderString().SubStr(selMin, numChars).CStr());
GlobalUnlock(hData);
EmptyClipboard();
SetClipboardData(CF_TEXT, hData);
CloseClipboard();
}
}
else if(ctrl && MFInput_WasPressed(Key_X, IDD_Keyboard) && selectionStart != selectionEnd)
{
BOOL opened = OpenClipboard(apphWnd);
if(opened)
{
int selMin = MFMin(selectionStart, selectionEnd);
int selMax = MFMax(selectionStart, selectionEnd);
int numChars = selMax-selMin;
HANDLE hData = GlobalAlloc(GMEM_MOVEABLE, numChars + 1);
char *pString = (char*)GlobalLock(hData);
MFString_Copy(pString, GetRenderString().SubStr(selMin, numChars).CStr());
GlobalUnlock(hData);
EmptyClipboard();
SetClipboardData(CF_TEXT, hData);
CloseClipboard();
ClearSelection();
}
}
else if(ctrl && MFInput_WasPressed(Key_V, IDD_Keyboard))
{
BOOL opened = OpenClipboard(apphWnd);
if(opened)
{
int selMin = MFMin(selectionStart, selectionEnd);
int selMax = MFMax(selectionStart, selectionEnd);
int numChars = selMax-selMin;
HANDLE hData = GetClipboardData(CF_TEXT);
MFString paste((const char*)GlobalLock(hData), true);
buffer.Replace(selMin, numChars, paste);
GlobalUnlock(hData);
cursorPos = selMin + paste.NumBytes();
selectionStart = selectionEnd = cursorPos;
GlobalUnlock(hData);
CloseClipboard();
if((numChars || cursorPos != selMin) && changeCallback)
changeCallback(buffer.CStr());
}
}
else
#endif
{
// check for new keypresses
for(int a=0; a<255; a++)
{
if(MFInput_WasPressed(a, IDD_Keyboard))
{
keyPressed = a;
holdKey = a;
repeatDelay = gRepeatDelay;
break;
}
}
// handle repeat keys
if(holdKey && MFInput_Read(holdKey, IDD_Keyboard))
{
repeatDelay -= MFSystem_TimeDelta();
if(repeatDelay <= 0.f)
{
keyPressed = holdKey;
repeatDelay += gRepeatRate;
}
}
else
holdKey = 0;
// if there was a new key press
if(keyPressed)
{
switch(keyPressed)
{
case Key_Backspace:
case Key_Delete:
{
if(selectionStart != selectionEnd)
{
ClearSelection();
}
else
{
if(keyPressed == Key_Backspace && cursorPos > 0)
{
buffer.ClearRange(--cursorPos, 1);
selectionStart = selectionEnd = cursorPos;
if(changeCallback)
changeCallback(buffer.CStr());
}
else if(keyPressed == Key_Delete && cursorPos < buffer.NumBytes())
{
buffer.ClearRange(cursorPos, 1);
selectionStart = selectionEnd = cursorPos;
if(changeCallback)
changeCallback(buffer.CStr());
}
}
break;
}
case Key_Left:
case Key_Right:
case Key_Home:
case Key_End:
{
if(ctrl)
{
if(keyPressed == Key_Left)
{
while(cursorPos && MFIsWhite(buffer[cursorPos-1]))
--cursorPos;
if(MFIsAlphaNumeric(buffer[cursorPos-1]))
{
while(cursorPos && MFIsAlphaNumeric(buffer[cursorPos-1]))
--cursorPos;
}
else if(cursorPos)
{
--cursorPos;
while(cursorPos && buffer[cursorPos-1] == buffer[cursorPos])
--cursorPos;
}
}
else if(keyPressed == Key_Right)
{
while(cursorPos < buffer.NumBytes() && MFIsWhite(buffer[cursorPos]))
++cursorPos;
if(MFIsAlphaNumeric(buffer[cursorPos]))
{
while(cursorPos < buffer.NumBytes() && MFIsAlphaNumeric(buffer[cursorPos]))
++cursorPos;
}
else if(cursorPos < buffer.NumBytes())
{
++cursorPos;
while(cursorPos < buffer.NumBytes() && buffer[cursorPos] == buffer[cursorPos-1])
++cursorPos;
}
}
else if(keyPressed == Key_Home)
cursorPos = 0;
else if(keyPressed == Key_End)
cursorPos = buffer.NumBytes();
}
else
{
if(keyPressed == Key_Left)
cursorPos = (!shift && selectionStart != selectionEnd ? MFMin(selectionStart, selectionEnd) : MFMax(cursorPos-1, 0));
else if(keyPressed == Key_Right)
cursorPos = (!shift && selectionStart != selectionEnd ? MFMax(selectionStart, selectionEnd) : MFMin(cursorPos+1, buffer.NumBytes()));
else if(keyPressed == Key_Home)
cursorPos = 0; // TODO: if multiline, go to start of line..
else if(keyPressed == Key_End)
cursorPos = buffer.NumBytes(); // TODO: if multiline, go to end of line...
}
if(shift)
selectionEnd = cursorPos;
else
selectionStart = selectionEnd = cursorPos;
break;
}
default:
{
bool caps = MFInput_GetKeyboardStatusState(KSS_CapsLock);
int ascii = MFInput_KeyToAscii(keyPressed, shift, caps);
if(ascii && (!maxLen || buffer.NumBytes() < maxLen-1))
{
// check character exclusions
if(MFIsNewline(ascii) && type != ST_MultiLine)
break;
if(ascii == '\t' && type != ST_MultiLine)
break;
if(type == ST_Numeric && !MFIsNumeric(ascii))
break;
if(include)
{
if(include.FindChar(ascii) < 0)
break;
}
if(exclude)
{
if(exclude.FindChar(ascii) >= 0)
break;
}
int selMin = MFMin(selectionStart, selectionEnd);
int selMax = MFMax(selectionStart, selectionEnd);
int selRange = selMax - selMin;
const uint16 wstr[] = { (uint16)ascii, 0 };
char insert[5];
MFString_CopyUTF16ToUTF8(insert, wstr);
buffer.Replace(selMin, selRange, insert);
cursorPos = selMin + 1;
selectionStart = selectionEnd = cursorPos;
if(changeCallback)
changeCallback(buffer.CStr());
}
break;
}
}
}
}
}
void GraphicUI::createActions()
{
CreateAct = new QAction(QIcon("images/create.png"), tr("&Create a mind map"), this);
connect(CreateAct, SIGNAL(triggered()), this, SLOT(create()));
OpenAct = new QAction(QIcon("images/open.png"), tr("&Open a mind map"), this);
OpenAct->setStatusTip(tr("Open an existing file"));
connect(OpenAct, SIGNAL(triggered()), this, SLOT(open()));
SaveAct = new QAction(QIcon("images/save.png"), tr("&Save a mind map"), this);
connect(SaveAct, SIGNAL(triggered()), this, SLOT(save()));
ExitAct = new QAction(QIcon("images/exit.png"), tr("&Exit"), this);
ExitAct->setStatusTip(tr("Exit the application"));
connect(ExitAct, SIGNAL(triggered()), this, SLOT(close()));
EditAct = new QAction(QIcon("images/edit.png"), tr("&Edit"), this);
connect(EditAct, SIGNAL(triggered()), this, SLOT(edit()));
DeleteAct = new QAction(QIcon("images/delete.png"), tr("&Delete"), this);
connect(DeleteAct, SIGNAL(triggered()), this, SLOT(deleteNode()));
InsertAChildAct = new QAction(QIcon("images/child.png"), tr("&Insert a child"), this);
connect(InsertAChildAct, SIGNAL(triggered()), this, SLOT(insertChild()));
InsertASiblingAct = new QAction(QIcon("images/silbing.png"), tr("&Insert a silbing"), this);
connect(InsertASiblingAct, SIGNAL(triggered()), this, SLOT(insertSilbing()));
InsertAParentAct = new QAction(QIcon("images/parent.png"), tr("&Insert a parent"), this);
connect(InsertAParentAct, SIGNAL(triggered()), this, SLOT(insertParent()));
AboutAct = new QAction(QIcon("images/about.png"), tr("&About"), this);
connect(AboutAct, SIGNAL(triggered()), this, SLOT(about()));
CutAct = new QAction(QIcon("images/cut.png"), tr("&Cut"), this);
connect(CutAct, SIGNAL(triggered()), this, SLOT(cut()));
CopyAct = new QAction(QIcon("images/copy.png"), tr("&Copy"), this);
connect(CopyAct, SIGNAL(triggered()), this, SLOT(copy()));
PasteAct = new QAction(QIcon("images/paste.png"), tr("&Paste"), this);
connect(PasteAct, SIGNAL(triggered()), this, SLOT(paste()));
RedoAct = new QAction(QIcon("images/redo.png"), tr("&Redo"), this);
connect(RedoAct, SIGNAL(triggered()), this, SLOT(redo()));
UndoAct = new QAction(QIcon("images/undo.png"), tr("&Undo"), this);
connect(UndoAct, SIGNAL(triggered()), this, SLOT(undo()));
InsertARectangleAct = new QAction(QIcon("images/rectangle.png"), tr("&Insert a rectangle"), this);
connect(InsertARectangleAct, SIGNAL(triggered()), this, SLOT(insertRectangle()));
InsertACircleAct = new QAction(QIcon("images/circle.png"), tr("&Insert a circle"), this);
connect(InsertACircleAct, SIGNAL(triggered()), this, SLOT(insertCircle()));
InsertATriangleAct = new QAction(QIcon("images/triangle.png"), tr("&Insert a triangle"), this);
connect(InsertATriangleAct, SIGNAL(triggered()), this, SLOT(insertTriangle()));
UpAct = new QAction(QIcon("images/up.png"), tr("&Up"), this);
connect(UpAct, SIGNAL(triggered()), this, SLOT(up()));
DownAct = new QAction(QIcon("images/down.png"), tr("&Down"), this);
connect(DownAct, SIGNAL(triggered()), this, SLOT(down()));
ExpandAct = new QAction(QIcon("images/expand.png"), tr("&Expand"), this);
connect(ExpandAct, SIGNAL(triggered()), this, SLOT(expand()));
CollapseAct = new QAction(QIcon("images/collapse.png"), tr("&Collapse"), this);
connect(CollapseAct, SIGNAL(triggered()), this, SLOT(collapse()));
ExpandOneAct = new QAction(QIcon("images/expand2.png"), tr("&Expand"), this);
connect(ExpandOneAct, SIGNAL(triggered()), this, SLOT(expandOne()));
CollapseOneAct = new QAction(QIcon("images/collapse2.png"), tr("&Collapse"), this);
connect(CollapseOneAct, SIGNAL(triggered()), this, SLOT(collapseOne()));
ClearAct = new QAction(QIcon("images/clear.png"), tr("&Clear"), this);
connect(ClearAct, SIGNAL(triggered()), this, SLOT(clear()));
initialAction();
GraphicAction.push_back(DeleteAct);
GraphicAction.push_back(InsertAChildAct);
GraphicAction.push_back(InsertASiblingAct);
GraphicAction.push_back(InsertAParentAct);
GraphicAction.push_back(EditAct);
GraphicAction.push_back(CutAct);
GraphicAction.push_back(CopyAct);
GraphicAction.push_back(PasteAct);
GraphicAction.push_back(RedoAct);
GraphicAction.push_back(UndoAct);
GraphicAction.push_back(InsertARectangleAct);
GraphicAction.push_back(InsertACircleAct);
GraphicAction.push_back(InsertATriangleAct);
GraphicAction.push_back(UpAct);
GraphicAction.push_back(DownAct);
GraphicAction.push_back(ExpandAct);
GraphicAction.push_back(CollapseAct);
GraphicAction.push_back(ExpandOneAct);
GraphicAction.push_back(CollapseOneAct);
GraphicAction.push_back(ClearAct);
Gui_presentation->setGraphicAction(GraphicAction);
}
// -----------------------------------------------------------------------------
// Called when a key is pressed in the texture list
// -----------------------------------------------------------------------------
void TextureXPanel::onTextureListKeyDown(wxKeyEvent& e)
{
// Check if keypress matches any keybinds
wxArrayString binds = KeyBind::getBinds(KeyBind::asKeyPress(e.GetKeyCode(), e.GetModifiers()));
// Go through matching binds
for (unsigned a = 0; a < binds.size(); a++)
{
string name = binds[a];
// Copy
if (name == "copy")
{
copy();
return;
}
// Cut
else if (name == "cut")
{
copy();
removeTexture();
return;
}
// Paste
else if (name == "paste")
{
paste();
return;
}
// Move texture up
else if (name == "txed_tex_up")
{
moveUp();
return;
}
// Move texture down
else if (name == "txed_tex_down")
{
moveDown();
return;
}
// New texture
else if (name == "txed_tex_new")
{
newTexture();
return;
}
// New texture from patch
else if (name == "txed_tex_new_patch")
{
newTextureFromPatch();
return;
}
// New texture from file
else if (name == "txed_tex_new_file")
{
newTextureFromFile();
return;
}
// Delete texture
else if (name == "txed_tex_delete")
{
removeTexture();
return;
}
}
// Not handled here, send off to be handled by a parent window
e.Skip();
}
WorkoutWindow::WorkoutWindow(Context *context) :
GcWindow(context), draw(true), context(context), active(false), recording(false)
{
setContentsMargins(0,0,0,0);
setProperty("color", GColor(CTRAINPLOTBACKGROUND));
setControls(NULL);
ergFile = NULL;
QVBoxLayout *main = new QVBoxLayout(this);
QHBoxLayout *layout = new QHBoxLayout;
QVBoxLayout *editor = new QVBoxLayout;
connect(context, SIGNAL(configChanged(qint32)), this, SLOT(configChanged(qint32)));
// the workout scene
workout = new WorkoutWidget(this, context);
// paint the TTE curve
mmp = new WWMMPCurve(workout);
// add a line between the dots
line = new WWLine(workout);
// block cursos
bcursor = new WWBlockCursor(workout);
// block selection
brect = new WWBlockSelection(workout);
// paint the W'bal curve
wbline = new WWWBLine(workout, context);
// add the power, W'bal scale
powerscale = new WWPowerScale(workout, context);
wbalscale = new WWWBalScale(workout, context);
// lap markers
lap = new WWLap(workout);
// tte warning bar at bottom
tte = new WWTTE(workout);
// selection tool
rect = new WWRect(workout);
// guides always on top!
guide = new WWSmartGuide(workout);
// recording ...
now = new WWNow(workout, context);
telemetry = new WWTelemetry(workout, context);
// scroller, hidden until needed
scroll = new QScrollBar(Qt::Horizontal, this);
scroll->hide();
// setup the toolbar
toolbar = new QToolBar(this);
toolbar->setToolButtonStyle(Qt::ToolButtonTextUnderIcon);
toolbar->setFloatable(true);
toolbar->setIconSize(QSize(18,18));
QIcon newIcon(":images/toolbar/new doc.png");
newAct = new QAction(newIcon, tr("New"), this);
connect(newAct, SIGNAL(triggered()), this, SLOT(newFile()));
toolbar->addAction(newAct);
QIcon saveIcon(":images/toolbar/save.png");
saveAct = new QAction(saveIcon, tr("Save"), this);
connect(saveAct, SIGNAL(triggered()), this, SLOT(saveFile()));
toolbar->addAction(saveAct);
QIcon saveAsIcon(":images/toolbar/saveas.png");
saveAsAct = new QAction(saveAsIcon, tr("Save As"), this);
connect(saveAsAct, SIGNAL(triggered()), this, SLOT(saveAs()));
toolbar->addAction(saveAsAct);
toolbar->addSeparator();
//XXX TODO
//XXXHelpWhatsThis *helpToolbar = new HelpWhatsThis(toolbar);
//XXXtoolbar->setWhatsThis(helpToolbar->getWhatsThisText(HelpWhatsThis::ChartRides_Editor));
// undo and redo deliberately at a distance from the
// save icon, since accidentally hitting the wrong
// icon in that instance would be horrible
QIcon undoIcon(":images/toolbar/undo.png");
undoAct = new QAction(undoIcon, tr("Undo"), this);
connect(undoAct, SIGNAL(triggered()), workout, SLOT(undo()));
toolbar->addAction(undoAct);
QIcon redoIcon(":images/toolbar/redo.png");
redoAct = new QAction(redoIcon, tr("Redo"), this);
connect(redoAct, SIGNAL(triggered()), workout, SLOT(redo()));
toolbar->addAction(redoAct);
toolbar->addSeparator();
QIcon drawIcon(":images/toolbar/edit.png");
drawAct = new QAction(drawIcon, tr("Draw"), this);
connect(drawAct, SIGNAL(triggered()), this, SLOT(drawMode()));
toolbar->addAction(drawAct);
QIcon selectIcon(":images/toolbar/select.png");
selectAct = new QAction(selectIcon, tr("Select"), this);
connect(selectAct, SIGNAL(triggered()), this, SLOT(selectMode()));
toolbar->addAction(selectAct);
selectAct->setEnabled(true);
drawAct->setEnabled(false);
toolbar->addSeparator();
QIcon cutIcon(":images/toolbar/cut.png");
cutAct = new QAction(cutIcon, tr("Cut"), this);
cutAct->setEnabled(true);
toolbar->addAction(cutAct);
connect(cutAct, SIGNAL(triggered()), workout, SLOT(cut()));
QIcon copyIcon(":images/toolbar/copy.png");
copyAct = new QAction(copyIcon, tr("Copy"), this);
copyAct->setEnabled(true);
toolbar->addAction(copyAct);
connect(copyAct, SIGNAL(triggered()), workout, SLOT(copy()));
QIcon pasteIcon(":images/toolbar/paste.png");
pasteAct = new QAction(pasteIcon, tr("Paste"), this);
pasteAct->setEnabled(false);
toolbar->addAction(pasteAct);
connect(pasteAct, SIGNAL(triggered()), workout, SLOT(paste()));
toolbar->addSeparator();
QIcon propertiesIcon(":images/toolbar/properties.png");
propertiesAct = new QAction(propertiesIcon, tr("Properties"), this);
connect(propertiesAct, SIGNAL(triggered()), this, SLOT(properties()));
toolbar->addAction(propertiesAct);
QIcon zoomInIcon(":images/toolbar/zoom in.png");
zoomInAct = new QAction(zoomInIcon, tr("Zoom In"), this);
connect(zoomInAct, SIGNAL(triggered()), this, SLOT(zoomIn()));
toolbar->addAction(zoomInAct);
QIcon zoomOutIcon(":images/toolbar/zoom out.png");
zoomOutAct = new QAction(zoomOutIcon, tr("Zoom Out"), this);
connect(zoomOutAct, SIGNAL(triggered()), this, SLOT(zoomOut()));
toolbar->addAction(zoomOutAct);
// stretch the labels to the right hand side
QWidget *empty = new QWidget(this);
empty->setSizePolicy(QSizePolicy::Expanding,QSizePolicy::Preferred);
toolbar->addWidget(empty);
xlabel = new QLabel("00:00");
toolbar->addWidget(xlabel);
ylabel = new QLabel("150w");
toolbar->addWidget(ylabel);
IFlabel = new QLabel("0 IF");
toolbar->addWidget(IFlabel);
TSSlabel = new QLabel("0 TSS");
toolbar->addWidget(TSSlabel);
#if 0 // not yet!
// get updates..
connect(context, SIGNAL(telemetryUpdate(RealtimeData)), this, SLOT(telemetryUpdate(RealtimeData)));
telemetryUpdate(RealtimeData());
#endif
// editing the code...
code = new CodeEditor(this);
code->setContextMenuPolicy(Qt::NoContextMenu); // no context menu
code->installEventFilter(this); // filter the undo/redo stuff
code->hide();
// WATTS and Duration for the cursor
main->addWidget(toolbar);
editor->addWidget(workout);
editor->addWidget(scroll);
layout->addLayout(editor);
layout->addWidget(code);
main->addLayout(layout);
// make it look right
saveAct->setEnabled(false);
undoAct->setEnabled(false);
redoAct->setEnabled(false);
// watch for erg file selection
connect(context, SIGNAL(ergFileSelected(ErgFile*)), this, SLOT(ergFileSelected(ErgFile*)));
// watch for erg run/stop
connect(context, SIGNAL(start()), this, SLOT(start()));
connect(context, SIGNAL(stop()), this, SLOT(stop()));
// text changed
connect(code, SIGNAL(textChanged()), this, SLOT(qwkcodeChanged()));
connect(code, SIGNAL(cursorPositionChanged()), workout, SLOT(hoverQwkcode()));
// scrollbar
connect(scroll, SIGNAL(sliderMoved(int)), this, SLOT(scrollMoved()));
// set the widgets etc
configChanged(CONFIG_APPEARANCE);
}
RichTextEdit::RichTextEdit(QWidget *parent)
: QWidget(parent)
{
layout = new QVBoxLayout;
layout->setContentsMargins(0, 0, 0, 0);
toolbar = new QToolBar;
setupActions();
layout->addWidget(toolbar);
fontToolbar = new QToolBar;
setupFontActions();
layout->addWidget(fontToolbar);
textedit = new QTextEdit;
textedit->setTabStopWidth(40);
layout->addWidget(textedit);
findWidget = new TextFind(this);
findWidget->hide();
layout->addWidget(findWidget);
setLayout(layout);
// find
connect(actionFind, SIGNAL(triggered()), findWidget, SLOT(show()));
connect(findWidget->getNextBtn(), SIGNAL(clicked()), this, SLOT(findNext()));
connect(findWidget->getPrevBtn(), SIGNAL(clicked()), this, SLOT(findPrev()));
connect(findWidget->getFindEdit(), SIGNAL(textChanged(const QString&)), this, SLOT(findFirst()));
// save
connect(actionSave, SIGNAL(triggered()), this, SLOT(saveContent()));
// alignment
alignmentChanged(textedit->alignment());
connect(textedit, SIGNAL(cursorPositionChanged()),
this, SLOT(cursorPositionChanged()));
// color & font
connect(textedit, SIGNAL(currentCharFormatChanged(const QTextCharFormat &)),
this, SLOT(currentCharFormatChanged(const QTextCharFormat &)));
colorChanged(textedit->textColor());
fontChanged(textedit->font());
// undo & redo
connect(textedit->document(), SIGNAL(undoAvailable(bool)),
actionUndo, SLOT(setEnabled(bool)));
connect(textedit->document(), SIGNAL(redoAvailable(bool)),
actionRedo, SLOT(setEnabled(bool)));
setWindowModified(textedit->document()->isModified());
actionUndo->setEnabled(textedit->document()->isUndoAvailable());
actionRedo->setEnabled(textedit->document()->isRedoAvailable());
connect(actionUndo, SIGNAL(triggered()), textedit, SLOT(undo()));
connect(actionRedo, SIGNAL(triggered()), textedit, SLOT(redo()));
// cut, copy, paste
actionCut->setEnabled(false);
actionCopy->setEnabled(false);
connect(actionCut, SIGNAL(triggered()), textedit, SLOT(cut()));
connect(actionCopy, SIGNAL(triggered()), textedit, SLOT(copy()));
connect(actionPaste, SIGNAL(triggered()), textedit, SLOT(paste()));
connect(textedit, SIGNAL(copyAvailable(bool)), actionCut, SLOT(setEnabled(bool)));
connect(textedit, SIGNAL(copyAvailable(bool)), actionCopy, SLOT(setEnabled(bool)));
connect(QApplication::clipboard(), SIGNAL(dataChanged()),
this, SLOT(clipboardDataChanged()));
}
void WldScene::mouseReleaseEvent(QGraphicsSceneMouseEvent *mouseEvent)
{
if(MouseReleaseEventOnly)
{
QGraphicsScene::mousePressEvent(mouseEvent);
MouseReleaseEventOnly = false;
return;
}
bool isLeftMouse=false;
bool isMiddleMouse=false;
if( mouseEvent->button() == Qt::LeftButton )
{
mouseLeft=false;
isLeftMouse=true;
WriteToLog(QtDebugMsg, QString("Left mouse button released [edit mode: %1]").arg(EditingMode));
}
if( mouseEvent->button() == Qt::MiddleButton )
{
mouseMid=false;
isMiddleMouse=true;
WriteToLog(QtDebugMsg, QString("Middle mouse button released [edit mode: %1]").arg(EditingMode));
}
if( mouseEvent->button() == Qt::RightButton )
{
mouseRight=false;
WriteToLog(QtDebugMsg, QString("Right mouse button released [edit mode: %1]").arg(EditingMode));
}
if(contextMenuOpened)
{
contextMenuOpened = false; //bug protector
QGraphicsScene::mouseReleaseEvent(mouseEvent);
return;
}
contextMenuOpened=false;
if(!isLeftMouse)
{
if(PasteFromBuffer && GlobalSettings::MidMouse_allowDuplicate && isMiddleMouse &&
(EditingMode==MODE_Selecting||EditingMode==MODE_SelectingOnly))
{
clearSelection();
paste( WldBuffer, mouseEvent->scenePos().toPoint() );
Debugger_updateItemList();
PasteFromBuffer = false;
}
if(GlobalSettings::MidMouse_allowSwitchToDrag && isMiddleMouse &&
(EditingMode==MODE_Selecting||EditingMode==MODE_SelectingOnly) && selectedItems().isEmpty())
{
MainWinConnect::pMainWin->on_actionHandScroll_triggered();
}
QGraphicsScene::mouseReleaseEvent(mouseEvent);
return;
}
if(CurrentMode) CurrentMode->mouseRelease(mouseEvent);
if(!CurrentMode->noEvent())
QGraphicsScene::mouseReleaseEvent(mouseEvent);
}
CamlDevWindow::CamlDevWindow(QString wd, QWidget *parent) :
QMainWindow(parent)
{
this->camlProcess = new QProcess(this);
this->camlStarted = false;
this->currentFile = "";
this->cwd = wd;
this->unsavedChanges = false;
this->programTitle = "LemonCaml";
/* The window title and icon */
this->setWindowTitle(this->programTitle + " - " + "untitled");
this->setWindowIcon(QIcon(":/progicon.png"));
this->settings = new QSettings("Cocodidou", "LemonCaml");
this->globalSettings = new QSettings(QSettings::SystemScope, "Cocodidou", "LemonCaml");
/* The main window elements : two text-areas and a splitter */
this->centralBox = new QVBoxLayout();
this->split = new QSplitter(Qt::Horizontal,this);
this->inputZone = new InputZone();
this->inputZone->setTabStopWidth(20);
this->inputZone->setAcceptRichText(false);
this->resize(settings->value("Size/y",800).toInt(), settings->value("Size/x",600).toInt());
this->move(settings->value("Pos/x",0).toInt(), settings->value("Pos/y",0).toInt());
this->setWindowFlags( (windowFlags() | Qt::CustomizeWindowHint));
#ifndef WIN32
QString defaultFont = "Andale Mono,10,-1,5,50,0,0,0,0,0";
#else
QString defaultFont = "Courier New,10,-1,5,50,0,0,0,0,0";
#endif
QString iFont = settings->value("Input/Font", defaultFont).toString();
QFont inputFont;
inputFont.fromString(iFont);
this->inputZone->setFont(inputFont);
this->outputZone = new QTextEdit(this);
this->outputZone->setReadOnly(true);
this->outputZone->setTabStopWidth(20);
QString kwfileloc = settings->value("General/keywordspath", (globalSettings->value("General/keywordspath", "./keywords").toString())).toString();
QFile kwfile(kwfileloc);
QStringList kwds;
if(kwfile.open(QIODevice::ReadOnly | QIODevice::Text))
{
QTextStream kstream(&kwfile);
QString st = kstream.readLine(256);
while(st != "")
{
kwds << st;
st = kstream.readLine(256);
}
kwfile.close();
}
else
{
QMessageBox::warning(this, tr("Warning"), tr("Unable to open the keywords file. There will likely be no syntax highlighting."));
}
this->hilit = new highlighter(inputZone->document(), &kwds, this->settings);
bool isHighlighting = (settings->value("Input/syntaxHighlight",1).toInt() == 1);
if(!isHighlighting)
{
this->hilit->setDocument(NULL);
}
QString oFont = settings->value("Output/Font", defaultFont).toString();
QFont outputFont;
outputFont.fromString(oFont);
this->outputZone->setFont(outputFont);
/* Find/Replace */
this->find = new findReplace(inputZone, hilit);
split->addWidget(this->inputZone);
split->addWidget(this->outputZone);
split->showMaximized();
centralBox->addWidget(split);
centralBox->addWidget(find);
if(!centralBox->setStretchFactor(split, 100))
qDebug() << "There will be a problem with Find/replace!";
centralBox->setContentsMargins(0,0,0,0);
/* a wrapper widget */
QWidget *window = new QWidget();
window->setLayout(centralBox);
window->setContentsMargins(0,0,0,0);
this->setCentralWidget(window);
find->setVisible(false);
if(settings->value("Input/indentOnFly",0).toInt() == 1)
inputZone->setHandleEnter(true);
/* the printer*/
this->printer = new QPrinter(QPrinter::HighResolution);
/* The actions */
this->actionNew = new QAction(tr("New"),this);
this->actionNew->setIcon(QIcon(":/new.png"));
this->actionNew->setShortcut(QKeySequence(QKeySequence::New));
this->actionOpen = new QAction(tr("Open"),this);
this->actionOpen->setIcon(QIcon(":/open.png"));
this->actionOpen->setShortcut(QKeySequence(QKeySequence::Open));
this->actionSaveAs = new QAction(tr("Save As"),this);
this->actionSaveAs->setIcon(QIcon(":/saveas.png"));
this->actionSaveAs->setShortcut(QKeySequence(QKeySequence::SaveAs));
this->actionSave = new QAction(tr("Save"),this);
this->actionSave->setIcon(QIcon(":/save.png"));
this->actionSave->setShortcut(QKeySequence(QKeySequence::Save));
this->actionAutoIndent = new QAction(tr("Indent code"),this);
this->actionAutoIndent->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_W));
this->actionFollowCursor = new QAction(tr("Indent code while typing"),this);
this->actionFollowCursor->setCheckable(true);
this->actionFollowCursor->setChecked(inputZone->getHandleEnter());
this->actionFollowCursor->setIcon(QIcon(":/autoindent.png"));
this->actionPrint = new QAction(tr("Print"),this);
this->actionPrint->setIcon(QIcon(":/print.png"));
this->actionPrint->setShortcut(QKeySequence(QKeySequence::Print));
this->actionClearOutput = new QAction(tr("Clear output"),this);
this->actionQuit = new QAction(tr("Quit"),this);
this->actionQuit->setIcon(QIcon(":/exit.png"));
this->actionQuit->setShortcut(QKeySequence(QKeySequence::Quit));
this->actionUndo = new QAction(tr("Undo"),this);
this->actionUndo->setIcon(QIcon(":/undo.png"));
this->actionUndo->setShortcut(QKeySequence(QKeySequence::Undo));
this->actionRedo = new QAction(tr("Redo"),this);
this->actionRedo->setIcon(QIcon(":/redo.png"));
this->actionRedo->setShortcut(QKeySequence(QKeySequence::Redo));
this->actionDelete = new QAction(tr("Delete"),this);
this->actionChangeInputFont = new QAction(tr("Change Input Font"),this);
this->actionChangeOutputFont = new QAction(tr("Change Output Font"),this);
this->actionSendCaml = new QAction(tr("Send Code to Caml"),this);
this->actionSendCaml->setIcon(QIcon(":/sendcaml.png"));
this->actionSendCaml->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_Return));
this->actionInterruptCaml = new QAction(tr("Interrupt Caml"),this);
this->actionInterruptCaml->setIcon(QIcon(":/interrupt.png"));
this->actionStopCaml = new QAction(tr("Stop Caml"),this);
this->actionStopCaml->setIcon(QIcon(":/stopcaml.png"));
this->actionShowSettings = new QAction(tr("Settings"),this);
this->actionShowSettings->setShortcut(QKeySequence(QKeySequence::Preferences));
this->actionAbout = new QAction(tr("About LemonCaml..."),this);
this->actionAboutQt = new QAction(tr("About Qt..."),this);
this->actionHighlightEnable = new QAction(tr("Enable syntax highlighting"), this);
this->actionHighlightEnable->setIcon(QIcon(":/highlight.png"));
this->actionHighlightEnable->setCheckable(true);
this->actionHighlightEnable->setChecked(isHighlighting);
this->actionZoomIn = new QAction(tr("Zoom in"), this);
this->actionZoomIn->setShortcut(QKeySequence(QKeySequence::ZoomIn));
this->actionZoomOut = new QAction(tr("Zoom out"), this);
this->actionZoomOut->setShortcut(QKeySequence(QKeySequence::ZoomOut));
this->actionFind = new QAction(tr("Find/Replace..."), this);
this->actionFind->setShortcut(QKeySequence(QKeySequence::Find));
this->actionFind->setIcon(QIcon(":/find.png"));
this->actionFind->setCheckable(true);
this->actionFind->setChecked(false);
/* The toolbar */
this->toolbar = new QToolBar(tr("Tools"),this);
this->toolbar->addAction(actionNew);
this->toolbar->addAction(actionOpen);
this->toolbar->addAction(actionSave);
this->toolbar->addAction(actionSaveAs);
this->toolbar->addAction(actionPrint);
this->toolbar->addSeparator();
this->toolbar->addAction(actionUndo);
this->toolbar->addAction(actionRedo);
this->toolbar->addSeparator();
this->toolbar->addAction(actionSendCaml);
this->toolbar->addAction(actionInterruptCaml);
this->toolbar->addAction(actionStopCaml);
this->toolbar->addAction(actionHighlightEnable);
this->toolbar->addAction(actionFollowCursor);
this->addToolBar(this->toolbar);
/* The menubar */
this->menuFile = this->menuBar()->addMenu(tr("File"));
this->menuFile->addAction(actionNew);
this->menuFile->addAction(actionOpen);
this->menuRecent = this->menuFile->addMenu(tr("Recent files"));
this->menuFile->addAction(actionSave);
this->menuFile->addAction(actionSaveAs);
this->menuFile->addAction(actionPrint);
this->menuFile->addAction(actionQuit);
this->menuEdit = this->menuBar()->addMenu(tr("Edit"));
this->menuEdit->addAction(actionUndo);
this->menuEdit->addAction(actionRedo);
this->menuEdit->addAction(actionDelete);
this->menuEdit->addSeparator();
this->menuEdit->addAction(actionAutoIndent);
this->menuEdit->addAction(actionFollowCursor);
this->menuEdit->addSeparator();
this->menuEdit->addAction(actionFind);
this->menuEdit->addAction(actionClearOutput);
this->menuEdit->addAction(actionHighlightEnable);
this->menuEdit->addAction(actionChangeInputFont);
this->menuEdit->addAction(actionChangeOutputFont);
this->menuEdit->addAction(actionZoomIn);
this->menuEdit->addAction(actionZoomOut);
this->menuCaml = this->menuBar()->addMenu(tr("Caml"));
this->menuCaml->addAction(actionSendCaml);
this->menuCaml->addAction(actionInterruptCaml);
this->menuCaml->addAction(actionStopCaml);
this->menuCaml->addAction(actionShowSettings);
this->menuHelp = this->menuBar()->addMenu(tr("Help"));
this->menuHelp->addAction(actionAbout);
this->menuHelp->addAction(actionAboutQt);
/* Connections */
connect(inputZone,SIGNAL(returnPressed()),this,SLOT(handleLineBreak()));
connect(actionSendCaml,SIGNAL(triggered()),this,SLOT(sendCaml()));
connect(camlProcess,SIGNAL(readyReadStandardOutput()),this,SLOT(readCaml()));
connect(camlProcess,SIGNAL(readyReadStandardError()),this,SLOT(readCamlErrors()));
connect(camlProcess,SIGNAL(stateChanged(QProcess::ProcessState)),this,SLOT(updateCamlStatus(QProcess::ProcessState)));
connect(actionStopCaml,SIGNAL(triggered()),this,SLOT(stopCaml()));
connect(camlProcess,SIGNAL(started()),this,SLOT(camlOK()));
connect(actionInterruptCaml,SIGNAL(triggered()),this,SLOT(interruptCaml()));
connect(actionSave,SIGNAL(triggered()),this,SLOT(save()));
connect(actionSaveAs,SIGNAL(triggered()),this,SLOT(saveAs()));
connect(actionOpen,SIGNAL(triggered()),this,SLOT(open()));
connect(inputZone,SIGNAL(textChanged()),this,SLOT(textChanged()));
connect(actionNew,SIGNAL(triggered()),this,SLOT(newFile()));
connect(actionClearOutput,SIGNAL(triggered()),this->outputZone,SLOT(clear()));
connect(actionChangeInputFont,SIGNAL(triggered()),this,SLOT(changeInputFont()));
connect(actionChangeOutputFont,SIGNAL(triggered()),this,SLOT(changeOutputFont()));
connect(actionQuit,SIGNAL(triggered()),this,SLOT(close()));
connect(actionPrint,SIGNAL(triggered()),this,SLOT(print()));
connect(actionUndo,SIGNAL(triggered()),this->inputZone,SLOT(undo()));
connect(actionRedo,SIGNAL(triggered()),this->inputZone,SLOT(redo()));
connect(actionDelete,SIGNAL(triggered()),this->inputZone,SLOT(paste()));
connect(actionShowSettings,SIGNAL(triggered()),this,SLOT(showSettings()));
connect(actionHighlightEnable,SIGNAL(toggled(bool)),this,SLOT(toggleHighlightOn(bool)));
connect(actionAutoIndent,SIGNAL(triggered()),this,SLOT(autoIndentCode()));
connect(actionFollowCursor,SIGNAL(triggered(bool)),this,SLOT(toggleAutoIndentOn(bool)));
connect(actionZoomIn,SIGNAL(triggered()),this,SLOT(zoomIn()));
connect(actionZoomOut,SIGNAL(triggered()),this,SLOT(zoomOut()));
connect(actionFind,SIGNAL(triggered(bool)),this,SLOT(triggerFindReplace(bool)));
connect(find,SIGNAL(hideRequest(bool)),this,SLOT(triggerFindReplace(bool)));
connect(inputZone, SIGNAL(unindentKeyStrokePressed()), this, SLOT(unindent()));
connect(actionAbout,SIGNAL(triggered()),this,SLOT(about()));
connect(actionAboutQt,SIGNAL(triggered()),this,SLOT(aboutQt()));
this->generateRecentMenu();
this->populateRecent();
this->highlightTriggered = false;
fillIndentWords(&indentWords);
//Draw trees?
this->drawTrees = (settings->value("General/drawTrees",0).toInt() == 1)?true:false;
this->graphCount = 0;
this->startCamlProcess();
}
TextEdit::TextEdit(QWidget *parent)
: QMainWindow(parent)
{
setToolButtonStyle(Qt::ToolButtonFollowStyle);
setupFileActions();
setupEditActions();
setupTextActions();
{
QMenu *helpMenu = new QMenu(tr("Help"), this);
menuBar()->addMenu(helpMenu);
helpMenu->addAction(tr("About"), this, SLOT(about()));
helpMenu->addAction(tr("About &Qt"), qApp, SLOT(aboutQt()));
}
textEdit = new QTextEdit(this);
connect(textEdit, SIGNAL(currentCharFormatChanged(QTextCharFormat)),
this, SLOT(currentCharFormatChanged(QTextCharFormat)));
connect(textEdit, SIGNAL(cursorPositionChanged()),
this, SLOT(cursorPositionChanged()));
setCentralWidget(textEdit);
textEdit->setFocus();
setCurrentFileName(QString());
fontChanged(textEdit->font());
colorChanged(textEdit->textColor());
alignmentChanged(textEdit->alignment());
connect(textEdit->document(), SIGNAL(modificationChanged(bool)),
actionSave, SLOT(setEnabled(bool)));
connect(textEdit->document(), SIGNAL(modificationChanged(bool)),
this, SLOT(setWindowModified(bool)));
connect(textEdit->document(), SIGNAL(undoAvailable(bool)),
actionUndo, SLOT(setEnabled(bool)));
connect(textEdit->document(), SIGNAL(redoAvailable(bool)),
actionRedo, SLOT(setEnabled(bool)));
setWindowModified(textEdit->document()->isModified());
actionSave->setEnabled(textEdit->document()->isModified());
actionUndo->setEnabled(textEdit->document()->isUndoAvailable());
actionRedo->setEnabled(textEdit->document()->isRedoAvailable());
connect(actionUndo, SIGNAL(triggered()), textEdit, SLOT(undo()));
connect(actionRedo, SIGNAL(triggered()), textEdit, SLOT(redo()));
actionCut->setEnabled(false);
actionCopy->setEnabled(false);
connect(actionCut, SIGNAL(triggered()), textEdit, SLOT(cut()));
connect(actionCopy, SIGNAL(triggered()), textEdit, SLOT(copy()));
connect(actionPaste, SIGNAL(triggered()), textEdit, SLOT(paste()));
connect(textEdit, SIGNAL(copyAvailable(bool)), actionCut, SLOT(setEnabled(bool)));
connect(textEdit, SIGNAL(copyAvailable(bool)), actionCopy, SLOT(setEnabled(bool)));
#ifndef QT_NO_CLIPBOARD
connect(QApplication::clipboard(), SIGNAL(dataChanged()), this, SLOT(clipboardDataChanged()));
#endif
QString initialFile = ":/example.html";
const QStringList args = QCoreApplication::arguments();
if (args.count() == 2)
initialFile = args.at(1);
if (!load(initialFile))
fileNew();
}
bool TextWidget::on_key_event(const KeyEvent *event) {
if (!_text_interaction_on)
return false;
if (_on_key_event(this, event)) {
// user ate this event
return true;
}
if (event->action == KeyActionUp)
return false;
int start, end;
get_cursor_slice(start, end);
switch (event->virt_key) {
case VirtKeyLeft:
if (key_mod_ctrl(event->modifiers) && key_mod_shift(event->modifiers)) {
int new_end = backward_word();
set_selection(_cursor_start, new_end);
} else if (key_mod_ctrl(event->modifiers)) {
int new_start = backward_word();
set_selection(new_start, new_start);
} else if (key_mod_shift(event->modifiers)) {
set_selection(_cursor_start, _cursor_end - 1);
} else {
if (start == end) {
set_selection(start - 1, start - 1);
} else {
set_selection(start, start);
}
}
return true;
case VirtKeyRight:
if (key_mod_ctrl(event->modifiers) && key_mod_shift(event->modifiers)) {
int new_end = forward_word();
set_selection(_cursor_start, new_end);
} else if (key_mod_ctrl(event->modifiers)) {
int new_start = forward_word();
set_selection(new_start, new_start);
} else if (key_mod_shift(event->modifiers)) {
set_selection(_cursor_start, _cursor_end + 1);
} else {
if (start == end) {
set_selection(start + 1, end + 1);
} else {
set_selection(end, end);
}
}
return true;
case VirtKeyBackspace:
if (start == end) {
if (key_mod_ctrl(event->modifiers)) {
int new_start = backward_word();
replace_text(new_start, start, "", 0);
} else {
replace_text(start - 1, end, "", 0);
}
} else {
replace_text(start, end, "", 0);
}
return true;
case VirtKeyDelete:
if (start == end) {
if (key_mod_ctrl(event->modifiers)) {
int new_start = forward_word();
replace_text(start, new_start, "", 0);
} else {
replace_text(start, end + 1, "", 0);
}
} else {
replace_text(start, end, "", 0);
}
return true;
case VirtKeyHome:
if (key_mod_shift(event->modifiers)) {
set_selection(_cursor_start, 0);
} else {
set_selection(0, 0);
}
return true;
case VirtKeyEnd:
if (key_mod_shift(event->modifiers)) {
set_selection(_cursor_start, _label.text().length());
} else {
set_selection(_label.text().length(), _label.text().length());
}
return true;
case VirtKeyA:
if (key_mod_only_ctrl(event->modifiers)) {
select_all();
return true;
}
case VirtKeyX:
if (key_mod_only_ctrl(event->modifiers)) {
cut();
return true;
}
case VirtKeyC:
if (key_mod_only_ctrl(event->modifiers)) {
copy();
return true;
}
case VirtKeyV:
if (key_mod_only_ctrl(event->modifiers)) {
paste();
return true;
}
default:
// do nothing
return true;
}
}
void
textselect(Text *t)
{
uint q0, q1;
int b, x, y;
int state;
selecttext = t;
/*
* To have double-clicking and chording, we double-click
* immediately if it might make sense.
*/
b = mouse->buttons;
q0 = t->q0;
q1 = t->q1;
selectq = t->org+frcharofpt(t, mouse->xy);
if(clicktext==t && mouse->msec-clickmsec<500)
if(q0==q1 && selectq==q0){
textdoubleclick(t, &q0, &q1);
textsetselect(t, q0, q1);
flushimage(display, 1);
x = mouse->xy.x;
y = mouse->xy.y;
/* stay here until something interesting happens */
do
readmouse(mousectl);
while(mouse->buttons==b && abs(mouse->xy.x-x)<3 && abs(mouse->xy.y-y)<3);
mouse->xy.x = x; /* in case we're calling frselect */
mouse->xy.y = y;
q0 = t->q0; /* may have changed */
q1 = t->q1;
selectq = q0;
}
if(mouse->buttons == b){
t->Frame.scroll = framescroll;
frselect(t, mousectl);
/* horrible botch: while asleep, may have lost selection altogether */
if(selectq > t->file->nc)
selectq = t->org + t->p0;
t->Frame.scroll = nil;
if(selectq < t->org)
q0 = selectq;
else
q0 = t->org + t->p0;
if(selectq > t->org+t->nchars)
q1 = selectq;
else
q1 = t->org+t->p1;
}
if(q0 == q1){
if(q0==t->q0 && clicktext==t && mouse->msec-clickmsec<500){
textdoubleclick(t, &q0, &q1);
clicktext = nil;
}else{
clicktext = t;
clickmsec = mouse->msec;
}
}else
clicktext = nil;
textsetselect(t, q0, q1);
flushimage(display, 1);
state = 0; /* undo when possible; +1 for cut, -1 for paste */
while(mouse->buttons){
mouse->msec = 0;
b = mouse->buttons;
if((b&1) && (b&6)){
if(state==0 && t->what==Body){
seq++;
filemark(t->w->body.file);
}
if(b & 2){
if(state==-1 && t->what==Body){
winundo(t->w, TRUE);
textsetselect(t, q0, t->q0);
state = 0;
}else if(state != 1){
cut(t, t, nil, TRUE, TRUE, nil, 0);
state = 1;
}
}else{
if(state==1 && t->what==Body){
winundo(t->w, TRUE);
textsetselect(t, q0, t->q1);
state = 0;
}else if(state != -1){
paste(t, t, nil, TRUE, FALSE, nil, 0);
state = -1;
}
}
textscrdraw(t);
clearmouse();
}
flushimage(display, 1);
while(mouse->buttons == b)
readmouse(mousectl);
clicktext = nil;
}
}
int mainForm::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = Q3MainWindow::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0: fileOpen((*reinterpret_cast< const QString(*)>(_a[1]))); break;
case 1: fileOpen(); break;
case 2: fileNew(); break;
case 3: populateStructure(); break;
case 4: populateTable((*reinterpret_cast< const QString(*)>(_a[1]))); break;
case 5: resetBrowser(); break;
case 6: fileClose(); break;
case 7: fileExit(); break;
case 8: closeEvent((*reinterpret_cast< QCloseEvent*(*)>(_a[1]))); break;
case 9: addRecord(); break;
case 10: deleteRecord(); break;
case 11: updateTableView((*reinterpret_cast< int(*)>(_a[1]))); break;
case 12: selectTableLine((*reinterpret_cast< int(*)>(_a[1]))); break;
case 13: navigatePrevious(); break;
case 14: navigateNext(); break;
case 15: navigateGoto(); break;
case 16: setRecordsetLabel(); break;
case 17: browseFind((*reinterpret_cast< bool(*)>(_a[1]))); break;
case 18: browseFindAway(); break;
case 19: lookfor((*reinterpret_cast< const QString(*)>(_a[1])),(*reinterpret_cast< const QString(*)>(_a[2])),(*reinterpret_cast< const QString(*)>(_a[3]))); break;
case 20: showrecord((*reinterpret_cast< int(*)>(_a[1]))); break;
case 21: createTable(); break;
case 22: createIndex(); break;
case 23: compact(); break;
case 24: deleteTable(); break;
case 25: editTable(); break;
case 26: deleteIndex(); break;
case 27: copy(); break;
case 28: paste(); break;
case 29: helpWhatsThis(); break;
case 30: helpAbout(); break;
case 31: updateRecordText((*reinterpret_cast< int(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2])),(*reinterpret_cast< QString(*)>(_a[3]))); break;
case 32: logWinAway(); break;
case 33: editWinAway(); break;
case 34: editText((*reinterpret_cast< int(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2]))); break;
case 35: doubleClickTable((*reinterpret_cast< int(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2])),(*reinterpret_cast< int(*)>(_a[3])),(*reinterpret_cast< const QPoint(*)>(_a[4]))); break;
case 36: executeQuery(); break;
case 37: mainTabSelected((*reinterpret_cast< const QString(*)>(_a[1]))); break;
case 38: toggleLogWindow((*reinterpret_cast< bool(*)>(_a[1]))); break;
case 39: importTableFromCSV(); break;
case 40: exportTableToCSV(); break;
case 41: dbState((*reinterpret_cast< bool(*)>(_a[1]))); break;
case 42: fileSave(); break;
case 43: fileRevert(); break;
case 44: exportDatabaseToSQL(); break;
case 45: importDatabaseFromSQL(); break;
case 46: openPreferences(); break;
case 47: updatePreferences(); break;
case 48: languageChange(); break;
default: ;
}
_id -= 49;
}
return _id;
}
void AppEditMenu::setupMenu(QMenu *editMenu, QToolBar *toolbar)
{
toolbar->addSeparator();
editUndoAction=editMenu->addAction(IconUtil::getIcon("undo"), tr("&Undo"), this, SLOT(undo()), QKeySequence(QKeySequence::Undo));
editUndoAction->setStatusTip(tr("Undo last edit action"));
toolbar->addAction(editUndoAction);
editRedoAction=editMenu->addAction(IconUtil::getIcon("redo"), tr("&Redo"), this, SLOT(redo()), QKeySequence(QKeySequence::Redo));
editRedoAction->setStatusTip(tr("Redo last undone edit action"));
toolbar->addAction(editRedoAction);
editMenu->addSeparator();
toolbar->addSeparator();
editCutAction=editMenu->addAction(IconUtil::getIcon("editcut"), tr("Cu&t"), this, SLOT(cut()), QKeySequence(QKeySequence::Cut));
editCutAction->setStatusTip(tr("Cut"));
toolbar->addAction(editCutAction);
editCopyAction=editMenu->addAction(IconUtil::getIcon("editcopy"), tr("&Copy"), this, SLOT(copy()), QKeySequence(QKeySequence::Copy));
editCopyAction->setStatusTip(tr("Copy"));
toolbar->addAction(editCopyAction);
//editCopyAsAction=editMenu->addAction(IconUtil::getIcon("editcopy"), tr("Copy as"));
//editCopyAsAction->setMenu(createCopyAsMenu(editMenu));
editPasteAction=editMenu->addAction(IconUtil::getIcon("editpaste"), tr("&Paste"), this, SLOT(paste()), QKeySequence(QKeySequence::Paste));
editPasteAction->setStatusTip(tr("Paste"));
toolbar->addAction(editPasteAction);
editMenu->addSeparator();
editSelectAllAction=editMenu->addAction(IconUtil::getIcon("editselectall"), tr("Select &All"), this, SLOT(selectAll()), QKeySequence(QKeySequence::SelectAll));
editSelectAllAction->setStatusTip(tr("Select All"));
editMenu->addSeparator();
toolbar->addSeparator();
editAdvancedAction = editMenu->addAction(tr("Advanced"));
createEditAdvancedMenu(toolbar);
editAdvancedAction->setMenu(editAdvancedMenu);
editMenu->addSeparator();
editDescribeAction=editMenu->addAction(tr("Describe object"), this, SLOT(describeObject()), QKeySequence("F4"));
editResolveAction=editMenu->addAction(tr("Object Menu"));
createEditResolveMenu();
editResolveAction->setMenu(editResolveMenu);
editMenu->addSeparator();
//toolbar->addSeparator();
editIncreaseFontSize=editMenu->addAction(tr("Increase font size"), this, SLOT(increaseFont()), QKeySequence(QKeySequence::ZoomIn));
editIncreaseFontSize->setStatusTip(tr("Increase font size"));
editDecreaseFontSize=editMenu->addAction(tr("Decrease font size"), this, SLOT(decreaseFont()), QKeySequence(QKeySequence::ZoomOut));
editDecreaseFontSize->setStatusTip(tr("Decrease font size"));
editResetFontSize=editMenu->addAction(tr("Reset font size"), this, SLOT(resetFont()), QKeySequence(tr("Ctrl+0", "Edit|Reset font size")));
editResetFontSize->setStatusTip(tr("Reset font size"));
editMenu->addSeparator();
toolbar->addSeparator();
editFindAction=editMenu->addAction(IconUtil::getIcon("find"), tr("&Find..."), this, SLOT(showSearchWidget()), QKeySequence("Ctrl+F"));
editFindAction->setStatusTip(tr("Find text"));
toolbar->addAction(editFindAction);
editFindPreviousAction=editMenu->addAction(IconUtil::getIcon("find_prev"), tr("Find p&revious"), this, SLOT(findPrevious()), QKeySequence("Shift+F3"));
editFindPreviousAction->setStatusTip(tr("Find previous occurence of current search text"));
toolbar->addAction(editFindPreviousAction);
editFindNextAction=editMenu->addAction(IconUtil::getIcon("find_next"), tr("Find &next"), this, SLOT(findNext()), QKeySequence("F3"));
editFindNextAction->setStatusTip(tr("Find next occurence of current search text"));
toolbar->addAction(editFindNextAction);
editMenu->addSeparator();
editGoToLineAction=editMenu->addAction(IconUtil::getIcon("goto_line"), tr("&Go to line..."), this, SLOT(goToLine()), QKeySequence("Ctrl+G"));
editGoToLineAction->setStatusTip(tr("Go to line"));
connect(editResolveMenu, SIGNAL(aboutToShow()), this, SLOT(populateResolveMenu()));
}
/*
* Constructs a mainForm as a child of 'parent', with the
* name 'name' and widget flags set to 'f'.
*
*/
mainForm::mainForm( QWidget* parent, const char* name, WFlags fl )
: QMainWindow( parent, name, fl )
{
(void)statusBar();
if ( !name )
setName( "mainForm" );
setCentralWidget( new QWidget( this, "qt_central_widget" ) );
mainFormLayout = new QVBoxLayout( centralWidget(), 11, 6, "mainFormLayout");
mainTab = new QTabWidget( centralWidget(), "mainTab" );
structure = new QWidget( mainTab, "structure" );
structureLayout = new QVBoxLayout( structure, 11, 6, "structureLayout");
dblistView = new QListView( structure, "dblistView" );
dblistView->addColumn( tr( "Name" ) );
dblistView->header()->setClickEnabled( FALSE, dblistView->header()->count() - 1 );
dblistView->addColumn( tr( "Object" ) );
dblistView->header()->setClickEnabled( FALSE, dblistView->header()->count() - 1 );
dblistView->addColumn( tr( "Type" ) );
dblistView->header()->setClickEnabled( FALSE, dblistView->header()->count() - 1 );
dblistView->addColumn( tr( "Schema" ) );
dblistView->header()->setClickEnabled( FALSE, dblistView->header()->count() - 1 );
dblistView->setResizePolicy( QScrollView::Manual );
dblistView->setSelectionMode( QListView::NoSelection );
dblistView->setRootIsDecorated( TRUE );
dblistView->setResizeMode( QListView::LastColumn );
structureLayout->addWidget( dblistView );
mainTab->insertTab( structure, QString("") );
browser = new QWidget( mainTab, "browser" );
browserLayout = new QVBoxLayout( browser, 11, 6, "browserLayout");
layout2 = new QHBoxLayout( 0, 0, 6, "layout2");
textLabel1 = new QLabel( browser, "textLabel1" );
layout2->addWidget( textLabel1 );
comboBrowseTable = new QComboBox( FALSE, browser, "comboBrowseTable" );
comboBrowseTable->setMinimumSize( QSize( 115, 0 ) );
layout2->addWidget( comboBrowseTable );
buttonFind = new QPushButton( browser, "buttonFind" );
buttonFind->setPixmap( QPixmap::fromMimeSource( "searchfind.png" ) );
buttonFind->setToggleButton( TRUE );
layout2->addWidget( buttonFind );
QSpacerItem* spacer = new QSpacerItem( 51, 20, QSizePolicy::Expanding, QSizePolicy::Minimum );
layout2->addItem( spacer );
buttonNewRecord = new QPushButton( browser, "buttonNewRecord" );
layout2->addWidget( buttonNewRecord );
buttonDeleteRecord = new QPushButton( browser, "buttonDeleteRecord" );
layout2->addWidget( buttonDeleteRecord );
browserLayout->addLayout( layout2 );
dataTable = new QTable( browser, "dataTable" );
dataTable->setAcceptDrops( TRUE );
dataTable->setResizePolicy( QTable::Default );
dataTable->setVScrollBarMode( QTable::Auto );
dataTable->setNumRows( 0 );
dataTable->setNumCols( 0 );
dataTable->setReadOnly( TRUE );
dataTable->setSelectionMode( QTable::Single );
dataTable->setFocusStyle( QTable::FollowStyle );
browserLayout->addWidget( dataTable );
layout9 = new QHBoxLayout( 0, 0, 6, "layout9");
buttonPrevious = new QPushButton( browser, "buttonPrevious" );
buttonPrevious->setSizePolicy( QSizePolicy( (QSizePolicy::SizeType)0, (QSizePolicy::SizeType)0, 0, 0, buttonPrevious->sizePolicy().hasHeightForWidth() ) );
layout9->addWidget( buttonPrevious );
labelRecordset = new QLabel( browser, "labelRecordset" );
layout9->addWidget( labelRecordset );
buttonNext = new QPushButton( browser, "buttonNext" );
buttonNext->setSizePolicy( QSizePolicy( (QSizePolicy::SizeType)0, (QSizePolicy::SizeType)0, 0, 0, buttonNext->sizePolicy().hasHeightForWidth() ) );
layout9->addWidget( buttonNext );
QSpacerItem* spacer_2 = new QSpacerItem( 50, 20, QSizePolicy::Expanding, QSizePolicy::Minimum );
layout9->addItem( spacer_2 );
buttonGoto = new QPushButton( browser, "buttonGoto" );
layout9->addWidget( buttonGoto );
editGoto = new QLineEdit( browser, "editGoto" );
editGoto->setSizePolicy( QSizePolicy( (QSizePolicy::SizeType)0, (QSizePolicy::SizeType)0, 0, 0, editGoto->sizePolicy().hasHeightForWidth() ) );
editGoto->setFrameShape( QLineEdit::LineEditPanel );
editGoto->setFrameShadow( QLineEdit::Sunken );
layout9->addWidget( editGoto );
browserLayout->addLayout( layout9 );
mainTab->insertTab( browser, QString("") );
query = new QWidget( mainTab, "query" );
queryLayout = new QVBoxLayout( query, 11, 6, "queryLayout");
textLabel1_2 = new QLabel( query, "textLabel1_2" );
queryLayout->addWidget( textLabel1_2 );
sqlTextEdit = new QTextEdit( query, "sqlTextEdit" );
sqlTextEdit->setSizePolicy( QSizePolicy( (QSizePolicy::SizeType)7, (QSizePolicy::SizeType)5, 0, 0, sqlTextEdit->sizePolicy().hasHeightForWidth() ) );
queryLayout->addWidget( sqlTextEdit );
layout5 = new QHBoxLayout( 0, 0, 6, "layout5");
executeQueryButton = new QPushButton( query, "executeQueryButton" );
layout5->addWidget( executeQueryButton );
QSpacerItem* spacer_3 = new QSpacerItem( 325, 20, QSizePolicy::Expanding, QSizePolicy::Minimum );
layout5->addItem( spacer_3 );
queryLayout->addLayout( layout5 );
textLabel2 = new QLabel( query, "textLabel2" );
queryLayout->addWidget( textLabel2 );
queryErrorLineEdit = new QLineEdit( query, "queryErrorLineEdit" );
queryErrorLineEdit->setReadOnly( TRUE );
queryLayout->addWidget( queryErrorLineEdit );
textLabel3 = new QLabel( query, "textLabel3" );
queryLayout->addWidget( textLabel3 );
queryResultListView = new QListView( query, "queryResultListView" );
queryResultListView->setResizePolicy( QListView::Default );
queryResultListView->setSelectionMode( QListView::NoSelection );
queryResultListView->setResizeMode( QListView::AllColumns );
queryLayout->addWidget( queryResultListView );
mainTab->insertTab( query, QString("") );
mainFormLayout->addWidget( mainTab );
// actions
fileNewAction = new QAction( this, "fileNewAction" );
fileNewAction->setIconSet( QIconSet( QPixmap::fromMimeSource( "new.png" ) ) );
fileOpenAction = new QAction( this, "fileOpenAction" );
fileOpenAction->setIconSet( QIconSet( QPixmap::fromMimeSource( "open.png" ) ) );
fileExitAction = new QAction( this, "fileExitAction" );
editCopyAction = new QAction( this, "editCopyAction" );
editPasteAction = new QAction( this, "editPasteAction" );
editFindAction = new QAction( this, "editFindAction" );
editFindAction->setIconSet( QIconSet( QPixmap::fromMimeSource( "searchfind.png" ) ) );
helpContentsAction = new QAction( this, "helpContentsAction" );
helpIndexAction = new QAction( this, "helpIndexAction" );
helpAboutAction = new QAction( this, "helpAboutAction" );
fileCloseAction = new QAction( this, "fileCloseAction" );
fileCloseAction->setEnabled( FALSE );
newRecordAction = new QAction( this, "newRecordAction" );
fileCompactAction = new QAction( this, "fileCompactAction" );
fileCompactAction->setEnabled( FALSE );
helpWhatsThisAction = new QAction( this, "helpWhatsThisAction" );
helpWhatsThisAction->setIconSet( QIconSet( QPixmap::fromMimeSource( "whatis.png" ) ) );
sqlLogAction = new QAction( this, "sqlLogAction" );
sqlLogAction->setToggleAction( TRUE );
sqlLogAction->setIconSet( QIconSet( QPixmap::fromMimeSource( "log.png" ) ) );
fileImportCSVAction = new QAction( this, "fileImportCSVAction" );
fileExportCSVAction = new QAction( this, "fileExportCSVAction" );
fileSaveAction = new QAction( this, "fileSaveAction" );
fileSaveAction->setEnabled( FALSE );
fileSaveAction->setIconSet( QIconSet( QPixmap::fromMimeSource( "save.png" ) ) );
fileRevertAction = new QAction( this, "fileRevertAction" );
fileRevertAction->setEnabled( FALSE );
fileRevertAction->setIconSet( QIconSet( QPixmap::fromMimeSource( "revert.png" ) ) );
fileImportAction = new QAction( this, "fileImportAction" );
fileExportAction = new QAction( this, "fileExportAction" );
editCreateTableAction = new QAction( this, "editCreateTableAction" );
editCreateTableAction->setEnabled( FALSE );
editCreateTableAction->setIconSet( QIconSet( QPixmap::fromMimeSource( "create_table.png" ) ) );
editDeleteTableAction = new QAction( this, "editDeleteTableAction" );
editDeleteTableAction->setEnabled( FALSE );
editDeleteTableAction->setIconSet( QIconSet( QPixmap::fromMimeSource( "delete_table.png" ) ) );
editModifyTableAction = new QAction( this, "editModifyTableAction" );
editModifyTableAction->setEnabled( FALSE );
editModifyTableAction->setIconSet( QIconSet( QPixmap::fromMimeSource( "modify_table.png" ) ) );
editCreateIndexAction = new QAction( this, "editCreateIndexAction" );
editCreateIndexAction->setEnabled( FALSE );
editCreateIndexAction->setIconSet( QIconSet( QPixmap::fromMimeSource( "create_index.png" ) ) );
editDeleteIndexAction = new QAction( this, "editDeleteIndexAction" );
editDeleteIndexAction->setEnabled( FALSE );
editDeleteIndexAction->setIconSet( QIconSet( QPixmap::fromMimeSource( "delete_index.png" ) ) );
fileImportSQLAction = new QAction( this, "fileImportSQLAction" );
fileExportSQLAction = new QAction( this, "fileExportSQLAction" );
// toolbars
Toolbar = new QToolBar( QString(""), this, DockTop );
fileNewAction->addTo( Toolbar );
fileOpenAction->addTo( Toolbar );
fileSaveAction->addTo( Toolbar );
fileRevertAction->addTo( Toolbar );
Toolbar->addSeparator();
editCreateTableAction->addTo( Toolbar );
editDeleteTableAction->addTo( Toolbar );
editModifyTableAction->addTo( Toolbar );
editCreateIndexAction->addTo( Toolbar );
editDeleteIndexAction->addTo( Toolbar );
Toolbar->addSeparator();
sqlLogAction->addTo( Toolbar );
Toolbar->addSeparator();
helpWhatsThisAction->addTo( Toolbar );
// menubar
menubar = new QMenuBar( this, "menubar" );
fileMenu = new QPopupMenu( this );
fileNewAction->addTo( fileMenu );
fileOpenAction->addTo( fileMenu );
fileCloseAction->addTo( fileMenu );
fileMenu->insertSeparator();
fileSaveAction->addTo( fileMenu );
fileRevertAction->addTo( fileMenu );
fileCompactAction->addTo( fileMenu );
fileMenu->insertSeparator();
QPopupMenu *PopupMenuEditor_9 = new QPopupMenu( this );
fileMenu->setAccel( tr( "" ),
fileMenu->insertItem( fileImportAction->iconSet(),tr( "Import" ), PopupMenuEditor_9 ) );
fileImportSQLAction->addTo( PopupMenuEditor_9 );
fileImportCSVAction->addTo( PopupMenuEditor_9 );
QPopupMenu *PopupMenuEditor_12 = new QPopupMenu( this );
fileMenu->setAccel( tr( "" ),
fileMenu->insertItem( fileExportAction->iconSet(),tr( "Export" ), PopupMenuEditor_12 ) );
fileExportSQLAction->addTo( PopupMenuEditor_12 );
fileExportCSVAction->addTo( PopupMenuEditor_12 );
fileMenu->insertSeparator();
fileExitAction->addTo( fileMenu );
menubar->insertItem( QString(""), fileMenu, 1 );
EditMenu = new QPopupMenu( this );
editCreateTableAction->addTo( EditMenu );
editDeleteTableAction->addTo( EditMenu );
editModifyTableAction->addTo( EditMenu );
EditMenu->insertSeparator();
editCreateIndexAction->addTo( EditMenu );
editDeleteIndexAction->addTo( EditMenu );
menubar->insertItem( QString(""), EditMenu, 2 );
ViewMenu = new QPopupMenu( this );
sqlLogAction->addTo( ViewMenu );
menubar->insertItem( QString(""), ViewMenu, 3 );
PopupMenu = new QPopupMenu( this );
helpWhatsThisAction->addTo( PopupMenu );
helpAboutAction->addTo( PopupMenu );
menubar->insertItem( QString(""), PopupMenu, 4 );
languageChange();
resize( QSize(702, 552).expandedTo(minimumSizeHint()) );
clearWState( WState_Polished );
// signals and slots connections
connect( fileExitAction, SIGNAL( activated() ), this, SLOT( fileExit() ) );
connect( fileOpenAction, SIGNAL( activated() ), this, SLOT( fileOpen() ) );
connect( fileNewAction, SIGNAL( activated() ), this, SLOT( fileNew() ) );
connect( fileCloseAction, SIGNAL( activated() ), this, SLOT( fileClose() ) );
connect( comboBrowseTable, SIGNAL( activated(const QString&) ), this, SLOT( populateTable(const QString&) ) );
connect( buttonNewRecord, SIGNAL( clicked() ), this, SLOT( addRecord() ) );
connect( buttonDeleteRecord, SIGNAL( clicked() ), this, SLOT( deleteRecord() ) );
connect( buttonPrevious, SIGNAL( clicked() ), this, SLOT( navigatePrevious() ) );
connect( buttonNext, SIGNAL( clicked() ), this, SLOT( navigateNext() ) );
connect( editGoto, SIGNAL( returnPressed() ), this, SLOT( navigateGoto() ) );
connect( buttonGoto, SIGNAL( clicked() ), this, SLOT( navigateGoto() ) );
connect( buttonFind, SIGNAL( toggled(bool) ), this, SLOT( browseFind(bool) ) );
connect( fileCompactAction, SIGNAL( activated() ), this, SLOT( compact() ) );
connect( editCopyAction, SIGNAL( activated() ), this, SLOT( copy() ) );
connect( editPasteAction, SIGNAL( activated() ), this, SLOT( paste() ) );
connect( helpWhatsThisAction, SIGNAL( activated() ), this, SLOT( helpWhatsThis() ) );
connect( helpAboutAction, SIGNAL( activated() ), this, SLOT( helpAbout() ) );
connect( dataTable, SIGNAL( doubleClicked(int,int,int,const QPoint&) ), this, SLOT( doubleClickTable(int,int,int,const QPoint&) ) );
connect( mainTab, SIGNAL( selected(const QString&) ), this, SLOT( mainTabSelected(const QString&) ) );
connect( sqlLogAction, SIGNAL( toggled(bool) ), this, SLOT( toggleLogWindow(bool) ) );
connect( executeQueryButton, SIGNAL( clicked() ), this, SLOT( executeQuery() ) );
connect( fileImportCSVAction, SIGNAL( activated() ), this, SLOT( importTableFromCSV() ) );
connect( fileExportCSVAction, SIGNAL( activated() ), this, SLOT( exportTableToCSV() ) );
connect( fileRevertAction, SIGNAL( activated() ), this, SLOT( fileRevert() ) );
connect( fileSaveAction, SIGNAL( activated() ), this, SLOT( fileSave() ) );
connect( editDeleteIndexAction, SIGNAL( activated() ), this, SLOT( deleteIndex() ) );
connect( editCreateIndexAction, SIGNAL( activated() ), this, SLOT( createIndex() ) );
connect( editCreateTableAction, SIGNAL( activated() ), this, SLOT( createTable() ) );
connect( editDeleteTableAction, SIGNAL( activated() ), this, SLOT( deleteTable() ) );
connect( editModifyTableAction, SIGNAL( activated() ), this, SLOT( editTable() ) );
connect( fileExportSQLAction, SIGNAL( activated() ), this, SLOT( exportDatabaseToSQL() ) );
connect( fileImportSQLAction, SIGNAL( activated() ), this, SLOT( importDatabaseFromSQL() ) );
init();
}
/** Constructor */
CreateBlogMsg::CreateBlogMsg(std::string cId ,QWidget* parent, Qt::WFlags flags)
: mBlogId(cId), QMainWindow (parent, flags)
{
/* Invoke the Qt Designer generated object setup routine */
ui.setupUi(this);
setAttribute ( Qt::WA_DeleteOnClose, true );
setupFileActions();
setupEditActions();
setupViewActions();
setupInsertActions();
setupParagraphActions();
setAcceptDrops(true);
setStartupText();
newBlogMsg();
ui.toolBar_2->addAction(ui.actionIncreasefontsize);
ui.toolBar_2->addAction(ui.actionDecreasefontsize);
ui.toolBar_2->addAction(ui.actionBlockquoute);
ui.toolBar_2->addAction(ui.actionOrderedlist);
ui.toolBar_2->addAction(ui.actionUnorderedlist);
ui.toolBar_2->addAction(ui.actionBlockquoute);
ui.toolBar_2->addAction(ui.actionCode);
ui.toolBar_2->addAction(ui.actionsplitPost);
setupTextActions();
connect(ui.actionPublish, SIGNAL(triggered()), this, SLOT(sendMsg()));
connect(ui.actionNew, SIGNAL(triggered()), this, SLOT (fileNew()));
connect(ui.actionIncreasefontsize, SIGNAL (triggered()), this, SLOT (fontSizeIncrease()));
connect(ui.actionDecreasefontsize, SIGNAL (triggered()), this, SLOT (fontSizeDecrease()));
connect(ui.actionBlockquoute, SIGNAL (triggered()), this, SLOT (blockQuote()));
connect(ui.actionCode, SIGNAL (triggered()), this, SLOT (toggleCode()));
connect(ui.actionsplitPost, SIGNAL (triggered()), this, SLOT (addPostSplitter()));
connect(ui.actionOrderedlist, SIGNAL (triggered()), this, SLOT (addOrderedList()));
connect(ui.actionUnorderedlist, SIGNAL (triggered()), this, SLOT (addUnorderedList()));
//connect(webView, SIGNAL(loadFinished(bool)),this, SLOT(updateTextEdit()));
connect( ui.msgEdit, SIGNAL( textChanged(const QString &)), this, SLOT(updateTextEdit()));
connect( ui.msgEdit, SIGNAL(currentCharFormatChanged(QTextCharFormat)),
this, SLOT(currentCharFormatChanged(QTextCharFormat)));
connect( ui.msgEdit, SIGNAL(cursorPositionChanged()),
this, SLOT(cursorPositionChanged()));
QPalette palette = QApplication::palette();
codeBackground = palette.color( QPalette::Active, QPalette::Midlight );
fontChanged(ui.msgEdit->font());
colorChanged(ui.msgEdit->textColor());
alignmentChanged(ui.msgEdit->alignment());
connect( ui.msgEdit->document(), SIGNAL(modificationChanged(bool)),
actionSave, SLOT(setEnabled(bool)));
connect( ui.msgEdit->document(), SIGNAL(modificationChanged(bool)),
this, SLOT(setWindowModified(bool)));
connect( ui.msgEdit->document(), SIGNAL(undoAvailable(bool)),
actionUndo, SLOT(setEnabled(bool)));
connect( ui.msgEdit->document(), SIGNAL(undoAvailable(bool)),
ui.actionUndo, SLOT(setEnabled(bool)));
connect( ui.msgEdit->document(), SIGNAL(redoAvailable(bool)),
actionRedo, SLOT(setEnabled(bool)));
setWindowModified( ui.msgEdit->document()->isModified());
actionSave->setEnabled( ui.msgEdit->document()->isModified());
actionUndo->setEnabled( ui.msgEdit->document()->isUndoAvailable());
ui.actionUndo->setEnabled( ui.msgEdit->document()->isUndoAvailable());
actionRedo->setEnabled( ui.msgEdit->document()->isRedoAvailable());
connect(actionUndo, SIGNAL(triggered()), ui.msgEdit, SLOT(undo()));
connect(ui.actionUndo, SIGNAL(triggered()), ui.msgEdit, SLOT(undo()));
connect(actionRedo, SIGNAL(triggered()), ui.msgEdit, SLOT(redo()));
actionCut->setEnabled(false);
actionCopy->setEnabled(false);
connect(actionCut, SIGNAL(triggered()), ui.msgEdit, SLOT(cut()));
connect(actionCopy, SIGNAL(triggered()), ui.msgEdit, SLOT(copy()));
connect(actionPaste, SIGNAL(triggered()), ui.msgEdit, SLOT(paste()));
connect(ui.msgEdit, SIGNAL(copyAvailable(bool)), actionCut, SLOT(setEnabled(bool)));
connect(ui.msgEdit, SIGNAL(copyAvailable(bool)), actionCopy, SLOT(setEnabled(bool)));
#ifndef QT_NO_CLIPBOARD
connect(QApplication::clipboard(), SIGNAL(dataChanged()), this, SLOT(clipboardDataChanged()));
#endif
//defaultCharFormat
defaultCharFormat = ui.msgEdit->currentCharFormat();
const QFont defaultFont = ui.msgEdit->document()->defaultFont();
defaultCharFormat.setFont( defaultFont );
defaultCharFormat.setForeground( ui.msgEdit->currentCharFormat().foreground() );
defaultCharFormat.setProperty( QTextFormat::FontSizeAdjustment, QVariant( 0 ) );
defaultCharFormat.setBackground( palette.color( QPalette::Active,
QPalette::Base ) );
defaultCharFormat.setProperty( TextFormat::HasCodeStyle, QVariant( false ) );
//defaultBlockFormat
defaultBlockFormat = ui.msgEdit->textCursor().blockFormat();
}