No OneTemporary
Actions

Size

53 KB

Subscribers

None

View Options

	diff --git a/README.md b/README.md
	index 70f5cd9..1594f59 100644
	--- a/README.md
	+++ b/README.md
	@@ -1,80 +1,81 @@
	QtPass
	======

	QtPass is a GUI for [pass](http://www.passwordstore.org/)

	Features
	--------
	* Using pass or git and gpg2 directly
	* Configurable shoulder surfing protection options
	* Cross platform: Linux, BSD, OS X and Windows
	* Per-folder user selection for multi recipient encryption
	+* Multiple password store profiles

	While QtPass will work with Qt4, currently multi-line editing is restricted to Qt5 only.

	Security considerations
	-----------------------
	Using this program will not magically keep your passwords secure against
	compromised computers even if you use it in combination with a smartcard.

	It does protect future and changed passwords though against anyone with access to
	your password store only but not your keys.
	Used with a smartcard it also protects against anyone just monitoring/copying
	all files/keystrokes on that machine and such an attacker would only gain access
	to the passwords you actually use.
	Once you plug in your smartcard and enter your PIN (or due to CVE-2015-3298
	even without your PIN) all your passwords available to the machine can be
	decrypted by it, if there is malicious software targeted specifically against
	it installed (or at least one that knows how to use a smartcard).

	To get better protection out of use with a smartcard even against a targeted
	attack I can think of at least two options:
	* The smartcard must require explicit confirmation for each decryption operation.
	Or if it just provides a counter for decrypted data you could at least notice
	an attack afterwards, though at quite some effort on your part.
	* Use a different smartcard for each (group of) key.
	* If using a YubiKey or U2F module or similar that requires a "button" press for
	other authentication methods you can use one OTP/U2F enabled WebDAV account per
	password (or groups of passwords) as a quite inconvenient workaround.
	Unfortunately I do not know of any WebDAV service with OTP support except ownCloud
	(so you would have to run your own server).

	Known issues
	------------
	* Filtering (searching) breaks the tree/model sometimes
	* Starting without a correctly set password-store folder give weird results in the tree view
	* On Mac OS X only the gpgtools MacGPG2 version works with passphrase or PIN

	Planned features
	----------------
	* Showing path in Add and Edit screen (currently sometimes confusing where I'm adding this password)
	* Right click handlers for file/folder and content
	* First use wizards to set up password-store (and decryption key, currently always the gpg default key)
	-* Profiles (to allow use of multiple password stores and decryption keys) with dropdown in main screen
	+* ~~Profiles (to allow use of multiple password stores and decryption keys) with dropdown in main screen~~
	* Password generation with options for what kind you'd like
	* Templates (username, url etc) in Add / Edit screen (configurable templates)
	* Colour coding or disabling of people you can't encrypt for (trust settings) in User management
	* Colour coding folders (possibly disabling folders you can't decrypt)
	* Trayicon support
	* WebDAV (configuration) support
	* Optional table view of decrypted folder contents
	* Opening of (basic auth) urls in default browser? Possibly with helper plugin for filling out forms?
	* Some other form of remote storage that allows for accountability / auditing (web API to retreive the .gpg files?)

	Installation
	------------
	On most systems all you need is:
	`qmake && make && make install`

	On MacOsX:
	`qmake && make && macdeployqt QtPass.app -dmg`
	* Currently seems to only work with MacGPG2

	On some systems there are issues with qt4 and qt5 being installed at the same time.
	An easy fix is regenerating the Makefile with: `make clean && rm Makefile && qmake -qt5` or if qmake is ambiguous: `qmake-qt5`

	Further reading
	---------------
	[Documentation](http://qtpass.org/)

	[Source code](https://github.com/IJHack/qtpass)
	diff --git a/dialog.cpp b/dialog.cpp
	index c10a4d8..93685f0 100644
	--- a/dialog.cpp
	+++ b/dialog.cpp
	@@ -1,376 +1,379 @@
	#include "dialog.h"
	#include "ui_dialog.h"

	/**
	* @brief Dialog::Dialog
	* @param parent
	*/
	Dialog::Dialog(QWidget *parent) :
	QDialog(parent),
	ui(new Ui::Dialog)
	{
	ui->setupUi(this);
	}

	/**
	* @brief Dialog::~Dialog
	*/
	Dialog::~Dialog()
	{
	}

	/**
	* @brief Dialog::setPassPath
	* @param path
	*/
	void Dialog::setPassPath(QString path) {
	ui->passPath->setText(path);
	}

	/**
	* @brief Dialog::setGitPath
	* @param path
	*/
	void Dialog::setGitPath(QString path) {
	ui->gitPath->setText(path);
	}

	/**
	* @brief Dialog::setGpgPath
	* @param path
	*/
	void Dialog::setGpgPath(QString path) {
	ui->gpgPath->setText(path);
	}

	/**
	* @brief Dialog::setStorePath
	* @param path
	*/
	void Dialog::setStorePath(QString path) {
	ui->storePath->setText(path);
	}

	/**
	* @brief Dialog::getPassPath
	* @return
	*/
	QString Dialog::getPassPath() {
	return ui->passPath->text();
	}

	/**
	* @brief Dialog::getGitPath
	* @return
	*/
	QString Dialog::getGitPath() {
	return ui->gitPath->text();
	}

	/**
	* @brief Dialog::getGpgPath
	* @return
	*/
	QString Dialog::getGpgPath() {
	return ui->gpgPath->text();
	}

	/**
	* @brief Dialog::getStorePath
	* @return
	*/
	QString Dialog::getStorePath() {
	return ui->storePath->text();
	}

	/**
	* @brief Dialog::usePass
	* @return
	*/
	bool Dialog::usePass() {
	return ui->radioButtonPass->isChecked();
	}

	/**
	* @brief Dialog::usePass
	* @param pass
	*/
	void Dialog::usePass(bool usePass) {
	if (usePass) {
	ui->radioButtonNative->setChecked(false);
	ui->radioButtonPass->setChecked(true);
	} else {
	ui->radioButtonNative->setChecked(true);
	ui->radioButtonPass->setChecked(false);
	}
	setGroupBoxState();
	}

	/**
	* @brief Dialog::on_radioButtonNative_clicked
	*/
	void Dialog::on_radioButtonNative_clicked()
	{
	setGroupBoxState();
	}

	/**
	* @brief Dialog::on_radioButtonPass_clicked
	*/
	void Dialog::on_radioButtonPass_clicked()
	{
	setGroupBoxState();
	}

	/**
	* @brief Dialog::setGroupBoxState
	*/
	void Dialog::setGroupBoxState() {
	if (ui->radioButtonPass->isChecked()) {
	ui->groupBoxNative->setEnabled(false);
	ui->groupBoxPass->setEnabled(true);
	} else {
	ui->groupBoxNative->setEnabled(true);
	ui->groupBoxPass->setEnabled(false);
	}
	}

	/**
	* @brief Dialog::selectExecutable
	* @return
	*/
	QString Dialog::selectExecutable() {
	QFileDialog dialog(this);
	dialog.setFileMode(QFileDialog::ExistingFile);
	dialog.setOption(QFileDialog::ReadOnly);
	if (dialog.exec()) {
	return dialog.selectedFiles().first();
	}
	else return "";
	}

	/**
	* @brief Dialog::selectFolder
	* @return
	*/
	QString Dialog::selectFolder() {
	QFileDialog dialog(this);
	dialog.setFileMode(QFileDialog::Directory);
	dialog.setOption(QFileDialog::ShowDirsOnly);
	if (dialog.exec()) {
	return dialog.selectedFiles().first();
	}
	else return "";
	}

	/**
	* @brief Dialog::on_toolButtonGit_clicked
	*/
	void Dialog::on_toolButtonGit_clicked()
	{
	QString git = selectExecutable();
	if (git != "") {
	ui->gitPath->setText(git);
	}
	}

	/**
	* @brief Dialog::on_toolButtonGpg_clicked
	*/
	void Dialog::on_toolButtonGpg_clicked()
	{
	QString gpg = selectExecutable();
	if (gpg != "") {
	ui->gpgPath->setText(gpg);
	}
	}

	/**
	* @brief Dialog::on_toolButtonPass_clicked
	*/
	void Dialog::on_toolButtonPass_clicked()
	{
	QString pass = selectExecutable();
	if (pass != "") {
	ui->passPath->setText(pass);
	}
	}

	/**
	* @brief Dialog::on_toolButtonStore_clicked
	*/
	void Dialog::on_toolButtonStore_clicked()
	{
	QString store = selectFolder();
	if (store != "") {
	ui->storePath->setText(store);
	}
	}

	/**
	* @brief Dialog::on_checkBoxClipboard_clicked
	*/
	void Dialog::on_checkBoxClipboard_clicked()
	{
	if (ui->checkBoxClipboard->isChecked()) {
	ui->checkBoxAutoclear->setEnabled(true);
	ui->checkBoxHidePassword->setEnabled(true);
	ui->checkBoxHideContent->setEnabled(true);
	if (ui->checkBoxAutoclear->isChecked()) {
	ui->spinBoxAutoclearSeconds->setEnabled(true);
	ui->labelSeconds->setEnabled(true);
	} else {
	ui->spinBoxAutoclearSeconds->setEnabled(false);
	ui->labelSeconds->setEnabled(false);
	}
	} else {
	ui->checkBoxAutoclear->setEnabled(false);
	ui->spinBoxAutoclearSeconds->setEnabled(false);
	ui->labelSeconds->setEnabled(false);
	ui->checkBoxHidePassword->setEnabled(false);
	ui->checkBoxHideContent->setEnabled(false);
	}
	}

	/**
	* @brief Dialog::useClipboard
	*/
	void Dialog::useClipboard(bool useClipboard)
	{
	ui->checkBoxClipboard->setChecked(useClipboard);
	on_checkBoxClipboard_clicked();
	}

	/**
	* @brief Dialog::useAutoclear
	* @param useAutoclear
	*/
	void Dialog::useAutoclear(bool useAutoclear)
	{
	ui->checkBoxAutoclear->setChecked(useAutoclear);
	on_checkBoxAutoclear_clicked();
	}

	/**
	* @brief Dialog::setAutoclear
	* @param seconds
	*/
	void Dialog::setAutoclear(int seconds)
	{
	ui->spinBoxAutoclearSeconds->setValue(seconds);
	}

	/**
	* @brief Dialog::useClipboard
	* @return
	*/
	bool Dialog::useClipboard()
	{
	return ui->checkBoxClipboard->isChecked();
	}

	/**
	* @brief Dialog::useAutoclear
	* @return
	*/
	bool Dialog::useAutoclear()
	{
	return ui->checkBoxAutoclear->isChecked();
	}

	/**
	* @brief Dialog::getAutoclear
	* @return
	*/
	int Dialog::getAutoclear()
	{
	return ui->spinBoxAutoclearSeconds->value();
	}

	/**
	* @brief Dialog::on_checkBoxAutoclear_clicked
	*/
	void Dialog::on_checkBoxAutoclear_clicked()
	{
	on_checkBoxClipboard_clicked();
	}

	/**
	* @brief Dialog::hidePassword
	* @return
	*/
	bool Dialog::hidePassword()
	{
	return ui->checkBoxHidePassword->isChecked();
	}

	/**
	* @brief Dialog::hideContent
	* @return
	*/
	bool Dialog::hideContent()
	{
	return ui->checkBoxHideContent->isChecked();
	}

	/**
	* @brief Dialog::hidePassword
	* @param hidePassword
	*/
	void Dialog::hidePassword(bool hidePassword)
	{
	ui->checkBoxHidePassword->setChecked(hidePassword);
	}

	/**
	* @brief Dialog::hideContent
	* @param hideContent
	*/
	void Dialog::hideContent(bool hideContent)
	{
	ui->checkBoxHideContent->setChecked(hideContent);
	}

	/**
	* @brief Dialog::addGPGId
	* @return
	*/
	bool Dialog::addGPGId()
	{
	return ui->checkBoxAddGPGId->isChecked();
	}

	/**
	* @brief Dialog::addGPGId
	* @param addGPGId
	*/
	void Dialog::addGPGId(bool addGPGId)
	{
	ui->checkBoxAddGPGId->setChecked(addGPGId);
	}

	/**
	* @brief Dialog::setProfiles
	* @param profiles
	*/
	-void Dialog::setProfiles(QHash<QString, QString> profiles)
	+void Dialog::setProfiles(QHash<QString, QString> profiles, QString profile)
	{
	QHashIterator<QString, QString> i(profiles);
	while (i.hasNext()) {
	i.next();
	// TODO
	- ui->profileName->setText(i.key());
	- ui->storePath->setText(i.value());
	+ //ui->profileTable->
	+ if (i.key() == profile) {
	+ ui->profileName->setText(i.key());
	+ ui->storePath->setText(i.value());
	+ }
	}
	}

	/**
	* @brief Dialog::getProfiles
	* @return
	*/
	QHash<QString, QString> Dialog::getProfiles()
	{
	QHash<QString, QString> profiles;
	profiles.insert(ui->profileName->text(), ui->storePath->text());
	return profiles;
	}
	diff --git a/dialog.h b/dialog.h
	index fe75259..ec2b490 100644
	--- a/dialog.h
	+++ b/dialog.h
	@@ -1,60 +1,60 @@
	#ifndef DIALOG_H
	#define DIALOG_H

	#include <QDialog>
	#include <QFileDialog>

	namespace Ui {
	class Dialog;
	}

	class Dialog : public QDialog
	{
	Q_OBJECT

	public:
	explicit Dialog(QWidget *parent = 0);
	~Dialog();
	void setPassPath(QString);
	void setGitPath(QString);
	void setGpgPath(QString);
	void setStorePath(QString);
	- void setProfiles(QHash<QString, QString>);
	+ void setProfiles(QHash<QString, QString>, QString);
	void usePass(bool);
	void useClipboard(bool);
	void useAutoclear(bool);
	void setAutoclear(int);
	void hidePassword(bool);
	void hideContent(bool);
	void addGPGId(bool);
	QString getPassPath();
	QString getGitPath();
	QString getGpgPath();
	QString getStorePath();
	QHash<QString,QString> getProfiles();
	bool usePass();
	bool useClipboard();
	bool useAutoclear();
	int getAutoclear();
	bool hidePassword();
	bool hideContent();
	bool addGPGId();

	private slots:
	void on_radioButtonNative_clicked();
	void on_radioButtonPass_clicked();
	void on_toolButtonGit_clicked();
	void on_toolButtonGpg_clicked();
	void on_toolButtonPass_clicked();
	void on_toolButtonStore_clicked();
	void on_checkBoxClipboard_clicked();
	void on_checkBoxAutoclear_clicked();

	private:
	QScopedPointer<Ui::Dialog> ui;
	void setGroupBoxState();
	QString selectExecutable();
	QString selectFolder();
	};

	#endif // DIALOG_H
	diff --git a/dialog.ui b/dialog.ui
	index 4cf57c4..3ddbd01 100644
	--- a/dialog.ui
	+++ b/dialog.ui
	@@ -1,290 +1,315 @@
	<?xml version="1.0" encoding="UTF-8"?>
	<ui version="4.0">
	<class>Dialog</class>
	<widget class="QDialog" name="Dialog">
	<property name="geometry">
	<rect>
	<x>0</x>
	<y>0</y>
	<width>660</width>
	<height>446</height>
	</rect>
	</property>
	<property name="windowTitle">
	<string>Configuration</string>
	</property>
	<layout class="QVBoxLayout" name="verticalLayout">
	<item>
	<widget class="QFrame" name="frame">
	<property name="sizePolicy">
	<sizepolicy hsizetype="Preferred" vsizetype="Fixed">
	<horstretch>0</horstretch>
	<verstretch>0</verstretch>
	</sizepolicy>
	</property>
	<property name="frameShape">
	<enum>QFrame::NoFrame</enum>
	</property>
	<property name="frameShadow">
	<enum>QFrame::Plain</enum>
	</property>
	<property name="lineWidth">
	<number>0</number>
	</property>
	<layout class="QHBoxLayout" name="horizontalLayout_2">
	<property name="leftMargin">
	<number>0</number>
	</property>
	<property name="topMargin">
	<number>0</number>
	</property>
	<property name="rightMargin">
	<number>0</number>
	</property>
	<property name="bottomMargin">
	<number>0</number>
	</property>
	<item>
	<layout class="QHBoxLayout" name="horizontalLayout_5">
	<item>
	<widget class="QRadioButton" name="radioButtonNative">
	<property name="text">
	<string>&Native git/gpg</string>
	</property>
	</widget>
	</item>
	<item>
	<widget class="QRadioButton" name="radioButtonPass">
	<property name="text">
	<string>&Use pass</string>
	</property>
	</widget>
	</item>
	</layout>
	</item>
	</layout>
	</widget>
	</item>
	<item>
	<layout class="QHBoxLayout" name="horizontalLayout_3">
	<item>
	<widget class="QGroupBox" name="groupBoxNative">
	<property name="title">
	<string>Native</string>
	</property>
	<layout class="QGridLayout" name="gridLayout">
	<item row="0" column="0">
	<widget class="QLabel" name="labelGitPath">
	<property name="text">
	<string>Executable git</string>
	</property>
	</widget>
	</item>
	<item row="1" column="1">
	<widget class="QLineEdit" name="gpgPath"/>
	</item>
	<item row="0" column="2">
	<widget class="QToolButton" name="toolButtonGit">
	<property name="text">
	<string>...</string>
	</property>
	</widget>
	</item>
	<item row="1" column="0">
	<widget class="QLabel" name="labelGpgPath">
	<property name="text">
	<string>Executable gpg</string>
	</property>
	</widget>
	</item>
	<item row="1" column="2">
	<widget class="QToolButton" name="toolButtonGpg">
	<property name="text">
	<string>...</string>
	</property>
	</widget>
	</item>
	<item row="0" column="1">
	<widget class="QLineEdit" name="gitPath"/>
	</item>
	</layout>
	</widget>
	</item>
	<item>
	<widget class="QGroupBox" name="groupBoxPass">
	<property name="title">
	<string>Pass</string>
	</property>
	<layout class="QGridLayout" name="gridLayout_2">
	<item row="0" column="2">
	<widget class="QToolButton" name="toolButtonPass">
	<property name="text">
	<string>...</string>
	</property>
	</widget>
	</item>
	<item row="0" column="0">
	<widget class="QLabel" name="labelPassPath">
	<property name="text">
	<string>Executable pass</string>
	</property>
	</widget>
	</item>
	<item row="0" column="1">
	<widget class="QLineEdit" name="passPath"/>
	</item>
	</layout>
	</widget>
	</item>
	</layout>
	</item>
	<item>
	<widget class="QGroupBox" name="groupBoxProfiles">
	<property name="title">
	<string>Profiles</string>
	</property>
	<layout class="QVBoxLayout" name="verticalLayout_2">
	+ <item>
	+ <widget class="QTableWidget" name="profileTable">
	+ <column>
	+ <property name="text">
	+ <string>Name</string>
	+ </property>
	+ </column>
	+ <column>
	+ <property name="text">
	+ <string>Path</string>
	+ </property>
	+ </column>
	+ </widget>
	+ </item>
	<item>
	<layout class="QGridLayout" name="gridLayout_5">
	- <item row="1" column="3">
	- <widget class="QLineEdit" name="storePath"/>
	+ <item row="1" column="1">
	+ <widget class="QLineEdit" name="profileName"/>
	</item>
	- <item row="1" column="4">
	- <widget class="QToolButton" name="toolButtonStore">
	+ <item row="1" column="0">
	+ <widget class="QLabel" name="labelName">
	<property name="text">
	- <string>...</string>
	+ <string>Profile name</string>
	</property>
	</widget>
	</item>
	<item row="1" column="2">
	<widget class="QLabel" name="labelStorePath">
	<property name="text">
	<string>Folder password-store</string>
	</property>
	</widget>
	</item>
	- <item row="1" column="1">
	- <widget class="QLineEdit" name="profileName"/>
	+ <item row="1" column="3">
	+ <widget class="QLineEdit" name="storePath"/>
	</item>
	- <item row="1" column="0">
	- <widget class="QLabel" name="labelName">
	+ <item row="1" column="4">
	+ <widget class="QToolButton" name="toolButtonStore">
	<property name="text">
	- <string>Profile name</string>
	+ <string>...</string>
	+ </property>
	+ </widget>
	+ </item>
	+ <item row="0" column="0">
	+ <widget class="QToolButton" name="toolButton">
	+ <property name="text">
	+ <string>Add</string>
	</property>
	</widget>
	</item>
	</layout>
	</item>
	</layout>
	+ <zorder>labelStorePath</zorder>
	+ <zorder></zorder>
	+ <zorder>profileTable</zorder>
	+ <zorder></zorder>
	</widget>
	</item>
	<item>
	<widget class="QGroupBox" name="groupBoxOther">
	<property name="title">
	<string>Other</string>
	</property>
	<layout class="QGridLayout" name="gridLayout_6">
	<item row="0" column="0">
	<layout class="QGridLayout" name="gridLayout_7">
	<item row="0" column="0">
	<widget class="QCheckBox" name="checkBoxClipboard">
	<property name="text">
	<string>Clipboard</string>
	</property>
	</widget>
	</item>
	<item row="0" column="1">
	<widget class="QCheckBox" name="checkBoxAutoclear">
	<property name="text">
	<string>Autoclear</string>
	</property>
	</widget>
	</item>
	<item row="1" column="0">
	<widget class="QCheckBox" name="checkBoxHidePassword">
	<property name="text">
	<string>Hide password</string>
	</property>
	</widget>
	</item>
	<item row="1" column="1">
	<widget class="QCheckBox" name="checkBoxHideContent">
	<property name="text">
	<string>Hide content</string>
	</property>
	</widget>
	</item>
	<item row="1" column="2">
	<widget class="QCheckBox" name="checkBoxAddGPGId">
	<property name="text">
	<string>Automatically add .gpg-id files</string>
	</property>
	</widget>
	</item>
	<item row="0" column="2">
	<layout class="QHBoxLayout" name="horizontalLayout">
	<item>
	<widget class="QSpinBox" name="spinBoxAutoclearSeconds"/>
	</item>
	<item>
	<widget class="QLabel" name="labelSeconds">
	<property name="text">
	<string>Seconds</string>
	</property>
	</widget>
	</item>
	</layout>
	</item>
	</layout>
	</item>
	</layout>
	</widget>
	</item>
	<item>
	<widget class="QDialogButtonBox" name="buttonBox">
	<property name="orientation">
	<enum>Qt::Horizontal</enum>
	</property>
	<property name="standardButtons">
	<set>QDialogButtonBox::Cancel\|QDialogButtonBox::Ok</set>
	</property>
	</widget>
	</item>
	</layout>
	</widget>
	<resources/>
	<connections>
	<connection>
	<sender>buttonBox</sender>
	<signal>accepted()</signal>
	<receiver>Dialog</receiver>
	<slot>accept()</slot>
	<hints>
	<hint type="sourcelabel">
	<x>248</x>
	<y>254</y>
	</hint>
	<hint type="destinationlabel">
	<x>157</x>
	<y>274</y>
	</hint>
	</hints>
	</connection>
	<connection>
	<sender>buttonBox</sender>
	<signal>rejected()</signal>
	<receiver>Dialog</receiver>
	<slot>reject()</slot>
	<hints>
	<hint type="sourcelabel">
	<x>316</x>
	<y>260</y>
	</hint>
	<hint type="destinationlabel">
	<x>286</x>
	<y>274</y>
	</hint>
	</hints>
	</connection>
	</connections>
	</ui>
	diff --git a/mainwindow.cpp b/mainwindow.cpp
	index f19c1aa..d74b817 100644
	--- a/mainwindow.cpp
	+++ b/mainwindow.cpp
	@@ -1,934 +1,935 @@
	#include "mainwindow.h"
	#include "ui_mainwindow.h"
	#include "dialog.h"
	#include "usersdialog.h"
	#include "util.h"
	#include <QClipboard>
	#include <QInputDialog>
	#include <QMessageBox>
	#include <QTimer>
	#include <QFileInfo>
	#include <QQueue>
	#ifdef Q_OS_WIN
	#include <windows.h>
	#include <winnetwk.h>
	#undef DELETE
	#endif

	/**
	* @brief MainWindow::MainWindow
	* @param parent
	*/
	MainWindow::MainWindow(QWidget *parent) :
	QMainWindow(parent),
	ui(new Ui::MainWindow),
	process(new QProcess(this)),
	fusedav(this)
	{
	// connect(process.data(), SIGNAL(readyReadStandardOutput()), this, SLOT(readyRead()));
	connect(process.data(), SIGNAL(error(QProcess::ProcessError)), this, SLOT(processError(QProcess::ProcessError)));
	connect(process.data(), SIGNAL(finished(int, QProcess::ExitStatus)), this, SLOT(processFinished(int, QProcess::ExitStatus)));
	ui->setupUi(this);
	enableUiElements(true);
	wrapperRunning = false;
	execQueue = new QQueue<execQueueItem>;
	ui->statusBar->showMessage(tr("Welcome to QtPass ") + VERSION, 2000);
	}

	/**
	* @brief MainWindow::~MainWindow
	*/
	MainWindow::~MainWindow()
	{
	#ifdef Q_OS_WIN
	if (useWebDav) WNetCancelConnection2A(passStore.toUtf8().constData(), 0, 1);
	#else
	if (fusedav.state() == QProcess::Running) {
	fusedav.terminate();
	fusedav.waitForFinished(2000);
	}
	#endif
	}

	void MainWindow::normalizePassStore() {
	if (!passStore.endsWith("/") && !passStore.endsWith(QDir::separator())) {
	passStore += '/';
	}
	}

	QSettings &MainWindow::getSettings() {
	if (!settings) {
	QString portable_ini = QCoreApplication::applicationDirPath() + "/qtpass.ini";
	if (QFile(portable_ini).exists()) {
	settings.reset(new QSettings(portable_ini, QSettings::IniFormat));
	} else {
	settings.reset(new QSettings("IJHack", "QtPass"));
	}
	}
	return *settings;
	}

	void MainWindow::mountWebDav() {
	#ifdef Q_OS_WIN
	char dst[20] = {0};
	NETRESOURCEA netres;
	memset(&netres, 0, sizeof(netres));
	netres.dwType = RESOURCETYPE_DISK;
	netres.lpLocalName = 0;
	netres.lpRemoteName = webDavUrl.toUtf8().data();
	DWORD size = sizeof(dst);
	DWORD r = WNetUseConnectionA(reinterpret_cast<HWND>(effectiveWinId()), &netres, webDavPassword.toUtf8().constData(),
	webDavUser.toUtf8().constData(), CONNECT_TEMPORARY \| CONNECT_INTERACTIVE \| CONNECT_REDIRECT,
	dst, &size, 0);
	if (r == NO_ERROR) {
	passStore = dst;
	} else {
	char message[256] = {0};
	FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM, 0, r, 0, message, sizeof(message), 0);
	ui->textBrowser->setTextColor(Qt::red);
	ui->textBrowser->setText(tr("Failed to connect WebDAV:\n") + message + " (0x" + QString::number(r, 16) + ")");
	}
	#else
	fusedav.start("fusedav -o nonempty -u \"" + webDavUser + "\" " + webDavUrl + " \"" + passStore + '"');
	fusedav.waitForStarted();
	if (fusedav.state() == QProcess::Running) {
	QString pwd = webDavPassword;
	bool ok = true;
	if (pwd.isEmpty()) {
	pwd = QInputDialog::getText(this, tr("QtPass WebDAV password"),
	tr("Enter password to connect to WebDAV:"), QLineEdit::Password, "", &ok);
	}
	if (ok && !pwd.isEmpty()) {
	fusedav.write(pwd.toUtf8() + '\n');
	fusedav.closeWriteChannel();
	fusedav.waitForFinished(2000);
	} else {
	fusedav.terminate();
	}
	}
	QString error = fusedav.readAllStandardError();
	int prompt = error.indexOf("Password:");
	if (prompt >= 0) {
	error.remove(0, prompt + 10);
	}
	if (fusedav.state() != QProcess::Running) {
	error = tr("fusedav exited unexpectedly\n") + error;
	}
	if (error.size() > 0) {
	ui->textBrowser->setTextColor(Qt::red);
	ui->textBrowser->setText(tr("Failed to start fusedav to connect WebDAV:\n") + error);
	}
	#endif
	}

	/**
	* @brief MainWindow::checkConfig
	*/
	void MainWindow::checkConfig() {

	QSettings &settings(getSettings());

	usePass = (settings.value("usePass") == "true");

	useClipboard = (settings.value("useClipboard") == "true");
	useAutoclear = (settings.value("useAutoclear") == "true");
	autoclearSeconds = settings.value("autoclearSeconds").toInt();
	hidePassword = (settings.value("hidePassword") == "true");
	hideContent = (settings.value("hideContent") == "true");
	addGPGId = (settings.value("addGPGId") != "false");

	passStore = settings.value("passStore").toString();
	if (passStore == "") {
	passStore = Util::findPasswordStore();
	settings.setValue("passStore", passStore);
	}
	normalizePassStore();

	passExecutable = settings.value("passExecutable").toString();
	if (passExecutable == "") {
	passExecutable = Util::findBinaryInPath("pass");
	}

	gitExecutable = settings.value("gitExecutable").toString();
	if (gitExecutable == "") {
	gitExecutable = Util::findBinaryInPath("git");
	}

	gpgExecutable = settings.value("gpgExecutable").toString();
	if (gpgExecutable == "") {
	gpgExecutable = Util::findBinaryInPath("gpg2");
	}
	gpgHome = settings.value("gpgHome").toString();

	useWebDav = (settings.value("useWebDav") == "true");
	webDavUrl = settings.value("webDavUrl").toString();
	webDavUser = settings.value("webDavUser").toString();
	webDavPassword = settings.value("webDavPassword").toString();

	+ profile = settings.value("profile").toString();
	settings.beginGroup("profiles");
	QStringList keys = settings.childKeys();
	foreach (QString key, keys) {
	profiles[key] = settings.value(key).toString();
	}
	settings.endGroup();

	if (passExecutable == "" && (gitExecutable == "" \|\| gpgExecutable == "")) {
	config();
	}

	// TODO: this needs to be before we try to access the store,
	// but it would be better to do it after the Window is shown,
	// as the long delay it can cause is irritating otherwise.
	if (useWebDav) {
	mountWebDav();
	}

	model.setNameFilters(QStringList() << "*.gpg");
	model.setNameFilterDisables(false);

	proxyModel.setSourceModel(&model);
	proxyModel.setModelAndStore(&model, passStore);
	selectionModel.reset(new QItemSelectionModel(&proxyModel));
	model.fetchMore(model.setRootPath(passStore));
	model.sort(0, Qt::AscendingOrder);

	ui->treeView->setModel(&proxyModel);
	ui->treeView->setRootIndex(proxyModel.mapFromSource(model.setRootPath(passStore)));
	ui->treeView->setColumnHidden(1, true);
	ui->treeView->setColumnHidden(2, true);
	ui->treeView->setColumnHidden(3, true);
	ui->treeView->setHeaderHidden(true);
	ui->treeView->setIndentation(15);
	ui->treeView->setHorizontalScrollBarPolicy(Qt::ScrollBarAsNeeded);

	ui->textBrowser->setOpenExternalLinks(true);

	updateProfileBox();

	env = QProcess::systemEnvironment();
	if (!gpgHome.isEmpty()) {
	QDir absHome(gpgHome);
	absHome.makeAbsolute();
	env << "GNUPGHOME=" + absHome.path();
	}
	#ifdef __APPLE__
	// If it exists, add the gpgtools to PATH
	if (QFile("/usr/local/MacGPG2/bin").exists()) {
	env.replaceInStrings("PATH=", "PATH=/usr/local/MacGPG2/bin:");
	}
	// Add missing /usr/local/bin
	if (env.filter("/usr/local/bin").isEmpty()) {
	env.replaceInStrings("PATH=", "PATH=/usr/local/bin:");
	}
	#endif
	//QMessageBox::information(this, "env", env.join("\n"));

	ui->lineEdit->setFocus();
	}

	/**
	* @brief MainWindow::config
	*/
	void MainWindow::config() {
	QScopedPointer<Dialog> d(new Dialog());
	d->setModal(true);

	d->setPassPath(passExecutable);
	d->setGitPath(gitExecutable);
	d->setGpgPath(gpgExecutable);
	d->setStorePath(passStore);
	d->usePass(usePass);
	d->useClipboard(useClipboard);
	d->useAutoclear(useAutoclear);
	d->setAutoclear(autoclearSeconds);
	d->hidePassword(hidePassword);
	d->hideContent(hideContent);
	d->addGPGId(addGPGId);
	- d->setProfiles(profiles);
	+ d->setProfiles(profiles, profile);

	if (d->exec()) {
	if (d->result() == QDialog::Accepted) {
	passExecutable = d->getPassPath();
	gitExecutable = d->getGitPath();
	gpgExecutable = d->getGpgPath();
	passStore = d->getStorePath();
	normalizePassStore();
	usePass = d->usePass();
	useClipboard = d->useClipboard();
	useAutoclear = d->useAutoclear();
	autoclearSeconds = d->getAutoclear();
	hidePassword = d->hidePassword();
	hideContent = d->hideContent();
	addGPGId = d->addGPGId();
	profiles = d->getProfiles();

	QSettings &settings(getSettings());

	settings.setValue("passExecutable", passExecutable);
	settings.setValue("gitExecutable", gitExecutable);
	settings.setValue("gpgExecutable", gpgExecutable);
	settings.setValue("passStore", passStore);
	settings.setValue("usePass", usePass ? "true" : "false");
	settings.setValue("useClipboard", useClipboard ? "true" : "false");
	settings.setValue("useAutoclear", useAutoclear ? "true" : "false");
	settings.setValue("autoclearSeconds", autoclearSeconds);
	settings.setValue("hidePassword", hidePassword ? "true" : "false");
	settings.setValue("hideContent", hideContent ? "true" : "false");
	settings.setValue("addGPGId", addGPGId ? "true" : "false");
	settings.beginGroup("profiles");
	settings.remove("");
	bool profileExists = false;
	QHashIterator<QString, QString> i(profiles);
	while (i.hasNext()) {
	i.next();
	//qDebug() << i.key() + "\|" + i.value();
	if (i.key() == profile) {
	profileExists = true;
	}
	settings.setValue(i.key(), i.value());
	}
	if (!profileExists) {
	// just take the last one
	profile = i.key();
	}
	settings.endGroup();

	updateProfileBox();
	ui->treeView->setRootIndex(model.setRootPath(passStore));
	}
	}
	}

	/**
	* @brief MainWindow::on_updateButton_clicked
	*/
	void MainWindow::on_updateButton_clicked()
	{
	ui->statusBar->showMessage(tr("Updating password-store"), 2000);
	currentAction = GIT;
	if (usePass) {
	executePass("git pull");
	} else {
	executeWrapper(gitExecutable, "pull");
	}
	}

	/**
	* @brief MainWindow::on_pushButton_clicked
	*/
	void MainWindow::on_pushButton_clicked()
	{
	ui->statusBar->showMessage(tr("Updating password-store"), 2000);
	currentAction = GIT;
	if (usePass) {
	executePass("git push");
	} else {
	executeWrapper(gitExecutable, "push");
	}
	}

	QString MainWindow::getDir(const QModelIndex &index, bool forPass)
	{
	if (!index.isValid()) {
	return forPass ? "" : passStore;
	}
	QFileInfo info = model.fileInfo(proxyModel.mapToSource(index));
	QString filePath = (info.isFile() ? info.absolutePath() : info.absoluteFilePath()) + '/';
	if (forPass) {
	filePath.replace(QRegExp("^" + passStore), "");
	}
	return filePath;
	}

	QString MainWindow::getFile(const QModelIndex &index, bool forPass)
	{
	if (!index.isValid() \|\| !model.fileInfo(proxyModel.mapToSource(index)).isFile()) {
	return QString();
	}
	QString filePath = model.filePath(proxyModel.mapToSource(index));
	if (forPass) {
	filePath.replace(QRegExp("\\.gpg$"), "");
	filePath.replace(QRegExp("^" + passStore), "");
	}
	return filePath;
	}

	/**
	* @brief MainWindow::on_treeView_clicked
	* @param index
	*/
	void MainWindow::on_treeView_clicked(const QModelIndex &index)
	{
	lastDecrypt = "Could not decrypt";
	QString file = getFile(index, usePass);
	if (!file.isEmpty()){
	currentAction = GPG;
	if (usePass) {
	executePass('"' + file + '"');
	} else {
	executeWrapper(gpgExecutable , "-d --quiet --yes --no-encrypt-to --batch --use-agent \"" + file + '"');
	}
	}
	}

	/**
	* @brief MainWindow::executePass
	* @param args
	*/
	void MainWindow::executePass(QString args, QString input) {
	executeWrapper(passExecutable, args, input);
	}

	/**
	* @brief MainWindow::executeWrapper
	* @param app
	* @param args
	*/
	void MainWindow::executeWrapper(QString app, QString args, QString input) {
	if (wrapperRunning) {
	execQueueItem item;
	item.app = app;
	item.args = args;
	item.input = input;
	execQueue->enqueue(item);
	//qDebug() << item.app + "," + item.args + "," + item.input;
	return;
	}
	wrapperRunning = true;
	process->setWorkingDirectory(passStore);
	process->setEnvironment(env);
	ui->textBrowser->clear();
	ui->textBrowser->setTextColor(Qt::black);
	enableUiElements(false);
	process->start('"' + app + "\" " + args);
	if (!input.isEmpty()) {
	process->write(input.toUtf8());
	}
	process->closeWriteChannel();
	}

	/**
	* @brief MainWindow::readyRead
	*/
	void MainWindow::readyRead(bool finished = false) {
	QString output = "";
	QString error = process->readAllStandardError();
	if (currentAction != GPG_INTERNAL) {
	output = process->readAllStandardOutput();
	if (finished && currentAction == GPG) {
	lastDecrypt = output;
	if (useClipboard && error.size() == 0) {
	QClipboard *clip = QApplication::clipboard();
	QStringList tokens = output.split("\n");
	clip->setText(tokens[0]);
	ui->statusBar->showMessage(tr("Password copied to clipboard"), 3000);
	if (useAutoclear) {
	clippedPass = tokens[0];
	QTimer::singleShot(1000*autoclearSeconds, this, SLOT(clearClipboard()));
	}
	if (hidePassword) {
	//tokens.pop_front();
	tokens[0] = "*" + tr("Password hidden") + "*";
	output = tokens.join("\n");
	}
	if (hideContent) {
	output = "*" + tr("Content hidden") + "*";
	}
	}
	}
	output.replace(QRegExp("<"), "<");
	output.replace(QRegExp(">"), ">");
	}

	if (error.size() > 0) {
	output = "<font color=\"red\">" + error + "</font><br />" + output;
	}

	output.replace(QRegExp("((http\|https\|ftp)\\://[a-zA-Z0-9\\-\\.]+\\.[a-zA-Z]{2,3}(:[a-zA-Z0-9])?/?([a-zA-Z0-9\\-\\._\\?\\,\\'/\\\\+&%\\$#\\=~]))"), "<a href=\"\\1\">\\1</a>");
	output.replace(QRegExp("\n"), "<br />");
	if (ui->textBrowser->toPlainText() != "") {
	output = ui->textBrowser->toHtml() + output;
	}
	ui->textBrowser->setHtml(output);
	}

	/**
	* @brief MainWindow::clearClipboard
	* @TODO check clipboard content (only clear if contains the password)
	*/
	void MainWindow::clearClipboard()
	{
	QClipboard *clipboard = QApplication::clipboard();
	if (clipboard->text() == clippedPass) {
	clipboard->clear();
	clippedPass = "";
	ui->statusBar->showMessage(tr("Clipboard cleared"), 3000);
	} else {
	ui->statusBar->showMessage(tr("Clipboard not cleared"), 3000);
	}
	}

	/**
	* @brief MainWindow::processFinished
	* @param exitCode
	* @param exitStatus
	*/
	void MainWindow::processFinished(int exitCode, QProcess::ExitStatus exitStatus) {
	wrapperRunning = false;
	bool error = exitStatus != QProcess::NormalExit \|\| exitCode > 0;
	if (error) {
	ui->textBrowser->setTextColor(Qt::red);
	}
	readyRead(true);
	enableUiElements(true);
	if (!error && currentAction == EDIT) {
	on_treeView_clicked(ui->treeView->currentIndex());
	}
	if (!execQueue->isEmpty()) {
	execQueueItem item = execQueue->dequeue();
	executeWrapper(item.app, item.args, item.input);
	}
	}

	/**
	* @brief MainWindow::enableUiElements
	* @param state
	*/
	void MainWindow::enableUiElements(bool state) {
	ui->updateButton->setEnabled(state);
	ui->treeView->setEnabled(state);
	ui->lineEdit->setEnabled(state);
	ui->addButton->setEnabled(state);
	ui->usersButton->setEnabled(state);
	state &= ui->treeView->currentIndex().isValid();
	ui->deleteButton->setEnabled(state);
	ui->editButton->setEnabled(state);
	ui->pushButton->setEnabled(state);
	}

	/**
	* @brief MainWindow::processError
	* @param error
	*/
	void MainWindow::processError(QProcess::ProcessError error)
	{
	QString errorString;
	switch (error) {
	case QProcess::FailedToStart:
	errorString = tr("QProcess::FailedToStart");
	break;
	case QProcess::Crashed:
	errorString = tr("QProcess::Crashed");
	break;
	case QProcess::Timedout:
	errorString = tr("QProcess::Timedout");
	break;
	case QProcess::ReadError:
	errorString = tr("QProcess::ReadError");
	break;
	case QProcess::WriteError:
	errorString = tr("QProcess::WriteError");
	break;
	case QProcess::UnknownError:
	errorString = tr("QProcess::UnknownError");
	break;
	}
	ui->textBrowser->setTextColor(Qt::red);
	ui->textBrowser->setText(errorString);
	if (process->state() == QProcess::NotRunning)
	enableUiElements(true);
	}

	/**
	* @brief MainWindow::setPassExecutable
	* @param path
	*/
	void MainWindow::setPassExecutable(QString path) {
	passExecutable = path;
	}

	/**
	* @brief MainWindow::setGitExecutable
	* @param path
	*/
	void MainWindow::setGitExecutable(QString path) {
	gitExecutable = path;
	}

	/**
	* @brief MainWindow::setGpgExecutable
	* @param path
	*/
	void MainWindow::setGpgExecutable(QString path) {
	gpgExecutable = path;
	}

	/**
	* @brief MainWindow::on_configButton_clicked
	*/
	void MainWindow::on_configButton_clicked()
	{
	config();
	}

	/**
	* @brief MainWindow::on_lineEdit_textChanged
	* @param arg1
	*/
	void MainWindow::on_lineEdit_textChanged(const QString &arg1)
	{
	ui->treeView->expandAll();
	ui->statusBar->showMessage(tr("Looking for: ") + arg1, 1000);
	QString query = arg1;
	query.replace(QRegExp(" "), ".*");
	QRegExp regExp(query, Qt::CaseInsensitive);
	proxyModel.setFilterRegExp(regExp);
	ui->treeView->setRootIndex(proxyModel.mapFromSource(model.setRootPath(passStore)));
	selectFirstFile();
	}

	/**
	* @brief MainWindow::on_lineEdit_returnPressed
	*/
	void MainWindow::on_lineEdit_returnPressed()
	{
	selectFirstFile();
	on_treeView_clicked(ui->treeView->currentIndex());
	}

	/**
	* @brief MainWindow::selectFirstFile
	*/
	void MainWindow::selectFirstFile()
	{
	QModelIndex index = proxyModel.mapFromSource(model.setRootPath(passStore));
	index = firstFile(index);
	ui->treeView->setCurrentIndex(index);
	}

	/**
	* @brief MainWindow::firstFile
	* @param parentIndex
	* @return QModelIndex
	*/
	QModelIndex MainWindow::firstFile(QModelIndex parentIndex) {
	QModelIndex index = parentIndex;
	int numRows = proxyModel.rowCount(parentIndex);
	for (int row = 0; row < numRows; ++row) {
	index = proxyModel.index(row, 0, parentIndex);
	if (model.fileInfo(proxyModel.mapToSource(index)).isFile()) {
	return index;
	}
	if (proxyModel.hasChildren(index)) {
	return firstFile(index);
	}
	}
	return index;
	}

	/**
	* @brief MainWindow::on_clearButton_clicked
	*/
	void MainWindow::on_clearButton_clicked()
	{
	ui->lineEdit->clear();
	}

	QStringList MainWindow::getRecipientList(QString for_file)
	{
	QDir gpgIdPath(QFileInfo(for_file.startsWith(passStore) ? for_file : passStore + for_file).absoluteDir());
	bool found = false;
	while (gpgIdPath.exists() && gpgIdPath.absolutePath().startsWith(passStore))
	{
	if (QFile(gpgIdPath.absoluteFilePath(".gpg-id")).exists()) {
	found = true;
	break;
	}
	if (!gpgIdPath.cdUp()) {
	break;
	}
	}
	QFile gpgId(found ? gpgIdPath.absoluteFilePath(".gpg-id") : passStore + ".gpg-id");
	if (!gpgId.open(QIODevice::ReadOnly \| QIODevice::Text)) {
	return QStringList();
	}
	QStringList recipients;
	while (!gpgId.atEnd()) {
	QString recipient(gpgId.readLine());
	recipient = recipient.trimmed();
	if (!recipient.isEmpty()) {
	recipients += recipient;
	}
	}
	return recipients;
	}

	QString MainWindow::getRecipientString(QString for_file, QString separator, int *count)
	{
	QString recipients_str;
	QStringList recipients_list = getRecipientList(for_file);
	if (count)
	{
	*count = recipients_list.size();
	}
	foreach (const QString recipient, recipients_list)
	{
	recipients_str += separator + '"' + recipient + '"';
	}
	return recipients_str;
	}

	void MainWindow::setPassword(QString file, bool overwrite)
	{
	bool ok;
	#if QT_VERSION >= QT_VERSION_CHECK(5, 2, 0)
	QString newValue = QInputDialog::getMultiLineText(this, tr("New Value"),
	tr("New password value:"),
	lastDecrypt, &ok);
	#else
	QString newValue = QInputDialog::getText(this, tr("New Value"),
	tr("New password value:"), QLineEdit::Normal,
	lastDecrypt, &ok);
	#endif
	if (!ok \|\| newValue.isEmpty()) {
	return;
	}
	currentAction = EDIT;
	if (usePass) {
	QString force(overwrite ? " -f " : " ");
	executePass("insert" + force + "-m \"" + file + '"', newValue);
	} else {
	QString recipients = getRecipientString(file, " -r ");
	if (recipients.isEmpty()) {
	QMessageBox::critical(this, tr("Can not edit"),
	tr("Could not read encryption key to use, .gpg-id file missing or invalid."));
	return;
	}
	QString force(overwrite ? " --yes " : " ");
	executeWrapper(gpgExecutable , force + "--batch -eq --output \"" + file + "\" " + recipients + " -", newValue);
	if (!useWebDav) {
	if (!overwrite) {
	executeWrapper(gitExecutable, "add \"" + file + '"');
	}
	QString path = file;
	path.replace(QRegExp("\\.gpg$"), "");
	path.replace(QRegExp("^" + passStore), "");
	executeWrapper(gitExecutable, "commit \"" + file + "\" -m \"" + (overwrite ? "Edit" : "Add") + " for " + path + " using QtPass\"");
	}
	}
	}

	void MainWindow::on_addButton_clicked()
	{
	bool ok;
	QString file = QInputDialog::getText(this, tr("New file"),
	tr("New password file:"), QLineEdit::Normal,
	"", &ok);
	if (!ok \|\| file.isEmpty()) {
	return;
	}
	file = getDir(ui->treeView->currentIndex(), usePass) + file;
	if (!usePass) {
	file += ".gpg";
	}
	lastDecrypt = "";
	setPassword(file, false);
	}

	void MainWindow::on_deleteButton_clicked()
	{
	QString file = getFile(ui->treeView->currentIndex(), usePass);
	if (QMessageBox::question(this, tr("Delete password?"),
	tr("Are you sure you want to delete %1?").arg(file),
	QMessageBox::Yes \| QMessageBox::No) != QMessageBox::Yes) {
	return;
	}
	currentAction = DELETE;
	if (usePass) {
	executePass("rm -f \"" + file + '"');
	} else {
	QFile(file).remove();
	}
	}

	void MainWindow::on_editButton_clicked()
	{
	QString file = getFile(ui->treeView->currentIndex(), usePass);
	if (file.isEmpty()) {
	QMessageBox::critical(this, tr("Can not edit"),
	tr("Selected password file does not exist, not able to edit"));
	return;
	}
	setPassword(file, true);
	}

	QList<UserInfo> MainWindow::listKeys(QString keystring)
	{
	QList<UserInfo> users;
	currentAction = GPG_INTERNAL;
	executeWrapper(gpgExecutable , "--no-tty --with-colons --list-keys " + keystring);
	process->waitForFinished(2000);
	if (process->exitStatus() != QProcess::NormalExit) {
	return users;
	}
	QStringList keys = QString(process->readAllStandardOutput()).split(QRegExp("[\r\n]"), QString::SkipEmptyParts);
	UserInfo current_user;
	foreach (QString key, keys) {
	QStringList props = key.split(':');
	if (props.size() < 10) {
	continue;
	}
	if(props[0] == "pub") {
	if (!current_user.key_id.isEmpty())
	{
	users.append(current_user);
	}
	current_user = UserInfo();
	current_user.key_id = props[4];
	current_user.name = props[9];
	} else if (current_user.name.isEmpty() && props[0] == "uid") {
	current_user.name = props[9];
	}
	}
	if (!current_user.key_id.isEmpty())
	{
	users.append(current_user);
	}
	return users;
	}

	void MainWindow::on_usersButton_clicked()
	{
	QList<UserInfo> users = listKeys();
	if (users.size() == 0) {
	QMessageBox::critical(this, tr("Can not get key list"),
	tr("Unable to get list of available gpg keys"));
	return;
	}
	QList<UserInfo> selected_users;
	QString dir = getDir(ui->treeView->currentIndex(), false);
	int count = 0;
	QString recipients = getRecipientString(dir.isEmpty() ? "" : dir, " ", &count);
	if (!recipients.isEmpty()) {
	selected_users = listKeys(recipients);
	}
	foreach (const UserInfo &sel, selected_users) {
	for (QList<UserInfo>::iterator it = users.begin(); it != users.end(); ++it) {
	if (sel.key_id == it->key_id) it->enabled = true;
	}
	}
	if (count > selected_users.size())
	{
	// Some keys seem missing from keyring, add them separately
	QStringList recipients = getRecipientList(dir.isEmpty() ? "" : dir);
	foreach (const QString recipient, recipients)
	{
	if (listKeys(recipient).size() < 1)
	{
	UserInfo i;
	i.enabled = true;
	i.key_id = recipient;
	i.name = " ?? " + tr("Key not found in keyring");
	users.append(i);
	}
	}
	}
	UsersDialog d(this);
	d.setUsers(&users);
	if (!d.exec()) {
	d.setUsers(NULL);
	return;
	}
	d.setUsers(NULL);
	QString gpgIdFile = dir + ".gpg-id";
	QFile gpgId(gpgIdFile);
	bool addFile = false;
	if (addGPGId) {
	QFileInfo checkFile(gpgIdFile);
	if (!checkFile.exists() \|\| !checkFile.isFile()) {
	addFile = true;
	}
	}
	if (!gpgId.open(QIODevice::WriteOnly \| QIODevice::Text)) {
	QMessageBox::critical(this, tr("Cannot update"),
	tr("Failed to open .gpg-id for writing."));
	return;
	}
	foreach (const UserInfo &user, users) {
	if (user.enabled) {
	gpgId.write((user.key_id + "\n").toUtf8());
	}
	}
	gpgId.close();
	if (!useWebDav){
	if (addFile) {
	executeWrapper(gitExecutable, "add \"" + gpgIdFile + '"');
	}
	QString path = gpgIdFile;
	path.replace(QRegExp("\\.gpg$"), "");
	executeWrapper(gitExecutable, "commit \"" + gpgIdFile + "\" -m \"Added "+ path + " using QtPass\"");
	}
	}

	/**
	* @brief MainWindow::setApp
	* @param app
	*/
	void MainWindow::setApp(SingleApplication *app)
	{
	#if SINGLE_APP
	connect(app, SIGNAL(messageAvailable(QString)), this, SLOT(messageAvailable(QString)));
	#endif
	}

	/**
	* @brief MainWindow::messageAvailable
	* @param message
	*/
	void MainWindow::messageAvailable(QString message)
	{
	if (message == "") {
	ui->lineEdit->selectAll();
	ui->lineEdit->setFocus();
	} else {
	ui->treeView->expandAll();
	ui->lineEdit->setText(message);
	on_lineEdit_returnPressed();
	}
	show();
	raise();
	}

	/**
	* @brief MainWindow::setText
	* @param message
	*/
	void MainWindow::setText(QString text)
	{
	ui->lineEdit->setText(text);
	}

	/**
	* @brief MainWindow::updateProfileBox
	*/
	void MainWindow::updateProfileBox()
	{
	if (profiles.isEmpty()) {
	ui->profileBox->setVisible(false);
	} else {
	ui->profileBox->setVisible(true);
	if (profiles.size() < 2) {
	ui->profileBox->setEnabled(false);
	}
	ui->profileBox->clear();
	QHashIterator<QString, QString> i(profiles);
	while (i.hasNext()) {
	i.next();
	ui->profileBox->addItem(i.key());
	}
	}
	int index = ui->profileBox->findData(profile);
	if ( index != -1 ) { // -1 for not found
	ui->profileBox->setCurrentIndex(index);
	}
	}
	diff --git a/qtpass.pro b/qtpass.pro
	index d24a8f2..12ca88f 100644
	--- a/qtpass.pro
	+++ b/qtpass.pro
	@@ -1,75 +1,75 @@
	#-------------------------------------------------
	#
	# Project created by QtCreator 2014-07-30T21:56:15
	#
	#-------------------------------------------------

	QT += core gui

	greaterThan(QT_MAJOR_VERSION, 4): QT += widgets

	macx {
	TARGET = QtPass
	} else {
	TARGET = qtpass
	}

	TEMPLATE = app
	-VERSION = 0.8.1
	+VERSION = 0.8.2

	SOURCES += main.cpp\
	mainwindow.cpp \
	dialog.cpp \
	storemodel.cpp \
	util.cpp \
	usersdialog.cpp

	HEADERS += mainwindow.h \
	dialog.h \
	storemodel.h \
	util.h \
	usersdialog.h

	FORMS += mainwindow.ui \
	dialog.ui \
	usersdialog.ui

	nosingleapp {
	QMAKE_CXXFLAGS += -DSINGLE_APP=0
	} else {
	SOURCES += singleapplication.cpp
	HEADERS += singleapplication.h
	QT += network
	QMAKE_CXXFLAGS += -DSINGLE_APP=1
	}

	TRANSLATIONS += localization/localization_nl_NL.ts \
	localization/localization_de_DE.ts \
	localization/localization_es_ES.ts \
	localization/localization_gl_ES.ts \
	localization/localization_hu_HU.ts \
	localization/localization_sv_SE.ts \
	localization/localization_pl_PL.ts \
	localization/localization_ru_RU.ts

	RESOURCES += resources.qrc

	win32 {
	RC_FILE = windows.rc
	static {
	QMAKE_LFLAGS += -static-libgcc -static-libstdc++
	}
	QMAKE_LFLAGS += -Wl,--dynamicbase -Wl,--nxcompat
	LIBS += -lmpr
	} else:macx {
	ICON = artwork/icon.icns
	QMAKE_INFO_PLIST = Info.plist
	}

	OTHER_FILES += LICENSE \
	README.md

	target.path = /usr/local/bin/
	INSTALLS += target

	DEFINES += "VERSION=\"\\\"$$VERSION\\\"\""

File Metadata

Mime Type: text/x-diff
Expires: Sun, Feb 23, 7:21 PM (5 h, 16 m)
Storage Engine: local-disk
Storage Format: Raw Data
Storage Handle: 01/02/29b876eb5ff493fe4e721adc1bac

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions