void BalanceWindow::on_settingsAction_triggered()
{
    SettingsDialog *d = new SettingsDialog(settings, this);
    connect(d,SIGNAL(testEmail()), this, SLOT(sendEmail()));
    d->setModal(true);
    d->show();
}
MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent), ui(new Ui::MainWindow)
{
    StringProvider::loadTemplate();

    ui->setupUi(this);

    initLayout();

    sqlLiteProvider = new SqlLiteProvider();
    connect(sqlLiteProvider, SIGNAL(updateEventLogUI(QList<EventLog>)),
            this, SLOT(sloUpdateEventLogUI(QList<EventLog>)));
    sqlLiteProvider->loadDatabase();

    httpProvider = new HttpProvider();
    connect(httpProvider, SIGNAL(sigHttpFinished(QNetworkReply*)),
            this, SLOT(sloHttpFinished(QNetworkReply*)));

    connect(ui->tableScan, SIGNAL(signalInsertLog(EventLog)),
            this, SLOT(slotInsertLog(EventLog)));

    // Load metascan online key
    QSettings qs(SETTINGS_DOMAIN, SETTINGS_USER);
    QString moKey = qs.value(SETTINGS_MO_KEY).toString();
    StringProvider::METASCAN_ONLINE_KEY = moKey;
    if(moKey.isEmpty()) {
        qDebug() << "moKey = NULLLLL";
        SettingsDialog* dialogSettings = new SettingsDialog(this);
        dialogSettings->setModal(true);
        dialogSettings->show();
    } else {
        qDebug() << "moKey = " << moKey;
    }
}
示例#3
0
文件: mainimpl.cpp 项目: fuCtor/rwin
MainDialogImpl::MainDialogImpl( QWidget * parent, Qt::WFlags f)
        : QDialog(parent, f)
{
	tray = new TrayMenu(this);
	connect(tray,SIGNAL(exitClicked(bool)),
		this,SLOT(exitClicked(bool)));


	QSettings settings;

	if(settings.value("first_launch",true).toBool())
	{
		SettingsDialog form;
		form.setModal(true);
		form.exec();

	}
	
	io = new RTorrentIO(0,
		settings.value("host","localhost").toString(),
		settings.value("port",80).toInt(),
		settings.value("path","/RPC2").toString());

	if(io)
	{
		connect(io,SIGNAL(started()),
			this,SLOT(init_client()));
		io->start();
	}else
		tray->disconnected();

}
示例#4
0
void MainWindow::send_settings(){
    // открыть диалоговое окно с настройками
    SettingsDialog *sd = new SettingsDialog();
    if(sd->exec() == QDialog::Accepted){
        delete sd;
        // если нажата кнопка ОК и хоть что-то изменено, пересоздаём соединение с базой
        if(base.databaseName() != settings->value("DATABASE/basename").toString() ||
           base.hostName() != settings->value("DATABASE/basehost").toString() ||
           base.userName() != settings->value("DATABASE/baseuser").toString() ||
           base.password() != settings->value("DATABASE/basepass").toString())
                reload_base();
        // если измененён шрифт, меняем его
        QFont new_font;
        new_font.setFamily(settings->value("FONTS/system_family").toString());
        new_font.setPointSize(settings->value("FONTS/system_size").toInt());
        if(new_font != qApp->font()){
            qApp->setFont(new_font);
            if(docs_list > 0) docs_list->resize();
            if(doc > 0) doc->resize();
            if(preview > 0) preview->resize();
        }
        settings->sync();
        return;
    }
    delete sd;
}
示例#5
0
// Menu Action: Options / Configure iCubGUI
void qavimator::configure()
{
    SettingsDialog dialog;
    connect(&dialog,SIGNAL(configChanged()),this,SLOT(configChanged()));

    dialog.exec();
}
示例#6
0
void MainWindow::showSettings()
{
    SettingsDialog dialog;
    dialog.setFilterModel(m_proxyModel);

    dialog.exec();
}
// Show dialog slots
void LauncherWindow::showSettingsDialog() {
    SettingsDialog* d = new SettingsDialog(this);
    d->exec();

    Settings* settings = Settings::instance();
    ui->clientCombo->setCurrentIndex(settings->loadActiveClientId());
}
示例#8
0
bool MainWindow::doGetSettings(bool first_time_user)
{
	SettingsDialog * dial = new SettingsDialog(wxT("Settings"));

	if (baud_rate) {
		dial->setValues(serial_port, baud_rate);

	}
	SettingDetails dets = dial->getDetails(first_time_user);



	if (dets.valid) {
		bool updateInit = false;

		if (baud_rate != dets.baud || serial_port != dets.portName) {
			updateInit = true;
		}

		serial_port = dets.portName;
		baud_rate = dets.baud;

		saveConfig();

		return updateInit;
	}


	return false;

}
示例#9
0
void MainWindow::on_actionSettings_triggered()
{
    SettingsDialog *dia = new SettingsDialog(m_hostName, m_port, m_font, m_Pallette, this);
    if(dia->exec()){
        loadSettingFromIni();
    }
}
示例#10
0
void MainWindow::openSettingsDialog()
{
    //create new SettingsDialog and open it
    SettingsDialog* playerSettings = new SettingsDialog(this);
    playerSettings->setModal(true);
    playerSettings->open();
}
示例#11
0
void MountTray::slotOpenSettings(){
  //Stop the refresh timer on the watcher
  diskWatcher->stop();
  //Open up the settings window and apply changes as necessary
  SettingsDialog *sdlg = new SettingsDialog();
  sdlg->useDiskWatcher = useDiskWatcher;
  sdlg->useDiskAutoTimer = useDiskTimerDevd;
  sdlg->diskRefreshMS = diskTimerMaxMS;
  sdlg->useAutoPlay = useAutoPlay;
  sdlg->showDialog();
  //Now parse the output and save if necessary
  if(sdlg->SettingsChanged){
    useDiskWatcher = sdlg->useDiskWatcher;
    useDiskTimerDevd = sdlg->useDiskAutoTimer;
    diskTimerMaxMS = sdlg->diskRefreshMS;
    useAutoPlay = sdlg->useAutoPlay;
    for(int i=0; i<DEVLIST.length(); i++){
      DEVLIST[i]->setAutoPlay(useAutoPlay);
    }
    qDebug() << "INFO: Saving updated settings to file";
    saveCurrentSettings(); //update the saved settings
  }
  //Now restart the disk watcher if enabled
  if(useDiskWatcher){ diskWatcher->start(diskTimerMaxMS); }
}
示例#12
0
void FirstWindow::on_settingsButton_clicked()
{
    SettingsDialog dialog;
    connect( &dialog, SIGNAL( signalSetSettings( Settings ) ),
             this, SLOT( slotSetSettings( Settings ) ) );
    dialog.exec();
}
示例#13
0
void ts3plugin_configure(void* handle, void* qParentWidget) {
	printf("PLUGIN: configure\n");
	SettingsDialog settings;
	settings.SetupUi();
	settings.exec();

}
void MainWindow::on_actionSettings_triggered()
{
    SettingsDialog dialog;
    dialog.setModal( true );
    connect( &dialog, SIGNAL( signalSetSettings( QString, QString) ),
             this, SLOT( slotSetSettings(QString, QString ) ) );
    dialog.exec();
}
示例#15
0
bool MainWindow::showOptionsDialog(Id page, QWidget *parent)
{
    emit m_coreImpl->optionsDialogRequested();
    if (!parent)
        parent = ICore::dialogParent();
    SettingsDialog *dialog = SettingsDialog::getSettingsDialog(parent, page);
    return dialog->execDialog();
}
示例#16
0
void MainWindow::showPreferences()
{
    SettingsDialog dialog;
    if(dialog.exec() == QDialog::Accepted) {
        scrollbackSize=Settings::getScrollbackSize();
        onValueChanged();
    }
}
示例#17
0
void MainWindow::onGeneralSettings()
{
    SettingsDialog *sDlg = new SettingsDialog(configHelper, this);
    connect(sDlg, &SettingsDialog::finished,
            sDlg, &SettingsDialog::deleteLater);
    if (sDlg->exec()) {
        configHelper->save(*model);
    }
}
示例#18
0
void MainWindow::openSettingsDialog()
{
    // Show preferences dialog
    SettingsDialog *settingsDlg = new SettingsDialog(this);
    connect(settingsDlg, &SettingsDialog::accepted,
            this, &MainWindow::settingsAccepted);
    connect(settingsDlg, &SettingsDialog::accepted,
            this, &MainWindow::settingsDialogAccepted);
    settingsDlg->exec();
}
/**
 * Show Settings dialog.
 */
void KAudioCreator::showSettings(){
    if(KConfigDialog::showDialog("settings"))
        return;

    SettingsDialog *dialog = new SettingsDialog(this, "settings", Prefs::self());
    connect(dialog, SIGNAL(settingsChanged()), ripper, SLOT(loadSettings()));
    connect(dialog, SIGNAL(settingsChanged()), encoder, SLOT(loadSettings()));
    connect(dialog, SIGNAL(settingsChanged()), tracks, SLOT(loadSettings()));
    connect(dialog->encoderConfigImp, SIGNAL(encoderUpdated()), encoder, SLOT(loadSettings()));
    dialog->show();
}
示例#20
0
void TagEditor::showSettings(){

    SettingsDialog s;
    if( s.exec()==QDialog::Accepted ){
        //obtain newly saved data from settingsdialog
        extensions = guiSettings->value("extensions","").toStringList();
        //api_key = guiSettings->value("api_key","").toString();
        subfolders = guiSettings->value("subfolders",true).toBool();
    }

}
示例#21
0
int main( int argc, char** argv )
{
    TDEApplication app(argc, argv, "KSpell2Test");

    SettingsDialog *dialog = new SettingsDialog( 0 );

    dialog->show();

    app.setMainWidget( dialog );

    return app.exec();
}
示例#22
0
void HaveClip::showSettings()
{
	SettingsDialog *dlg = new SettingsDialog(manager->connectionManager());

	if(dlg->exec() == QDialog::Accepted)
	{
		dlg->apply();

		Settings::get()->save();
	}

	dlg->deleteLater();
}
示例#23
0
void MainDialog::showOptions()
{
	LOG_5("MWIN: Showing settings dialog");
	SettingsDialog * settings = new SettingsDialog(this);
	// Exec for a modal dialog
	int result = settings->exec();
	
	if( result == QDialog::Accepted ){
		LOG_5("MWIN: Applying new settings");
		settings->applyChanges();	// Apply the changes to 'config'
		readConfig();				// Read the values from 'config'
	}
	delete settings;
}
示例#24
0
void MainWindow::on_actionSettings_triggered()
{
	if (state == STATE_RUNNING) mode_switch();
	SettingsDialog* dialog = new SettingsDialog(this);
	dialog->dropPreview = dropPreview;
	dialog->interval = interval;
	dialog->init_settings();
	dialog->setModal(true);
	dialog->exec();
	dropPreview = dialog->dropPreview;
	interval = dialog->interval;
	qDebug() << "dropPreview:" << dropPreview;
	qDebug() << "interval:" << interval;
	refreshSettings(true);
}
示例#25
0
void MainWindow::showSettings() {
  SettingsDialog *s = new SettingsDialog(this);

  s->show();

  connect(s, &QDialog::accepted, [&, s, this]() {  // NOLINT
    Settings set;
    toggleAnimeRecognition(
        set.getValue(Settings::AnimeRecognitionEnabled, D_ANIME_RECOGNITION)
            .toBool());

    torrents_enabled =
        set.getValue(Settings::TorrentsEnabled, D_TORRENTS_ENABLED).toBool();

    reloadSmartTitles();
    reloadRules();
  });
}
示例#26
0
void MainWindowImpl::OnSettings(void)
{
	SettingsDialog settings;
	settings.Set(m_Settings);
	if( settings.exec() == QDialog::Accepted )
	{
		//update our settings from the dialog.
		settings.Get(m_Settings);
		
		//We may have changed the screensaver supression
		ScreensaverPoke( m_Settings.PokeScreensaver);
		
		//We may have changed visualization
		m_AudioInterface.SetVisualization(m_Settings.VisualizationName,
											Visualization->winId(),true,
											m_Settings.UseXvimagesink );
	}
}
BOOL SettingsDialog::dlgProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	switch(message)
	{
		case WM_INITDIALOG:
			::SetWindowLongPtr(hWnd, GWL_USERDATA, lParam);
			return reinterpret_cast<SettingsDialog*>(lParam)->run_dlgProc(hWnd, message, wParam, lParam);

		default:
		{
			SettingsDialog* dlg = reinterpret_cast<SettingsDialog*>(::GetWindowLongPtr(hWnd, GWL_USERDATA));
			if (dlg)
				return dlg->run_dlgProc(hWnd, message, wParam, lParam);
			else
				return FALSE;
		}
	}
	
}
void mepp_component_Canonical_plugin::ValenceDrivenSimplification()
{
	// active viewer
	if (mw->activeMdiChild() != 0)
	{
		Viewer* viewer = (Viewer *)mw->activeMdiChild();
		PolyhedronPtr polyhedron_ptr = viewer->getScenePtr()->get_polyhedron();

		Canonical_ComponentPtr component_ptr = findOrCreateComponentForViewer<Canonical_ComponentPtr, Canonical_Component>(viewer, polyhedron_ptr);

		polyhedron_ptr->normalize_border();
		if(polyhedron_ptr->size_of_border_edges() != 0)
		{
			/*(void)wxMessageBox(_T("Simplification not possible\n\n")
				_T("The mesh owns border edges")

				   );*/
			QMessageBox::information(mw, APPLICATION, tr("Simplification not possible: the mesh owns border edges."));
			return;
		}
		
		if(polyhedron_ptr->is_pure_triangle() == false)
		{
			/*(void)wxMessageBox(_T("Simplification not possible\n\n")
				_T("The mesh is not triangular")

				   );*/
			QMessageBox::information(mw, APPLICATION, tr("Simplification not possible: the mesh is not triangular."));
			return;
		}

		//MyDialog3 dial(m_frame);

		bool Normal_Flipping = false;
		bool Use_Metric = false;
		bool Use_forget_metric = false;

		unsigned int Number_Vertices = 0;
		int Forget_Value = 0;
		float Metric_threshold = 0.0;

		/*char NVerticesChar[256];
		char MValue[256];
		char FValue[256];*/

		SettingsDialog dial;
		if (dial.exec() == QDialog::Accepted)
		{
			QApplication::setOverrideCursor(Qt::WaitCursor);

			Normal_Flipping = dial.normal_flipping->isChecked();//dial.m_normal_flipping->GetValue();

			Use_Metric = dial.useMetric->isChecked();//dial.m_use_metric->GetValue();

			//strcpy(NVerticesChar,dial.m_number_vertices->GetValue().ToAscii());
			Number_Vertices = dial.number_vertices->value();//atoi(NVerticesChar);

			if (Use_Metric == true)
			{
				//strcpy(MValue,dial.m_metric_value->GetValue().ToAscii());
				Metric_threshold = dial.metric_value->value();//atof(MValue);

				Use_forget_metric = dial.forgetMetric->isChecked();//dial.m_forget_metric->GetValue();
				if (Use_forget_metric == true)
				{
					//strcpy(FValue,dial.m_forget_metric_value->GetValue().ToAscii());
					Forget_Value = dial.forget_metric_value->value();//atoi(FValue);
				}
			}
			int Number_Of_Vertices1 = polyhedron_ptr->size_of_vertices();
			int Number_Of_Vertices2 = polyhedron_ptr->size_of_vertices();

			while(polyhedron_ptr->size_of_vertices() > Number_Vertices)
			{
				Number_Of_Vertices1 = polyhedron_ptr->size_of_vertices();

				component_ptr->Decimation_Conquest(polyhedron_ptr,Normal_Flipping,Use_Metric,Metric_threshold,
					Use_forget_metric,Forget_Value);
				component_ptr->Regulation(polyhedron_ptr,Normal_Flipping,Use_Metric,Metric_threshold,
					Use_forget_metric,Forget_Value);

				Number_Of_Vertices2 = polyhedron_ptr->size_of_vertices();
				if (Number_Of_Vertices1 == Number_Of_Vertices2)
					break;
			}

			/*m_frame->update_mesh_properties();
			m_frame->Refresh();
			m_frame->set_status_message(_T("Simplification is done"));*/
			mw->statusBar()->showMessage(tr("Simplification is done"));

			viewer->recreateListsAndUpdateGL();

		}
	}

	QApplication::restoreOverrideCursor();
}
示例#29
0
void Application::showSettings()
{
	SettingsDialog *s = new SettingsDialog( activeWindow() );
	s->addAction( d->closeAction );
	s->show();
}
示例#30
0
void MainWindow::setupMenu()
{
    //Setup menu
    menuBar = new QMenuBar(centralWidget());
    this->setMenuBar(menuBar);

    QMenu* fileMenu = new QMenu(tr("File"), menuBar);

    QAction *exitAction = new QAction(tr("Exit"), this);
    connect(exitAction, &QAction::triggered, this, &MainWindow::close);

    fileMenu->addAction(exitAction);

    // Profiles

    QMenu* profilesMenu = new QMenu(tr("Profiles"));

    QAction *backToMainPage = new QAction(tr("Back to main page"), this);
    connect(backToMainPage, &QAction::triggered, []() {
        SDK::ProfileManager::instance()->backToMainPage();
    });

    profilesMenu->addAction(backToMainPage);
    profilesMenu->addSection(tr("Profiles"));

    connect(profilesMenu, &QMenu::triggered, [=](QAction* action) {
        SDK::Profile* profile = SDK::ProfileManager::instance()->findById(action->data().toString());
        if(profile != NULL)
            SDK::ProfileManager::instance()->setActiveProfile(profile);
        else
            WARN() << qPrintable(QString("Can't load profile %1 from profiles menu!").arg(action->data().toString()));
    });

    connect(SDK::ProfileManager::instance(), &SDK::ProfileManager::profileChanged, [=](SDK::Profile* profile){
        for(QAction* action: profilesMenu->actions())
        {
            if(action->data().toString() == profile->getId())
            {
                action->setChecked(true);
                profilesMenu->setActiveAction(action);
            }
            else
            {
                action->setChecked(false);
            }
        }
    });

    for(const SDK::Profile* profile: SDK::ProfileManager::instance()->getProfiles())
    {
        if(!profile->hasFlag(SDK::Profile::HIDDEN))
        {
            QAction* loadProfile = new QAction(profile->getName(), profilesMenu);
            loadProfile->setData(profile->getId());
            loadProfile->setCheckable(true);
            loadProfile->setChecked(false);
            profilesMenu->addAction(loadProfile);
        }
    }

    // Video menu
    QMenu* videoMenu = new QMenu(tr("Video"), menuBar);

    QMenu* aspectRatioMenu = new QMenu(tr("Aspect ratio"), videoMenu);

    connect(aspectRatioMenu, &QMenu::triggered, [=](QAction* action){
        if(player())
            player()->setAspectRatio((SDK::AspectRatio) action->data().toInt());
        aspectRatioMenu->setActiveAction(action);
        for(QAction* a: aspectRatioMenu->actions())
        {
            a->setChecked(a == action && player());
        }

    });

    connect(aspectRatioMenu, &QMenu::aboutToShow, [=]{
        if(!player())
            return;

        SDK::AspectRatio current_ratio = player()->getAspectRatio();
        for(QAction* action: aspectRatioMenu->actions())
        {
            SDK::AspectRatio ratio = (SDK::AspectRatio) action->data().toInt();
            if(ratio == current_ratio)
            {
                action->setChecked(true);
            }
            else
            {
                action->setChecked(false);
            }
        }
    });

    QList<QPair<QString, SDK::AspectRatio>> ratios;
    ratios.append(QPair<QString, SDK::AspectRatio>(tr("Auto"),     SDK::ASPECT_RATIO_AUTO));
    ratios.append(QPair<QString, SDK::AspectRatio>(tr("1:1"),      SDK::ASPECT_RATIO_1_1));
    ratios.append(QPair<QString, SDK::AspectRatio>(tr("5:4"),      SDK::ASPECT_RATIO_5_4));
    ratios.append(QPair<QString, SDK::AspectRatio>(tr("4:3"),      SDK::ASPECT_RATIO_4_3));
    ratios.append(QPair<QString, SDK::AspectRatio>(tr("11:8"),     SDK::ASPECT_RATIO_11_8));
    ratios.append(QPair<QString, SDK::AspectRatio>(tr("14:10"),    SDK::ASPECT_RATIO_14_10));
    ratios.append(QPair<QString, SDK::AspectRatio>(tr("3:2"),      SDK::ASPECT_RATIO_3_2));
    ratios.append(QPair<QString, SDK::AspectRatio>(tr("14:9"),     SDK::ASPECT_RATIO_14_9));
    ratios.append(QPair<QString, SDK::AspectRatio>(tr("16:10"),    SDK::ASPECT_RATIO_16_10));
    ratios.append(QPair<QString, SDK::AspectRatio>(tr("16:9"),     SDK::ASPECT_RATIO_16_9));
    ratios.append(QPair<QString, SDK::AspectRatio>(tr("2.35:1"),   SDK::ASPECT_RATIO_2_35_1));

    for(QPair<QString, SDK::AspectRatio> pair: ratios)
    {
        QString name = pair.first;
        SDK::AspectRatio ratio = pair.second;
        QAction* action = new QAction(name, aspectRatioMenu);
        action->setData(ratio);
        action->setCheckable(true);
        action->setChecked(false);
        aspectRatioMenu->addAction(action);
    }

    videoMenu->addMenu(aspectRatioMenu);

    // Audio menu
    QMenu* audioMenu = new QMenu(tr("Audio"), menuBar);
    QMenu* audioTrackMenu = new QMenu(tr("Track"), audioMenu);

    connect(audioTrackMenu, &QMenu::triggered, [=](QAction* action){
        if(!player())
            return;

        player()->setAudioLanguage(action->data().toInt());
        audioTrackMenu->setActiveAction(action);
        for(QAction* a: audioTrackMenu->actions())
        {
            action->setChecked(a == action);
        }
    });

    connect(audioTrackMenu, &QMenu::aboutToShow, [=]{
        audioTrackMenu->clear();
        if(!player())
            return;

        int index = player()->getAudioPID();
        QList<AudioLangInfo> languages = player()->getAudioLanguages();
        for(const AudioLangInfo &lang: languages)
        {
            QAction* action = new QAction(lang.m_code3, audioTrackMenu);
            action->setData(lang.m_pid);
            action->setCheckable(true);
            action->setChecked(lang.m_pid == index);
            audioTrackMenu->addAction(action);
        }
    });

    audioMenu->addMenu(audioTrackMenu);

    // Settings

    QMenu* settingsMenu = new QMenu(tr("Settings"));
    QAction* settingsAction = new QAction(tr("Settings..."), settingsMenu);
    settingsAction->setMenuRole(QAction::PreferencesRole);
    connect(settingsAction, &QAction::triggered, [=]() {
        SettingsDialog* dialog = new SettingsDialog(this);
        dialog->setAttribute( Qt::WA_DeleteOnClose, true );
        dialog->show();
    });
    settingsMenu->addAction(settingsAction);

    QAction* showDevTools = new QAction(tr("Developer tools..."), settingsMenu);
    connect(showDevTools, &QAction::triggered, SDK::Browser::instance(), &SDK::Browser::showDeveloperTools);
    settingsMenu->addAction(showDevTools);

    QAction* toggleFullscreenAction = new QAction(tr("Fullscreen mode"), settingsMenu);
    toggleFullscreenAction->setCheckable(true);
    connect(this, &MainWindow::fullScreenModeToggled, [=](bool fullscreen){
        toggleFullscreenAction->setChecked(fullscreen);
    });
    connect(toggleFullscreenAction, &QAction::triggered, [=]() {
         setAppFullscreen(!isFullScreen());
    });
    settingsMenu->addAction(toggleFullscreenAction);

    //About

    QMenu* aboutMenu = new QMenu(tr("About"));

    QAction* aboutAppAction = new QAction(tr("About application..."), aboutMenu);
    aboutAppAction->setMenuRole(QAction::AboutRole);
    connect(aboutAppAction, &QAction::triggered, [=]() {
       AboutAppDialog dialog;
       dialog.exec();
       dialog.show();
    });


    QAction* aboutPluginsAction = new QAction(tr("About plugins..."), aboutMenu);
    aboutPluginsAction->setMenuRole(QAction::ApplicationSpecificRole);
    connect(aboutPluginsAction, &QAction::triggered, [=]() {
       PluginsDialog dialog;
       dialog.exec();
       dialog.show();
    });

    aboutMenu->addAction(aboutAppAction);
    aboutMenu->addAction(aboutPluginsAction);

    menuBar->addMenu(fileMenu);
    menuBar->addMenu(videoMenu);
    menuBar->addMenu(audioMenu);
    menuBar->addMenu(profilesMenu);
    menuBar->addMenu(settingsMenu);
    menuBar->addMenu(aboutMenu);

    m_menuItems.append(fileMenu);
    m_menuItems.append(videoMenu);
    m_menuItems.append(audioMenu);
    m_menuItems.append(profilesMenu);
    m_menuItems.append(settingsMenu);
}