Пример #1
0
void ProcessMonitor::initializeMenus() 
{
   QMenuBar* menubar(menuBar());
   QAction*  action;
   QMenu*    menu;

   menubar->clear();
   menu = menubar->addMenu(tr("File"));
      action = menu->addAction(tr("Reconnect Servers"));
      connect(action, SIGNAL(triggered()), this, SLOT(reconnectServers()));
      action->setShortcut(Qt::CTRL + Qt::Key_R);

      action = menu->addAction(tr("Remove All Processes"));
      connect(action, SIGNAL(triggered()), this, SLOT(clearProcessList()));
      action->setShortcut(Qt::CTRL + Qt::Key_Backspace);

      action = menu->addAction(tr("Close"));
      connect(action, SIGNAL(triggered()), this, SLOT(close()));
      action->setShortcut(QKeySequence::Close);
}
Пример #2
0
void MainWindow::createMenus()
{
   QAction* action;
   QString  name;
   QMenu*   menu;
   QMenu*   subMenu;

   // ----- File Menu -----
   menu = menuBar()->addMenu("File");

      name = "About";
      action = menu->addAction(name);
      connect(action, SIGNAL(triggered()), this, SLOT(showAbout()));

      name = "New Molecule";
      action = menu->addAction(name);
      connect(action, SIGNAL(triggered()), &m_viewerModel, SLOT(newMoleculeMenu()));
      action->setShortcut(QKeySequence::New);

      name = "New Viewer";
      action = menu->addAction(name);
      connect(action, SIGNAL(triggered()), this, SLOT(newViewer()));

      name = "Open";
      action = menu->addAction(name);
      connect(action, SIGNAL(triggered()), this, SLOT(openFile()));
      action->setShortcut(QKeySequence::Open);

      name = "Open Recent";
      m_recentFilesMenu = menu->addMenu(name);
      updateRecentFilesMenu();

      menu->addSeparator();

/*
      name = "Parse Test File";
      action = menu->addAction(name);
      connect(action, SIGNAL(triggered()), this, SLOT(parseFile()));

      menu->addSeparator();
*/

      name = "Close Viewer";
      action = menu->addAction(name);
      connect(action, SIGNAL(triggered()), this, SLOT(close()));
      action->setShortcut(QKeySequence::Close);

      name = "Save";
      action = menu->addAction(name);
      connect(action, SIGNAL(triggered()), &m_viewerModel, SLOT(saveAll()));
      action->setShortcut(QKeySequence::Save);

      name = "Save As";
      action = menu->addAction(name);
      connect(action, SIGNAL(triggered()), &m_viewerModel, SLOT(saveAs()));
      action->setShortcut(Qt::SHIFT + Qt::CTRL + Qt::Key_S);

      menu->addSeparator();

      name = "Save Picture";
      action = menu->addAction(name);
      connect(action, SIGNAL(triggered()), &m_viewer, SLOT(saveSnapshot()));
      action->setShortcut(Qt::CTRL + Qt::Key_P);

      name = "Record Animation";
      action = menu->addAction(name);
      action->setCheckable(true);
      action->setChecked(false);
      connect(action, SIGNAL(triggered()), this, SLOT(toggleRecordingActive()));
      action->setShortcut(Qt::SHIFT + Qt::CTRL + Qt::Key_P);
      m_recordAnimationAction = action;

      name = "Show Message Log";
      action = menu->addAction(name);
      connect(action, SIGNAL(triggered()), this, SLOT(showLogMessages()));
      action->setShortcut(Qt::CTRL + Qt::Key_L);

      name = "Quit";
      action = menu->addAction(name);
      connect(action, SIGNAL(triggered()), this, SLOT(quit()));
      action->setShortcut(Qt::CTRL + Qt::Key_Q);


   // ----- Edit Menu -----
   menu = menuBar()->addMenu("Edit");
  
      name = "Undo";
      action = menu->addAction(name);
      connect(action, SIGNAL(triggered()), &m_undoStack, SLOT(undo()));
      action->setShortcut(QKeySequence::Undo);
      connect(&m_undoStack, SIGNAL(canUndoChanged(bool)), action, SLOT(setEnabled(bool)));

      name = "Redo";
      action = menu->addAction(name);
      connect(action, SIGNAL(triggered()), &m_undoStack, SLOT(redo()));
      action->setShortcut(QKeySequence::Redo);
      connect(&m_undoStack, SIGNAL(canRedoChanged(bool)), action, SLOT(setEnabled(bool)));

      menu->addSeparator();

      name = "Cut";
      action = menu->addAction(name);
      connect(action, SIGNAL(triggered()), &m_viewerModel, SLOT(cutSelection()));
      action->setShortcut(Qt::CTRL + Qt::Key_X);

      name = "Copy";
      action = menu->addAction(name);
      connect(action, SIGNAL(triggered()), &m_viewerModel, SLOT(copySelectionToClipboard()));
      action->setShortcut(Qt::CTRL + Qt::Key_C);

      name = "Paste";
      action = menu->addAction(name);
      connect(action, SIGNAL(triggered()), &m_viewerModel, SLOT(pasteSelectionFromClipboard()));
      action->setShortcut(Qt::CTRL + Qt::Key_V);

      menu->addSeparator();

      name = "Select All";
      action = menu->addAction(name);
      connect(action, SIGNAL(triggered()), &m_viewerModel, SLOT(selectAll()));
      action->setShortcut(Qt::CTRL + Qt::Key_A);

      name = "Select None";
      action = menu->addAction(name);
      connect(action, SIGNAL(triggered()), &m_viewerModel, SIGNAL(clearSelection()));
      action->setShortcut(Qt::SHIFT + Qt::CTRL + Qt::Key_A);

      name = "Invert Selection";
      action = menu->addAction(name);
      connect(action, SIGNAL(triggered()), &m_viewerModel, SLOT(invertSelection()));
      action->setShortcut(Qt::CTRL + Qt::Key_I);

      menu->addSeparator();

      name = "Reindex Atoms";
      action = menu->addAction(name);
      connect(action, SIGNAL(triggered()), this, SLOT(reindexAtoms()));


      menu->addSeparator();

      name = "Preferences";
      action = menu->addAction(name);
      connect(action, SIGNAL(triggered()), this, SLOT(showPreferences()));


   // ----- Display Menu -----
   menu = menuBar()->addMenu("Display");

      name = "Full Screen";
      action = menu->addAction(name);
      action->setCheckable(true);
      action->setChecked(false);
      connect(action, SIGNAL(triggered()), this, SLOT(fullScreen()));
      action->setShortcut(Qt::CTRL + Qt::Key_0);
      m_fullScreenAction = action;

      name = "Reset View";
      action = menu->addAction(name);
      connect(action, SIGNAL(triggered()), &m_viewer, SLOT(resetView()));
      action->setShortcut(Qt::CTRL + Qt::Key_R);

      name = "Show Axes";
      action = menu->addAction(name);
      action->setCheckable(true);
      action->setChecked(false);
      connect(action, SIGNAL(triggered()), &m_viewerModel, SLOT(toggleAxes()));
      connect(&m_viewerModel, SIGNAL(axesOn(bool)), action, SLOT(setChecked(bool)));
      action->setShortcut(Qt::Key_A);


      menu->addSeparator();

      name = "Atom Labels";
      subMenu = menu->addMenu(name);

         name = "Element";
         action = subMenu->addAction(name);
         connect(action, SIGNAL(triggered()), this, SLOT(setLabel()));
         action->setData(Layer::Atom::Element);
         action->setShortcut(Qt::Key_E);
         action->setCheckable(true);
         m_labelActions << action;

         name = "Index";
         action = subMenu->addAction(name);
         connect(action, SIGNAL(triggered()), this, SLOT(setLabel()));
         action->setData(Layer::Atom::Index);
         action->setShortcut(Qt::Key_I);
         action->setCheckable(true);
         m_labelActions << action;
   
         name = "Mass";
         action = subMenu->addAction(name);
         connect(action, SIGNAL(triggered()), this, SLOT(setLabel()));
         action->setData(Layer::Atom::Mass);
         action->setShortcut(Qt::Key_M);
         action->setCheckable(true);
         m_labelActions << action;

/*
         name = "NMR Shifts";
         action = subMenu->addAction(name);
         connect(action, SIGNAL(triggered()), this, SLOT(setLabel()));
         action->setData(Layer::Atom::NmrShifts);
         action->setShortcut(Qt::Key_N);
         action->setCheckable(true);
         m_labelActions << action;
*/

         name = "Partial Charge";
         action = subMenu->addAction(name);
         connect(action, SIGNAL(triggered()), this, SLOT(setLabel()));
         action->setData(Layer::Atom::Charge);
         action->setShortcut(Qt::Key_Q);
         action->setCheckable(true);
         m_labelActions << action;

         name = "Spin Densities";
         action = subMenu->addAction(name);
         connect(action, SIGNAL(triggered()), this, SLOT(setLabel()));
         action->setData(Layer::Atom::Spin);
         action->setShortcut(Qt::Key_S);
         action->setCheckable(true);
         m_labelActions << action;

   menu->addSeparator();

   name = "Configure Appearance";
      action = menu->addAction(name);
      connect(action, SIGNAL(triggered()), this, SLOT(configureAppearance()));


      // These are not working correctly at the moment.
/*
      name = "Partial Charge Type";
      QActionGroup* partialChargeGroup = new QActionGroup(this);
      subMenu = menu->addMenu(name);

         QString pc("Gasteiger");
         action = subMenu->addAction(pc);
         action->setCheckable(true);
         action->setChecked(true);
         action->setData(pc);
         partialChargeGroup->addAction(action);
         connect(action, SIGNAL(triggered()), this, SLOT(setPartialChargeType()));

         pc = "Sanderson";
         action = subMenu->addAction(pc);
         action->setCheckable(true);
         action->setData(pc);
         partialChargeGroup->addAction(action);
         connect(action, SIGNAL(triggered()), this, SLOT(setPartialChargeType()));

         pc = "Mulliken";
         action = subMenu->addAction(pc);
         action->setCheckable(true);
         action->setData(pc);
         partialChargeGroup->addAction(action);
         connect(action, SIGNAL(triggered()), this, SLOT(setPartialChargeType()));
*/



   // ----- Build Menu -----
   menu = menuBar()->addMenu("Build");

      name = "Fill Valencies With Hydrogens";
      action = menu->addAction(name);
      connect(action, SIGNAL(triggered()), &m_viewerModel, SLOT(addHydrogens()));
      action->setShortcut(Qt::CTRL + Qt::Key_F);

      name = "Reperceive Bonds";
      action = menu->addAction(name);
      connect(action, SIGNAL(triggered()), &m_viewerModel, SLOT(reperceiveBonds()));

      menu->addSeparator();

      name = "Set Constraint";
      action = menu->addAction(name);
      connect(action, SIGNAL(triggered()), &m_viewerModel, SLOT(setConstraint()));
      action->setShortcut(Qt::CTRL + Qt::Key_K);

      name = "Minimize Structure";
      action = menu->addAction(name);
      connect(action, SIGNAL(triggered()), &m_viewerModel, SLOT(minimizeEnergy()));
      action->setShortcut(Qt::CTRL + Qt::Key_M);

      name = "Select Force Field";

      QActionGroup* forceFieldGroup = new QActionGroup(this);
      subMenu = menu->addMenu(name);

         QString ff("MMFF94");
         action = subMenu->addAction(ff);
         action->setCheckable(true);
         action->setData(ff);
         forceFieldGroup->addAction(action);
         connect(action, SIGNAL(triggered()), this, SLOT(setForceField()));
         if (Preferences::DefaultForceField() == ff) action->setChecked(true);

         ff = "MMFF94s";
         action = subMenu->addAction(ff);
         action->setCheckable(true);
         action->setData(ff);
         forceFieldGroup->addAction(action);
         connect(action, SIGNAL(triggered()), this, SLOT(setForceField()));
         if (Preferences::DefaultForceField() == ff) action->setChecked(true);

         ff = "UFF";
         action = subMenu->addAction(ff);
         action->setCheckable(true);
         action->setData(ff);
         forceFieldGroup->addAction(action);
         connect(action, SIGNAL(triggered()), this, SLOT(setForceField()));
         if (Preferences::DefaultForceField() == ff) action->setChecked(true);

         ff = "Ghemical";
         action = subMenu->addAction(ff);
         action->setCheckable(true);
         action->setData(ff);
         forceFieldGroup->addAction(action);
         connect(action, SIGNAL(triggered()), this, SLOT(setForceField()));
         if (Preferences::DefaultForceField() == ff) action->setChecked(true);

         ff = "Gaff";
         action = subMenu->addAction(ff);
         action->setCheckable(true);
         action->setData(ff);
         forceFieldGroup->addAction(action);
         connect(action, SIGNAL(triggered()), this, SLOT(setForceField()));
         if (Preferences::DefaultForceField() == ff) action->setChecked(true);

      menu->addSeparator();

      name = "Translate To Center";
      action = menu->addAction(name);
      connect(action, SIGNAL(triggered()), &m_viewerModel, SLOT(translateToCenter()));
      action->setShortcut(Qt::CTRL + Qt::Key_T );

      name = "Symmetrize Molecule";
      action = menu->addAction(name);
      connect(action, SIGNAL(triggered()), &m_viewerModel, SLOT(symmetrize()));
      action->setShortcut(Qt::CTRL + Qt::Key_Y );

      name = "Set Symmetry Tolerance";
      action = menu->addAction(name);
      connect(action, SIGNAL(triggered()), &m_viewerModel, SLOT(adjustSymmetryTolerance()));

      name = "Auto-detect Symmetry";
      action = menu->addAction(name);
      action->setCheckable(true);
      action->setChecked(false);
      connect(action, SIGNAL(triggered()), &m_viewerModel, SLOT(toggleAutoDetectSymmetry()));



   // ----- Calculation Menu -----
   menu = menuBar()->addMenu("Calculation");

      name = "Q-Chem Setup";
      action = menu->addAction(name);
      connect(action, SIGNAL(triggered()), this, SLOT(openQChemUI()));
      action->setShortcut(Qt::CTRL + Qt::Key_U );
      m_qchemSetupAction = action;

      name = "Job Monitor";
      action = menu->addAction(name);
      connect(action, SIGNAL(triggered()), this, SLOT(showProcessMonitor()));
      action->setShortcut(Qt::CTRL + Qt::Key_J );

      menu->addSeparator();

      name = "Edit Servers";
      action = menu->addAction(name);
      connect(action, SIGNAL(triggered()), this, SLOT(editServers()));

      name = "Remove All Processes";
      action = menu->addAction(name);
      connect(action, SIGNAL(triggered()), 
         &(ProcessMonitor::instance()), SLOT(clearProcessList()));

      name = "Reset Password Vault Key";
      action = menu->addAction(name);
      connect(action, SIGNAL(triggered()), this, SLOT(setVaultPassword()));



   // ----- Help Menu -----
   menu = menuBar()->addMenu("Help");

      name = "Show Help";
      action = menu->addAction(name);
      connect(action, SIGNAL(triggered()), this, SLOT(showHelp()));
}
Пример #3
0
void ProcessMonitor::on_clearListButton_clicked(bool)
{
   bool statusCheck(true);
   bool prompt(false);
   clearProcessList(statusCheck, prompt);
}
Пример #4
0
void OdroidFlashManager::updateProcessView()
{
    // maintain correct process view
    if(mAppSettings->flashMode()) // if write mode
    {
        if(mRunningProcesses.contains(READING_IMAGE) || mRunningProcesses.contains(READING_IMAGE_VERIFY))
        {
            mRunningProcesses.clear();
            emit clearProcessList();
        }
        if(mAppSettings->useCompression()) // should decompress before write
        {
            if(!mRunningProcesses.contains(DECOMPRESSING))
            {
                if(mRunningProcesses.isEmpty())
                {
                    emit appendProcess("DECOMPRESS");
                    mRunningProcesses.append(DECOMPRESSING);
                }
                else
                {
                    emit insertProcess(0,"DECOMPRESS");
                    mRunningProcesses.insert(0,DECOMPRESSING);
                }
            }
            if(mAppSettings->deleteAfterDecompress())
            {
                if(mRunningProcesses.contains(DELETE_IMAGE))
                {
                    int indexd(-1);
                    if((indexd = mRunningProcesses.indexOf(DELETE_IMAGE)) >=0)
                    {
                        emit removeProcessAt(indexd);
                        mRunningProcesses.removeAll(DELETE_IMAGE);
                    }
                }
                emit appendProcess("DELETE IMG");
                mRunningProcesses.append(DELETE_IMAGE);
            }
            else
            {
                int indexd(-1);
                if((indexd = mRunningProcesses.indexOf(DELETE_IMAGE)) >=0)
                {
                    emit removeProcessAt(indexd);
                    mRunningProcesses.removeAll(DELETE_IMAGE);
                }
            }

        }
        else
        {
            int index(mRunningProcesses.indexOf(DECOMPRESSING));
            if(index >=0)
            {
                emit removeProcessAt(index);
                mRunningProcesses.removeAll(DECOMPRESSING);
            }
            int indexd(mRunningProcesses.indexOf(DELETE_IMAGE));
            if(indexd >=0)
            {
                emit removeProcessAt(indexd);
                mRunningProcesses.removeAll(DELETE_IMAGE);
            }

        }
        if(mAppSettings->verifyFlash()) // verify write
        {
            int index(mRunningProcesses.indexOf(WRITING_IMAGE));
            if(index >= 0)
            {
                emit removeProcessAt(index);
                mRunningProcesses.removeAt(index);
            }
            if(!mRunningProcesses.contains(WRITING_IMAGE_VERIFY))
            {
                if(mAppSettings->useCompression())
                {
                    emit insertProcess(1,"WRITE IMG(V)");
                    mRunningProcesses.insert(1,WRITING_IMAGE_VERIFY);
                }
                else
                {
                    emit insertProcess(0,"WRITE IMG(V)");
                    mRunningProcesses.insert(0,WRITING_IMAGE_VERIFY);
                }
            }
        }
        else
        {
            int index(mRunningProcesses.indexOf(WRITING_IMAGE_VERIFY));
            if(index >= 0)
            {
                emit removeProcessAt(index);
                mRunningProcesses.removeAt(index);
            }
            if(!mRunningProcesses.contains(WRITING_IMAGE))
            {
                if(mAppSettings->useCompression())
                {
                    emit insertProcess(1,"WRITE IMG");
                    mRunningProcesses.insert(1,WRITING_IMAGE);
                }
                else
                {
                    emit insertProcess(0,"WRITE IMG");
                    mRunningProcesses.insert(0,WRITING_IMAGE);
                }
            }
        }
        if(mAppSettings->writeBootIni())
        {
            if(!mRunningProcesses.contains(WRITING_BOOT))
            {
                if(mRunningProcesses.contains(DELETE_IMAGE))
                {
                    int delete_index = mRunningProcesses.indexOf(DELETE_IMAGE);
                    emit insertProcess(delete_index-1,"WRITE BOOT");
                    mRunningProcesses.insert(delete_index-1,WRITING_BOOT);
                }
                else
                {
                    emit appendProcess("WRITE BOOT");
                    mRunningProcesses.append(WRITING_BOOT);
                }
            }
        }
        else
        {
            int indexw(-1);
            if((indexw = mRunningProcesses.indexOf(WRITING_BOOT)) >=0)
            {
                emit removeProcessAt(indexw);
                mRunningProcesses.removeAll(WRITING_BOOT);
            }
        }

    }
    else // read mode
    {
        if(mRunningProcesses.contains(WRITING_IMAGE) || mRunningProcesses.contains(WRITING_IMAGE_VERIFY))
        {
            mRunningProcesses.clear();
            emit clearProcessList();
        }
        if(mAppSettings->verifyFlash())
        {
            if(mRunningProcesses.isEmpty())
            {
                emit appendProcess("READ IMG(V)");
                mRunningProcesses.append(READING_IMAGE_VERIFY);
            }
            else
            {
                int read_index(-1);
                int readv_index(-1);
                if((read_index = mRunningProcesses.indexOf(READING_IMAGE)) >= 0 ||  (readv_index = mRunningProcesses.indexOf(READING_IMAGE_VERIFY)) >= 0)
                {
                    if(read_index >= 0)
                    {
                        emit removeProcessAt(read_index);
                        mRunningProcesses.removeAll(READING_IMAGE);
                    }
                    if(readv_index >= 0)
                    {
                        emit removeProcessAt(readv_index);
                        mRunningProcesses.removeAll(READING_IMAGE_VERIFY);
                    }
                }
                emit insertProcess(0,"READ IMG(V)");
                mRunningProcesses.insert(0,READING_IMAGE_VERIFY);
            }
        }
        else
        {
            if(mRunningProcesses.isEmpty())
            {
                emit appendProcess("READ IMG");
                mRunningProcesses.append(READING_IMAGE);
            }
            else
            {
                int read_index(-1);
                int readv_index(-1);
                if((read_index = mRunningProcesses.indexOf(READING_IMAGE)) >= 0 ||  (readv_index = mRunningProcesses.indexOf(READING_IMAGE_VERIFY)) >= 0)
                {
                    if(readv_index >= 0)
                    {
                        emit removeProcessAt(readv_index);
                        mRunningProcesses.removeAll(READING_IMAGE_VERIFY);
                    }
                    if(read_index >= 0)
                    {
                        emit removeProcessAt(read_index);
                        mRunningProcesses.removeAll(READING_IMAGE);
                    }
                }
                emit insertProcess(0,"READ IMG");
                mRunningProcesses.insert(0,READING_IMAGE);
            }
        }
        if(mAppSettings->useCompression())
        {
            int index(-1);
            if((index = mRunningProcesses.indexOf(COMPRESSING)) >= 0)
            {
                emit removeProcessAt(index);
                mRunningProcesses.removeAll(COMPRESSING);
            }

            emit appendProcess("COMPRESS");
            mRunningProcesses.append(COMPRESSING);
            if(mAppSettings->deleteAfterCompress())
            {
                int index(-1);
                if((index = mRunningProcesses.indexOf(DELETE_IMAGE) ) >=0)
                {
                    emit removeProcessAt(index);
                    mRunningProcesses.removeAll(DELETE_IMAGE);
                }
                emit appendProcess("DELETE IMG");
                mRunningProcesses.append(DELETE_IMAGE);
            }
            else
            {
                int indexd(-1);
                if((indexd = mRunningProcesses.indexOf(DELETE_IMAGE)) >=0)
                {
                    emit removeProcessAt(indexd);
                    mRunningProcesses.removeAll(DELETE_IMAGE);
                }
            }

        }
        else
        {
            int cindex(-1);
            if((cindex = mRunningProcesses.indexOf(COMPRESSING)) >= 0)
            {
                    emit removeProcessAt(cindex);
                    mRunningProcesses.removeAll(COMPRESSING);
            }
            int indexd(-1);
            if((indexd = mRunningProcesses.indexOf(DELETE_IMAGE)) >=0)
            {
                emit removeProcessAt(indexd);
                mRunningProcesses.removeAll(DELETE_IMAGE);
            }

        }
        if(mAppSettings->writeBootIni())
        {
            if(mAppSettings->preserveBootIni())
            {
                if(mRunningProcesses.isEmpty())
                {
                    if(mAppSettings->preserveBootIni())
                    {
                        mRunningProcesses.append(READING_BOOT);
                        emit appendProcess("READ BOOT");
                    }
                    emit appendProcess("WRITE BOOT");
                    mRunningProcesses.append(WRITING_BOOT);
                }
                else
                {
                    emit insertProcess(0,"READ BOOT");
                    mRunningProcesses.insert(0,READING_BOOT);
                    emit insertProcess(1,"WRITE BOOT");
                    mRunningProcesses.insert(1,WRITING_BOOT);
                }
                emit appendProcess("RESTORE BOOT");
                mRunningProcesses.append(RESTORING_BOOT);
            }
            else
            {
                int restore(-1);
                int read(-1);
                int write(-1);
                if((restore = mRunningProcesses.indexOf(RESTORING_BOOT)))
                mRunningProcesses.removeAll(READING_BOOT);
                mRunningProcesses.removeAll(WRITING_BOOT);
                emit appendProcess("WRITE BOOT");
                mRunningProcesses.append(WRITING_BOOT);
            }

        }
        else
        {
            // fill in removal
        }

    }
}