Add module select widget, add it to launch config dialog

src/CMakeLists.txt

@@ -78,6 +78,7 @@ set(GUI_SRCS
 	structedit.cpp
 	moduletreemodel.cpp
 	moduleselectiondialog.cpp
+	moduleselectwidget.cpp
 )
 
 set(GUI_RESOURCES
@@ -103,6 +104,7 @@ set(GUI_HEADERS
 	structedit.hpp
 	moduletreemodel.hpp
 	moduleselectiondialog.hpp
+	moduleselectwidget.hpp
 )
 
 add_executable(chigraphgui ${GUI_SRCS} ${GUI_HEADERS} ${GUI_RESOURCES})

src/chigraphguiui.rc

@@ -6,11 +6,11 @@
          <Action name="open" />
          <Action name="open-recent" />
          <Action name="save" />
-         <Action name="configure-launches" />
       </Menu>
       <Menu name="process">
          <text>Process</text>
           <Action name="run" />
+          <Action name="configure-launches" />
           <Action name="cancel" />
       </Menu>
       <Merge />

src/launchconfigurationdialog.cpp

@@ -1,4 +1,5 @@
 #include "launchconfigurationdialog.hpp"
+#include "moduleselectwidget.hpp"
 
 #include <KLocalizedString>
 
@@ -52,8 +53,8 @@ LaunchConfigurationDialog::LaunchConfigurationDialog(LaunchConfigurationManager&
 
 		// module
 		{
-			mModuleEdit = new QLineEdit;
-			connect(mModuleEdit, &QLineEdit::textChanged, this,
+			mModuleEdit = new ModuleSelectWidget(manager.context());
+			connect(mModuleEdit, &ModuleSelectWidget::moduleChanged, this,
 			        &LaunchConfigurationDialog::moduleChanged);
 			layout->addRow(i18n("Module"), mModuleEdit);
 		}
@@ -123,8 +124,8 @@ void LaunchConfigurationDialog::argsChanged(const QString& newArgs) {
 	if (currentlyEditing.valid()) { currentlyEditing.setArguments(newArgs); }
 }
 
-void LaunchConfigurationDialog::moduleChanged(const QString& newModule) {
-	if (currentlyEditing.valid()) { currentlyEditing.setModule(newModule); }
+void LaunchConfigurationDialog::moduleChanged(const boost::filesystem::path& newModule) {
+	if (currentlyEditing.valid()) { currentlyEditing.setModule(QString::fromStdString(newModule.string())); }
 }
 
 void LaunchConfigurationDialog::nameChanged(const QString& newName) {

src/launchconfigurationdialog.hpp

@@ -7,9 +7,13 @@
 
 #include "launchconfigurationmanager.hpp"
 
+#include <boost/filesystem/path.hpp>
+
 class QListWidget;
 class QLineEdit;
 
+class ModuleSelectWidget;
+
 class LaunchConfigurationDialog : public QDialog {
 	Q_OBJECT
 public:
@@ -21,7 +25,7 @@ private slots:
 
 	void nameChanged(const QString& newName);
 	void wdChanged(const QString& newWd);
-	void moduleChanged(const QString& newModule);
+	void moduleChanged(const boost::filesystem::path& newModule);
 	void argsChanged(const QString& newArgs);
 
 private:
@@ -30,7 +34,7 @@ private slots:
 
 	QLineEdit* mNameEdit;
 	QLineEdit* mWdEdit;
-	QLineEdit* mModuleEdit;
+	ModuleSelectWidget* mModuleEdit;
 	QLineEdit* mArgsEdit;
 
 	QListWidget* mConfigList;

src/launchconfigurationmanager.cpp

@@ -1,5 +1,7 @@
 #include "launchconfigurationmanager.hpp"
 
+#include <chi/Context.hpp>
+
 #include <KConfigGroup>
 #include <KSharedConfig>
 
@@ -8,14 +10,16 @@
 
 LaunchConfiguration::LaunchConfiguration(KConfigGroup grp) : mConfigGroup{grp} {}
 
-LaunchConfigurationManager::LaunchConfigurationManager() {
-	KConfigGroup config(KSharedConfig::openConfig(), "launchconfigurations");
+LaunchConfigurationManager::LaunchConfigurationManager(chi::Context& context) : mContext{&context} {
+	KConfigGroup contextConfig(KSharedConfig::openConfig(), context.workspacePath().string().c_str());
+
+	mConfigGroup = contextConfig.group("launchconfigurations");
 
-	auto configurations = config.readEntry("configurations", QStringList());
-	auto currentName    = config.readEntry("current", QString());
+	auto configurations = mConfigGroup.readEntry("configurations", QStringList());
+	auto currentName    = mConfigGroup.readEntry("current", QString());
 
 	for (const auto& configName : configurations) {
-		mConfigurations.emplace_back(KConfigGroup{KSharedConfig::openConfig(), configName});
+		mConfigurations.emplace_back(mConfigGroup.group(configName));
 
 		if (configName == currentName) { mCurrent = mConfigurations[mConfigurations.size() - 1]; }
 	}
@@ -26,11 +30,10 @@ LaunchConfiguration LaunchConfigurationManager::newConfiguration() {
 	auto uuid = QUuid::createUuid();
 
 	// add it to the list
-	KConfigGroup configs(KSharedConfig::openConfig(), "launchconfigurations");
-	configs.writeEntry("configurations",
-	                   configs.readEntry("configurations", QStringList()) << uuid.toString());
+	mConfigGroup.writeEntry("configurations",
+	                   mConfigGroup.readEntry("configurations", QStringList()) << uuid.toString());
 
-	auto group = KConfigGroup{KSharedConfig::openConfig(), uuid.toString()};
+	auto group = mConfigGroup.group(uuid.toString());
 
 	mConfigurations.emplace_back(group);
 
@@ -40,6 +43,5 @@ LaunchConfiguration LaunchConfigurationManager::newConfiguration() {
 void LaunchConfigurationManager::setCurrentConfiguration(LaunchConfiguration config) {
 	mCurrent = config;
 
-	KConfigGroup kconfig(KSharedConfig::openConfig(), "launchconfigurations");
-	kconfig.writeEntry("current", config.id());
+	mConfigGroup.writeEntry("current", config.id());
 }

src/launchconfigurationmanager.hpp

@@ -7,6 +7,8 @@
 
 #include <KConfigGroup>
 
+#include <chi/Fwd.hpp>
+
 struct LaunchConfiguration {
 	// constructs an invalid configuration
 	LaunchConfiguration() {}
@@ -40,7 +42,7 @@ struct LaunchConfiguration {
 class LaunchConfigurationManager : public QObject {
 	Q_OBJECT
 public:
-	LaunchConfigurationManager();
+	LaunchConfigurationManager(chi::Context& context);
 
 	LaunchConfigurationManager(const LaunchConfigurationManager&) = delete;
 	LaunchConfigurationManager(LaunchConfigurationManager&&)      = delete;
@@ -61,10 +63,15 @@ class LaunchConfigurationManager : public QObject {
 		}
 		return {};
 	}
+
+	chi::Context& context() const { return *mContext; }
 
 private:
 	LaunchConfiguration              mCurrent;
 	std::vector<LaunchConfiguration> mConfigurations;
+	KConfigGroup mConfigGroup;
+
+	chi::Context* mContext;
 };
 
 #endif  // CHIGRAPHGUI_LAUNCH_CONFIGURATION_HPP

src/mainwindow.cpp

@@ -57,6 +57,7 @@ MainWindow::MainWindow(QWidget* parent) : KXmlGuiWindow(parent) {
 	setWindowIcon(QIcon(":/icons/chigraphsmall.png"));
 
 	mChigContext = std::make_unique<chi::Context>(qApp->arguments()[0].toStdString().c_str());
+	mLaunchManager = std::make_unique<LaunchConfigurationManager>(*mChigContext);
 
 	mFunctionTabs = new FunctionTabView;
 	mFunctionTabs->setMovable(true);
@@ -222,7 +223,7 @@ MainWindow::MainWindow(QWidget* parent) : KXmlGuiWindow(parent) {
 	runConfigDialogAction->setText(i18n("Configure Launches"));
 	actColl->addAction(QStringLiteral("configure-launches"), runConfigDialogAction);
 	connect(runConfigDialogAction, &QAction::triggered, this, [this] {
-		LaunchConfigurationDialog d(mLaunchManager);
+		LaunchConfigurationDialog d(launchManager());
 
 		d.exec();
 
@@ -235,11 +236,11 @@ MainWindow::MainWindow(QWidget* parent) : KXmlGuiWindow(parent) {
 	connect(mConfigSelectAction,
 	        static_cast<void (KSelectAction::*)(const QString&)>(&KSelectAction::triggered), this,
 	        [this](const QString& str) {
-		        mLaunchManager.setCurrentConfiguration(mLaunchManager.configByName(str));
+		        launchManager().setCurrentConfiguration(launchManager().configByName(str));
 		    });
 	updateUsableConfigs();
-	if (mLaunchManager.currentConfiguration().valid()) {
-		mConfigSelectAction->setCurrentAction(mLaunchManager.currentConfiguration().name(),
+	if (launchManager().currentConfiguration().valid()) {
+		mConfigSelectAction->setCurrentAction(launchManager().currentConfiguration().name(),
 		                                      Qt::CaseSensitive);
 	}
 
@@ -291,25 +292,31 @@ void MainWindow::openWorkspaceDialog() {
 
 void MainWindow::openWorkspace(const QUrl& url) {
 	mChigContext = std::make_unique<chi::Context>(url.toLocalFile().toStdString());
+	mLaunchManager = std::make_unique<LaunchConfigurationManager>(*mChigContext);
+	updateUsableConfigs();
 
 	workspaceOpened(*mChigContext);
 }
 
 void MainWindow::moduleDirtied(chi::GraphModule& mod) { mModuleBrowser->moduleDirtied(mod); }
 
 void MainWindow::updateUsableConfigs() {
-	// save the current so we can set it back later
-	QString selectedText = mConfigSelectAction->currentText();
 
 	// repopulate
 	mConfigSelectAction->clear();
 
-	for (const auto& config : mLaunchManager.configurations()) {
+	for (const auto& config : launchManager().configurations()) {
 		mConfigSelectAction->addAction(config.name());
 	}
 
-	// set it back
-	mConfigSelectAction->setCurrentAction(selectedText, Qt::CaseSensitive);
+	auto currentConfig = launchManager().currentConfiguration();
+
+	if (currentConfig.valid()) {
+
+		// set it to the current config
+		mConfigSelectAction->setCurrentAction(currentConfig.name(), Qt::CaseSensitive);
+
+	}
 }
 
 void MainWindow::closeEvent(QCloseEvent* event) {

src/mainwindow.hpp

@@ -36,7 +36,7 @@ class MainWindow : public KXmlGuiWindow {
 	chi::Context&    context() const { return *mChigContext; }
 	FunctionTabView& tabView() const { return *mFunctionTabs; }
 
-	LaunchConfigurationManager& launchManager() { return mLaunchManager; }
+	LaunchConfigurationManager& launchManager() { return *mLaunchManager; }
 
 	std::pair<chi::Result, chi::GraphModule*> loadModule(const QString& name);
 
@@ -65,7 +65,7 @@ public slots:
 
 	void updateUsableConfigs();
 
-	LaunchConfigurationManager mLaunchManager;
+	std::unique_ptr<LaunchConfigurationManager> mLaunchManager;
 
 	KRecentFilesAction* mOpenRecentAction;  // keep this so we can save the entries
 

src/moduleselectwidget.cpp

@@ -0,0 +1,28 @@
+#include "moduleselectwidget.hpp"
+
+#include "moduleselectiondialog.hpp"
+
+ModuleSelectWidget::ModuleSelectWidget(chi::Context& ctx)
+{
+	connect(this, &QPushButton::clicked, this, [this, &ctx](bool) {
+
+		auto modName = ModuleSelectionDialog::getModule(this, ctx);
+
+		if (modName.empty()) {
+			return;
+		}
+
+		setModule(modName);
+
+	});
+
+	setIcon(QIcon::fromTheme(QStringLiteral("package-available")));
+}
+
+void ModuleSelectWidget::setModule(const boost::filesystem::path& newModule)
+{
+	setText(QString::fromStdString(newModule.string()));
+
+	emit moduleChanged(newModule);
+}
+

src/moduleselectwidget.hpp

@@ -0,0 +1,24 @@
+#pragma once
+
+#ifndef CHIGRAPHGUI_MODULE_SELECT_WIDGET_HPP
+#define CHIGRAPHGUI_MODULE_SELECT_WIDGET_HPP
+
+#include <QPushButton>
+
+#include <chi/Fwd.hpp>
+
+#include <boost/filesystem/path.hpp>
+
+class ModuleSelectWidget : public QPushButton {
+	Q_OBJECT
+public:
+
+	ModuleSelectWidget(chi::Context& ctx);
+
+	void setModule(const boost::filesystem::path& newModule);
+
+signals:
+	void moduleChanged(const boost::filesystem::path& moduleName);
+};
+
+#endif // CHIGRAPHGUI_MODULE_SELECT_WIDGET_HPP

src/moduletreemodel.cpp

@@ -230,6 +230,8 @@ QVariant ModuleTreeModel::data(const QModelIndex& index, int role) const {
             return QIcon::fromTheme(QStringLiteral("code-context"));
         case WorkspaceTree::STRUCT:
             return QIcon::fromTheme(QStringLiteral("code-class"));
+		case WorkspaceTree::FOLDER:
+			return QIcon::fromTheme(QStringLiteral("stock_folder"));
         default:
             return {};
         }