renamed program

git-svn-id: http://cpunk.de/svn/src/gpg4usb@105 34ebc366-c3a9-4b3c-9f84-69acf7962910

52 files changed, 4787 insertions, 0 deletions

diff --git a/2copyFrom/kgpgme-sample.cpp b/2copyFrom/kgpgme-sample.cpp
new file mode 100644
index 0000000..64dfcf7
--- /dev/null
+++ b/2copyFrom/kgpgme-sample.cpp
@@ -0,0 +1,442 @@
+/***************************************************************************
+ *   Copyright (C) 2006 by Petri Damsten                                   *
+ *   [email protected]                                                           *
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ *   This program is distributed in the hope that it will be useful,       *
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
+ *   GNU General Public License for more details.                          *
+ *                                                                         *
+ *   You should have received a copy of the GNU General Public License     *
+ *   along with this program; if not, write to the                         *
+ *   Free Software Foundation, Inc.,                                       *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
+ ***************************************************************************/
+
+#include "kgpgme.h"
+
+#ifdef HAVE_LIBGPGME
+
+#include <kapplication.h>
+#include <kmessagebox.h>
+#include <kpassdlg.h>
+#include <kiconloader.h>
+#include <klistview.h>
+#include <kdebug.h>
+#include <qcheckbox.h>
+#include <qlayout.h>
+#include <qlabel.h>
+#include <klocale.h>
+#include <locale.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+// KGpgSelKey class based on class in KGpg with the same name
+
+class KGpgSelKey : public KDialogBase
+{
+  private:
+    KListView* keysListpr;
+
+  public:
+
+    KGpgSelKey(QWidget *parent, const char *name, QString preselected,
+      const KGpgMe& gpg):
+    KDialogBase( parent, name, true,i18n("Private Key List"),Ok | Cancel) {
+      QString keyname;
+      QVBoxLayout* vbox;
+      QWidget* page = new QWidget(this);
+      QLabel* labeltxt;
+      KIconLoader* loader = KGlobal::iconLoader();
+      QPixmap keyPair = loader->loadIcon("kgpg_key2", KIcon::Small, 20);
+
+      setMinimumSize(350,100);
+      keysListpr = new KListView(page);
+      keysListpr->setRootIsDecorated(true);
+      keysListpr->addColumn(i18n("Name"));
+      keysListpr->addColumn(i18n("Email"));
+      keysListpr->addColumn(i18n("ID"));
+      keysListpr->setShowSortIndicator(true);
+      keysListpr->setFullWidth(true);
+      keysListpr->setAllColumnsShowFocus(true);
+
+      labeltxt = new QLabel(i18n("Choose a secret key:"),page);
+      vbox = new QVBoxLayout(page);
+
+      KGpgKeyList list = gpg.keys(true);
+
+      for(KGpgKeyList::iterator it = list.begin(); it != list.end(); ++it) {
+        QString name = gpg.checkForUtf8((*it).name);
+        KListViewItem *item = new
+          KListViewItem(keysListpr, name, (*it).email, (*it).id);
+        item->setPixmap(0,keyPair);
+        if(preselected == (*it).id) {
+          keysListpr->setSelected(item, true);
+          keysListpr->setCurrentItem(item);
+        }
+      }
+      if(!keysListpr->selectedItem()) {
+        keysListpr->setSelected(keysListpr->firstChild(), true);
+        keysListpr->setCurrentItem(keysListpr->firstChild());
+      }
+      vbox->addWidget(labeltxt);
+      vbox->addWidget(keysListpr);
+      setMainWidget(page);
+    };
+
+    QString key() {
+      QListViewItem* item = keysListpr->selectedItem();
+
+      if(item)
+        return item->text(2);
+      return "";
+    }
+};
+
+KGpgMe::KGpgMe() : m_ctx(0), m_useGnuPGAgent(true)
+{
+  init(GPGME_PROTOCOL_OpenPGP);
+  if(gpgme_new(&m_ctx)) {
+    m_ctx = 0;
+  }
+  else {
+    gpgme_set_armor(m_ctx, 1);
+    setPassphraseCb();
+  }
+}
+
+KGpgMe::~KGpgMe()
+{
+  if(m_ctx)
+    gpgme_release(m_ctx);
+  clearCache();
+}
+
+void KGpgMe::clearCache()
+{
+  if(m_cache.size() > 0)
+  {
+    m_cache.fill('\0');
+    m_cache.truncate(0);
+  }
+}
+
+void KGpgMe::init(gpgme_protocol_t proto)
+{
+  gpgme_error_t err;
+
+  gpgme_check_version(NULL);
+  setlocale(LC_ALL, "");
+  gpgme_set_locale(NULL, LC_CTYPE, setlocale(LC_CTYPE, NULL));
+  gpgme_set_locale(NULL, LC_MESSAGES, setlocale(LC_MESSAGES, NULL));
+
+  err = gpgme_engine_check_version(proto);
+  if(err) {
+    KMessageBox::error(kapp->activeWindow(), QString("%1: %2")
+      .arg(gpgme_strsource(err)).arg(gpgme_strerror(err)));
+  }
+}
+
+QString KGpgMe::checkForUtf8(QString txt)
+{
+  // code borrowed from KGpg which borrowed it from gpa
+  const char *s;
+
+  // Make sure the encoding is UTF-8.
+  // Test structure suggested by Werner Koch
+  if(txt.isEmpty())
+    return QString::null;
+
+  for(s = txt.ascii(); *s && !(*s & 0x80); s++)
+    ;
+  if (*s && !strchr (txt.ascii(), 0xc3) && (txt.find("\\x")==-1))
+    return txt;
+
+  // The string is not in UTF-8
+  //if (strchr (txt.ascii(), 0xc3)) return (txt+" +++");
+  if (txt.find("\\x")==-1)
+    return QString::fromUtf8(txt.ascii());
+  //        if (!strchr (txt.ascii(), 0xc3) || (txt.find("\\x")!=-1)) {
+  for(int idx = 0 ; (idx = txt.find( "\\x", idx )) >= 0 ; ++idx) {
+    char str[2] = "x";
+    str[0] = (char)QString(txt.mid(idx + 2, 2)).toShort(0, 16);
+    txt.replace(idx, 4, str);
+  }
+  if (!strchr (txt.ascii(), 0xc3))
+    return QString::fromUtf8(txt.ascii());
+  else
+    return QString::fromUtf8(QString::fromUtf8(txt.ascii()).ascii());
+  // perform Utf8 twice, or some keys display badly
+  return txt;
+}
+
+QString KGpgMe::selectKey(QString previous)
+{
+  KGpgSelKey dlg(kapp->activeWindow(), "", previous, *this);
+
+  if(dlg.exec())
+    return dlg.key();
+  return "";
+}
+
+// Rest of the code is mainly based in gpgme examples
+
+KGpgKeyList KGpgMe::keys(bool privateKeys /* = false */) const
+{
+  KGpgKeyList keys;
+  gpgme_error_t err = 0, err2 = 0;
+  gpgme_key_t key = 0;
+  gpgme_keylist_result_t result = 0;
+
+  if(m_ctx) {
+    err = gpgme_op_keylist_start(m_ctx, NULL, privateKeys);
+    if(!err) {
+      while(!(err = gpgme_op_keylist_next(m_ctx, &key))) {
+        KGpgKey gpgkey;
+
+        if(!key->subkeys)
+          continue;
+        gpgkey.id = key->subkeys->keyid;
+        if(key->uids) {
+          gpgkey.name = key->uids->name;
+          gpgkey.email = key->uids->email;
+        }
+        keys.append(gpgkey);
+        gpgme_key_unref(key);
+      }
+
+      if (gpg_err_code (err) == GPG_ERR_EOF)
+        err = 0;
+      err2 = gpgme_op_keylist_end(m_ctx);
+      if(!err)
+        err = err2;
+    }
+  }
+
+  if(err) {
+    KMessageBox::error(kapp->activeWindow(), QString("%1: %2")
+      .arg(gpgme_strsource(err)).arg(gpgme_strerror(err)));
+  }
+  else {
+    result = gpgme_op_keylist_result(m_ctx);
+    if (result->truncated) {
+      KMessageBox::error(kapp->activeWindow(),
+        i18n("Key listing unexpectedly truncated."));
+    }
+  }
+  return keys;
+}
+
+bool KGpgMe::encrypt(const QByteArray& inBuffer, Q_ULONG length,
+           QByteArray* outBuffer, QString keyid /* = QString::null */)
+{
+  gpgme_error_t err = 0;
+  gpgme_data_t in = 0, out = 0;
+  gpgme_key_t keys[2] = { NULL, NULL };
+  gpgme_key_t* key = NULL;
+  gpgme_encrypt_result_t result = 0;
+
+  outBuffer->resize(0);
+  if(m_ctx) {
+    err = gpgme_data_new_from_mem(&in, inBuffer.data(), length, 1);
+    if(!err) {
+      err = gpgme_data_new(&out);
+      if(!err) {
+        if(keyid.isNull()) {
+        	key = NULL;
+        } else {
+          err = gpgme_get_key(m_ctx, keyid.ascii(), &keys[0], 0);
+          key = keys;
+        }
+
+        if(!err) {
+          err = gpgme_op_encrypt(m_ctx, key, GPGME_ENCRYPT_ALWAYS_TRUST,
+            in, out);
+          if(!err) {
+            result = gpgme_op_encrypt_result(m_ctx);
+            if (result->invalid_recipients) {
+              KMessageBox::error(kapp->activeWindow(), QString("%1: %2")
+                .arg(i18n("That public key is not meant for encryption"))
+                .arg(result->invalid_recipients->fpr));
+            }
+            else {
+              err = readToBuffer(out, outBuffer);
+            }
+          }
+        }
+      }
+    }
+  }
+  if(err != GPG_ERR_NO_ERROR && err != GPG_ERR_CANCELED) {
+    KMessageBox::error(kapp->activeWindow(), QString("%1: %2")
+      .arg(gpgme_strsource(err)).arg(gpgme_strerror(err)));
+  }
+  if(err != GPG_ERR_NO_ERROR)
+    clearCache();
+  if(keys[0])
+    gpgme_key_unref(keys[0]);
+  if(in)
+    gpgme_data_release(in);
+  if(out)
+    gpgme_data_release(out);
+  return (err == GPG_ERR_NO_ERROR);
+}
+
+bool KGpgMe::decrypt(const QByteArray& inBuffer, QByteArray* outBuffer)
+{
+  gpgme_error_t err = 0;
+  gpgme_data_t in = 0, out = 0;
+  gpgme_decrypt_result_t result = 0;
+
+  outBuffer->resize(0);
+  if(m_ctx) {
+    err = gpgme_data_new_from_mem(&in, inBuffer.data(), inBuffer.size(), 1);
+    if(!err) {
+      err = gpgme_data_new(&out);
+      if(!err) {
+        err = gpgme_op_decrypt(m_ctx, in, out);
+        if(!err) {
+          result = gpgme_op_decrypt_result(m_ctx);
+          if(result->unsupported_algorithm) {
+            KMessageBox::error(kapp->activeWindow(), QString("%1: %2")
+              .arg(i18n("Unsupported algorithm"))
+              .arg(result->unsupported_algorithm));
+          }
+          else {
+            err = readToBuffer(out, outBuffer);
+          }
+        }
+      }
+    }
+  }
+  if(err != GPG_ERR_NO_ERROR && err != GPG_ERR_CANCELED) {
+    KMessageBox::error(kapp->activeWindow(), QString("%1: %2")
+      .arg(gpgme_strsource(err)).arg(gpgme_strerror(err)));
+  }
+  if(err != GPG_ERR_NO_ERROR)
+    clearCache();
+  if(in)
+    gpgme_data_release(in);
+  if(out)
+    gpgme_data_release(out);
+  return (err == GPG_ERR_NO_ERROR);
+}
+
+#define BUF_SIZE (32 * 1024)
+
+gpgme_error_t KGpgMe::readToBuffer(gpgme_data_t in, QByteArray* outBuffer) const
+{
+  int ret;
+  gpgme_error_t err = GPG_ERR_NO_ERROR;
+
+  ret = gpgme_data_seek(in, 0, SEEK_SET);
+  if(ret) {
+    err = gpgme_err_code_from_errno(errno);
+  }
+  else {
+    char* buf = new char[BUF_SIZE + 2];
+
+    if(buf) {
+      while((ret = gpgme_data_read(in, buf, BUF_SIZE)) > 0) {
+        uint size = outBuffer->size();
+        if(outBuffer->resize(size + ret))
+          memcpy(outBuffer->data() + size, buf, ret);
+      }
+      if(ret < 0)
+        err = gpgme_err_code_from_errno(errno);
+      delete[] buf;
+    }
+  }
+  return err;
+}
+
+bool KGpgMe::isGnuPGAgentAvailable()
+{
+  QString agent_info = getenv("GPG_AGENT_INFO");
+
+  if (agent_info.find(':') > 0)
+    return true;
+  return false;
+}
+
+void KGpgMe::setPassphraseCb()
+{
+  bool agent = false;
+  QString agent_info;
+
+  agent_info = getenv("GPG_AGENT_INFO");
+
+  if(m_useGnuPGAgent)
+  {
+    if (agent_info.find(':'))
+      agent = true;
+    if(agent_info.startsWith("disable:"))
+      setenv("GPG_AGENT_INFO", agent_info.mid(8), 1);
+  }
+  else
+  {
+    if(!agent_info.startsWith("disable:"))
+      setenv("GPG_AGENT_INFO", "disable:" + agent_info, 1);
+  }
+  if (agent)
+    gpgme_set_passphrase_cb(m_ctx, 0, 0);
+  else
+    gpgme_set_passphrase_cb(m_ctx, passphraseCb, this);
+}
+
+gpgme_error_t KGpgMe::passphraseCb(void* hook, const char* uid_hint,
+                   const char* passphrase_info,
+                   int last_was_bad, int fd)
+{
+  KGpgMe* gpg = static_cast<KGpgMe*>(hook);
+  return gpg->passphrase(uid_hint, passphrase_info, last_was_bad, fd);
+}
+
+gpgme_error_t KGpgMe::passphrase(const char* uid_hint,
+                 const char* /*passphrase_info*/,
+                 int last_was_bad, int fd)
+{
+  gpgme_error_t res = GPG_ERR_CANCELED;
+  QString s;
+  QString gpg_hint = checkForUtf8(uid_hint);
+  int result;
+
+  if(last_was_bad){
+    s += "<b>" + i18n("Wrong password.") + "</b><br><br>\n\n";
+    clearCache();
+  }
+
+  if(!m_text.isEmpty())
+    s += m_text + "<br>";
+
+  if(!gpg_hint.isEmpty())
+    s += gpg_hint;
+
+  if(m_cache.isEmpty()){
+    QCString password;
+
+    if(m_saving)
+      result = KPasswordDialog::getNewPassword(password, s);
+    else
+      result = KPasswordDialog::getPassword(password, s);
+
+    if(result == KPasswordDialog::Accepted)
+      m_cache = password;
+  }
+  else
+    result = KPasswordDialog::Accepted;
+
+  if(result == KPasswordDialog::Accepted) {
+    write(fd, m_cache.data(), m_cache.length());
+    res = 0;
+  }
+  write(fd, "\n", 1);
+  return res;
+}
+#endif  // HAVE_LIBGPGME
diff --git a/2copyFrom/kgpgme-sample.h b/2copyFrom/kgpgme-sample.h
new file mode 100644
index 0000000..6a3d912
--- /dev/null
+++ b/2copyFrom/kgpgme-sample.h
@@ -0,0 +1,85 @@
+/***************************************************************************
+ *   Copyright (C) 2006 by Petri Damsten                                   *
+ *   [email protected]                                                           *
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ *   This program is distributed in the hope that it will be useful,       *
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
+ *   GNU General Public License for more details.                          *
+ *                                                                         *
+ *   You should have received a copy of the GNU General Public License     *
+ *   along with this program; if not, write to the                         *
+ *   Free Software Foundation, Inc.,                                       *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
+ ***************************************************************************/
+#ifndef KGPGME_H
+#define KGPGME_H
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#ifdef HAVE_LIBGPGME
+
+#include <gpgme.h>
+#include <qstringlist.h>
+
+/**
+  @author Petri Damsten <[email protected]>
+*/
+
+class KGpgKey
+{
+  public:
+    QString id;
+    QString name;
+    QString email;
+};
+
+typedef QValueList< KGpgKey > KGpgKeyList;
+
+class KGpgMe
+{
+  public:
+    KGpgMe();
+    ~KGpgMe();
+
+    QString selectKey(QString previous = QString::null);
+    KGpgKeyList keys(bool privateKeys = false) const;
+    void setText(QString text, bool saving) { m_text = text; m_saving = saving; };
+    void setUseGnuPGAgent(bool use) { m_useGnuPGAgent = use; setPassphraseCb(); };
+    QString text() const { return m_text; };
+    bool saving() const { return m_saving; };
+    void clearCache();
+
+    bool encrypt(const QByteArray& inBuffer, Q_ULONG length,
+           QByteArray* outBuffer, QString keyid = QString::null);
+    bool decrypt(const QByteArray& inBuffer, QByteArray* outBuffer);
+
+    static QString checkForUtf8(QString txt);
+    static bool isGnuPGAgentAvailable();
+
+  private:
+    gpgme_ctx_t m_ctx;
+    QString m_text;
+    bool m_saving;
+    bool m_useGnuPGAgent;
+    QCString m_cache;
+
+    void init(gpgme_protocol_t proto);
+    gpgme_error_t readToBuffer(gpgme_data_t in, QByteArray* outBuffer) const;
+    void setPassphraseCb();
+    static gpgme_error_t passphraseCb(void *hook, const char *uid_hint,
+                      const char *passphrase_info,
+                      int last_was_bad, int fd);
+    gpgme_error_t passphrase(const char *uid_hint,
+                 const char *passphrase_info,
+                 int last_was_bad, int fd);
+};
+#endif                                  // HAVE_LIBGPGME
+#endif
diff --git a/COPYING b/COPYING
new file mode 100644
index 0000000..94fb846
--- /dev/null
+++ b/COPYING
@@ -0,0 +1,339 @@
+        GNU GENERAL PUBLIC LICENSE
+           Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+          Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Lesser General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+        GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+          NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+         END OF TERMS AND CONDITIONS
+
+      How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.
diff --git a/README b/README
new file mode 100644
index 0000000..764a1de
--- /dev/null
+++ b/README
@@ -0,0 +1,47 @@
+If you have any questions and/or suggestions contact us at [email protected] - or feel free to meet us at [email protected]
+
+Mixing C & C++:
+---------------
+http://developers.sun.com/solaris/articles/mixing.html
+http://www.mrunix.de/forums/showthread.php?t=51595
+
+qt-tutorial:
+------------
+http://doc.trolltech.com/4.4/index.html
+
+Static qt:
+----------
+test for static: ldd appname should result in "not a dynamic executable"
+
+
+http://doc.trolltech.com/4.1/deployment-x11.html
+
+apt-get source libqt4-dev
+
+./configure -no-xrandr -no-xrender -no-fontconfig -no-xinerama -no-glib -no-sm -qt-zlib -static -prefix=//home/ubbo/Desktop/editors/src/qt4-x11-4.4.0
+
+//after recompile with this flags nice layout is gone
+
+/* It's also worth mentioning that Qt will look for certain X11 extensions,
+such as Xinerama and Xrandr, and possibly pull them in, including all
+the libraries that they link against. If you can't guarantee the
+presence of a certain extension, the safest approach is to disable
+it when configuring Qt (e.g. ./configure -no-xrandr). */
+
+
+
+then:
+    make clean
+    PATH=/path/to/Qt/bin:$PATH
+    export PATH
+    qmake -config release
+    make
+
+static libraries:
+http://www.dwheeler.com/program-library/Program-Library-HOWTO/x26.html
+
+http://www.trilithium.com/johan/2005/06/static-libstdc/
+
+
+http://dev.mysql.com/doc/query-browser/en/mysql-gui-install-source-linux-compiling-static.html
+
diff --git a/TODO b/TODO
new file mode 100644
index 0000000..b5ee044
--- /dev/null
+++ b/TODO
@@ -0,0 +1,45 @@
+TODO:
+-----
+
+for release 0.1:
+- translation (learn about qt-tr() )
+- save on quit-bug
+- static-build win (evt. lin).
+- homepage
+- tidy up, source-format (indent)
+- LICENCE.txt
+- README.txt
+
+later:
+- Policy ( Icons von Erros und Warnungen anpassen )
+- Encrypt to self (prob: who is self?)
+
+
+- Keyimport, first: function Keyimport should use QByteArray, then:
+  - More Keymanagement (new popup window?) including:
+    - copy a public-keyfile into the editor-window and enable importing it -> same as "Import Key from Clipboard?"
+    - Import Key from Clipboard
+    - export public key
+    - export private key
+    - generate new key
+    - import keyfiles in non ASCII-Amor-format (always and everywhere error-free keyimport would be great)
+    - Import key from Keyserver
+
+- seen on ubuntu with seahorse daemon running, private password is stored for x minutes (x in system preferences), couse  system-preferenced password_cb function is used (seahorse in that case). not good for gpgOnUsb on not owned computers, so maybe force own password_cb (even if this is not recomended in gpgme_docs)  
+
+- Binary File Attachements, function for Decrypt & Help-Text (like safe eml, etc)
+- Tabbed editor (including useful things like encrypted data opens in new tab)
+
+advanced:
+- thread-safety in context.cpp (in, out, ctx)
+
+For the long shot:
+- ProgrammIcon unter Linux
+- Dateiendung unter Linux anhängen
+
+Already Done:
+rev49: Keylist breiter/schmaler machen koennen, vor allem Mailaddis nicht abschneiden
+rev50: About Dialog
+rev66: bei den Schluesseln anzeigen, ob sie private oder public sind
+(rev? ) - Key löschen
+(rev?) - Laden von Text
diff --git a/bin/gpg b/bin/gpg
new file mode 100755
index 0000000..af65ffb
--- /dev/null
+++ b/bin/gpg
diff --git a/context.cpp b/context.cpp
new file mode 100644
index 0000000..47ebfef
--- /dev/null
+++ b/context.cpp
@@ -0,0 +1,383 @@
+/*
+ *      context.cpp
+ *
+ *      Copyright 2008 gpg4usb-team <[email protected]>
+ *
+ *      This program is free software; you can redistribute it and/or modify
+ *      it under the terms of the GNU General Public License as published by
+ *      the Free Software Foundation; either version 2 of the License, or
+ *      (at your option) any later version.
+ *
+ *      This program is distributed in the hope that it will be useful,
+ *      but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *      GNU General Public License for more details.
+ *
+ *      You should have received a copy of the GNU General Public License
+ *      along with this program; if not, write to the Free Software
+ *      Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ *      MA 02110-1301, USA.
+ */
+
+#include "context.h"
+#include <locale.h>
+#include <sstream>
+#include <QApplication>
+#include <QtGui>
+#include <QMessageBox>
+#include <errno.h>
+
+#ifdef _WIN32
+#include <windows.h>
+#include <unistd.h>    /* contains read/write */
+#endif
+
+
+namespace GpgME {
+
+  /** Constructor
+   *  Set up gpgme-context, set paths to app-run path
+   */
+  Context::Context( ) {
+    /** The function `gpgme_check_version' must be called before any other
+     *  function in the library, because it initializes the thread support
+     *  subsystem in GPGME. (from the info page) */
+    gpgme_check_version (NULL);
+
+    setlocale (LC_ALL, "");
+    /** set locale, because tests do also */
+    gpgme_set_locale (NULL, LC_CTYPE, setlocale (LC_CTYPE, NULL));
+#ifndef _WIN32
+    gpgme_set_locale (NULL, LC_MESSAGES, setlocale (LC_MESSAGES, NULL));
+#endif
+
+    err = gpgme_new ( &m_ctx );
+    checkErr(err);
+   /** here come the settings, instead of /usr/bin/gpg
+    * a executable in the same path as app is used.
+    * also lin/win must  be checked, for calling gpg.exe if needed
+    */
+#ifdef _WIN32
+    err = gpgme_ctx_set_engine_info (m_ctx, GPGME_PROTOCOL_OpenPGP,
+               "bin/gpg.exe", "keydb");
+#else
+    err = gpgme_ctx_set_engine_info (m_ctx, GPGME_PROTOCOL_OpenPGP,
+               "./bin/gpg", "./keydb");
+#endif
+    checkErr(err);
+
+
+    /** Setting the output type must be done at the beginning */
+    /** think this means ascii-amor --> ? */
+    gpgme_set_armor (m_ctx, 1);
+    /** passphrase-callback */
+    gpgme_set_passphrase_cb(m_ctx, passphraseCb, this);
+
+    /** check if app is called with -d from command line */
+    if(qApp->arguments().contains("-d")) {
+      qDebug() << "gpgme_data_t debug on";
+      debug = true;
+    } else {
+      debug = false;
+    }
+
+  }
+
+  /** Destructor
+   *  Release gpgme-context
+   */
+  Context::~Context() {
+    if ( m_ctx ) gpgme_release( m_ctx );
+    m_ctx = 0;
+  }
+
+  /** Import Key from QByteArray
+   *  
+   */
+  void Context::importKey(QByteArray inBuffer) {
+  	err = gpgme_data_new_from_mem (&in, inBuffer.data(), inBuffer.size(), 1);
+  	checkErr(err);
+    err = gpgme_op_import (m_ctx, in);
+    checkErr(err);
+    gpgme_data_release (in);
+  }
+
+  /** List all availabe Keys (VERY much like kgpgme)
+   */
+  GpgKeyList Context::listKeys() {
+    gpgme_error_t err;
+    gpgme_key_t key;
+
+    GpgKeyList keys;
+    //TODO dont run the loop more often than necessary
+    // list all keys ( the 0 is for all )
+    err = gpgme_op_keylist_start (m_ctx, NULL, 0);
+    checkErr(err);
+    while (!(err = gpgme_op_keylist_next (m_ctx, &key))) {
+      GpgKey gpgkey;
+
+      if(!key->subkeys)
+        continue;
+
+      gpgkey.id = key->subkeys->keyid;
+
+      if(key->uids) {
+        gpgkey.name = key->uids->name;
+        gpgkey.email = key->uids->email;
+      }
+      keys.append(gpgkey);
+      gpgme_key_unref(key);
+    }
+    gpgme_op_keylist_end(m_ctx);
+
+    // list only private keys ( the 1 does )
+    gpgme_op_keylist_start (m_ctx, NULL, 1);
+    while (!(err = gpgme_op_keylist_next (m_ctx, &key))) {
+       if(!key->subkeys)
+         continue;
+      // iterate keys, mark privates
+      GpgKeyList::iterator it = keys.begin();
+      while (it != keys.end()) {
+        if(key->subkeys->keyid == it->id.toStdString())
+            it->privkey = 1;
+        it++;
+      }
+
+      gpgme_key_unref(key);
+    }
+    gpgme_op_keylist_end(m_ctx);
+
+    return keys;
+  }
+
+  /** Delete keys
+   */
+
+  void Context::deleteKeys(QList<QString> *uidList) {
+
+    QString tmp;
+    gpgme_key_t key;
+
+    foreach( tmp,  *uidList ) {
+      gpgme_op_keylist_start(m_ctx, tmp.toAscii().constData(), 0);
+      gpgme_op_keylist_next(m_ctx, &key);
+      gpgme_op_keylist_end(m_ctx);
+      gpgme_op_delete(m_ctx, key, 1);
+    }
+  }
+
+  /** Encrypt String, return String
+   *  should also use QByteArray, so be removed
+   *  in should be std::vector<key> & recipients (703 in context.cpp)
+   */
+  bool Context::encrypt(QList<QString> *uidList, const QByteArray& inBuffer, QByteArray* outBuffer){
+
+    gpgme_data_t in = 0, out = 0;
+    outBuffer->resize(0);
+
+    if(uidList->count()==0) {
+      QMessageBox::critical(0, "No Key Selected", "No Key Selected");
+      return false;
+    }
+
+    //gpgme_encrypt_result_t e_result;
+    gpgme_key_t recipients[uidList->count()+1];
+
+    /* get key for user */
+    for (int i = 0; i < uidList->count(); i++) {
+      // the last 0 is for public keys, 1 would return private keys
+      gpgme_op_keylist_start(m_ctx, uidList->at(i).toAscii().constData(), 0);
+      gpgme_op_keylist_next(m_ctx, &recipients[i]);
+      gpgme_op_keylist_end(m_ctx);
+    }
+    //Last entry in array has to be NULL
+    recipients[uidList->count()] = NULL;
+
+  //If the last parameter isnt 0, a private copy of data is made
+    err = gpgme_data_new_from_mem (&in, inBuffer.data(), inBuffer.size(), 1);
+    checkErr(err);
+    err = gpgme_data_new (&out);
+    checkErr(err);
+
+    err = gpgme_op_encrypt (m_ctx, recipients, GPGME_ENCRYPT_ALWAYS_TRUST, in, out);
+    checkErr(err);
+
+  	err = readToBuffer(out, outBuffer);
+  	checkErr(err);
+
+  	/* unref all keys */
+  	for (int i = 0; i <= uidList->count(); i++) {
+  	    gpgme_key_unref (recipients[i]);
+  	}
+    gpgme_data_release (in);
+    gpgme_data_release (out);
+
+    return true;
+  }
+
+  /** Decrypt QByteAarray, return QByteArray
+   *  from http://basket.kde.org/ (kgpgme.cpp)
+   */
+  bool Context::decrypt(const QByteArray& inBuffer, QByteArray* outBuffer)
+  {
+    gpgme_data_t in = 0, out = 0;
+    gpgme_decrypt_result_t result = 0;
+
+    outBuffer->resize(0);
+    if(m_ctx) {
+      err = gpgme_data_new_from_mem(&in, inBuffer.data(), inBuffer.size(), 1);
+      checkErr(err);
+      if(!err) {
+        err = gpgme_data_new(&out);
+        checkErr(err);
+        if(!err) {
+          err = gpgme_op_decrypt(m_ctx, in, out);
+          checkErr(err);
+          if(!err) {
+            result = gpgme_op_decrypt_result(m_ctx);
+            if(result->unsupported_algorithm) {
+                 QMessageBox::critical(0,"Unsupported algorithm", result->unsupported_algorithm);
+            }
+            else {
+             err = readToBuffer(out, outBuffer);
+             checkErr(err);
+            }
+         }
+        }
+      }
+    }
+    if(err != GPG_ERR_NO_ERROR && err != GPG_ERR_CANCELED) {
+      QMessageBox::critical(0, "Error encrypting:", gpgme_strerror(err));
+    }
+    if(err != GPG_ERR_NO_ERROR)
+      clearCache();
+    if(in)
+      gpgme_data_release(in);
+    if(out)
+      gpgme_data_release(out);
+    return (err == GPG_ERR_NO_ERROR);
+  }
+
+  /**  Read gpgme-Data to QByteArray
+   *   mainly from http://basket.kde.org/ (kgpgme.cpp)
+   *  maybe const ?
+   */
+  #define BUF_SIZE (32 * 1024)
+  gpgme_error_t Context::readToBuffer(gpgme_data_t in, QByteArray* outBuffer) 
+  {
+    int ret;
+    gpgme_error_t err = GPG_ERR_NO_ERROR;
+
+    ret = gpgme_data_seek(in, 0, SEEK_SET);
+    if(ret) {
+      err = gpgme_err_code_from_errno(errno);
+      checkErr(err, "failed dataseek in readToBuffer");
+     } else {
+      char *buf = new char[BUF_SIZE + 2];
+
+      if(buf) {
+        while((ret = gpgme_data_read(in, buf, BUF_SIZE)) > 0) {
+          uint size = outBuffer->size();
+          outBuffer->resize(size + ret);
+          memcpy(outBuffer->data() + size, buf, ret);
+        }
+        if(ret < 0) {
+          err = gpgme_err_code_from_errno(errno);
+          checkErr(err, "failed data_read in readToBuffer");
+        }
+        delete[] buf;
+      }
+    }
+    return err;
+  }
+
+  /** The Passphrase window, if not provided by env-Var GPG_AGENT_INFO
+   *  Copied from http://basket.kde.org/ (kgpgme.cpp)
+   */
+  gpgme_error_t Context::passphraseCb(void* hook, const char* uid_hint,
+                   const char* passphrase_info,
+                   int last_was_bad, int fd)
+  {
+    Context* gpg = static_cast<Context*>(hook);
+    return gpg->passphrase(uid_hint, passphrase_info, last_was_bad, fd);
+  }
+
+  gpgme_error_t Context::passphrase(const char* uid_hint,
+                   const char* /*passphrase_info*/,
+                   int last_was_bad, int fd)
+  {
+    gpgme_error_t res = GPG_ERR_CANCELED;
+    QString s;
+    QString gpg_hint = uid_hint;
+    bool result;
+
+    if(last_was_bad){
+      s += "<i>Wrong password.</i><br><br>\n\n";
+      clearCache();
+    }
+
+    /** if uid provided */
+    if(!gpg_hint.isEmpty()) {
+       // remove UID, leave only username & email
+       gpg_hint.remove(0, gpg_hint.indexOf(" "));
+       s += "<b>Enter Password for</b><br>\n" + gpg_hint + "\n";
+    }
+
+    if(m_cache.isEmpty()){
+      QString password = QInputDialog::getText(0, "Enter Password",
+                                          s, QLineEdit::Password,
+                                          "", &result);
+
+      if(result == 1) m_cache = password.toAscii();
+    }
+    else
+      result = 0;
+
+    if(result == 1) {
+#ifndef _WIN32
+      write(fd, m_cache.data(), m_cache.length());
+#else
+      DWORD written;
+      WriteFile ((HANDLE) fd, m_cache.data(), m_cache.length(), &written, 0);
+#endif
+      res = 0;
+    }
+#ifndef _WIN32
+    write(fd, "\n", 1);
+#else
+    DWORD written;
+    WriteFile ((HANDLE) fd, "\n", 1, &written, 0);
+#endif
+
+    return res;
+  }
+
+  /** also from kgpgme.cpp, seems to clear password from mem */
+  void Context::clearCache()
+  {
+    if(m_cache.size() > 0)
+    {
+     m_cache.fill('\0');
+     m_cache.truncate(0);
+    }
+  }
+
+  // error-handling
+  void Context::checkErr(gpgme_error_t err, QString comment) const {
+    if(err != GPG_ERR_NO_ERROR && err != GPG_ERR_CANCELED) {
+      qDebug() << "[Error " << comment << "] Source: " << gpgme_strsource(err) << " String: " << gpgme_strerror(err);
+    }
+  }
+
+  void Context::checkErr(gpgme_error_t err) const {
+    if(err != GPG_ERR_NO_ERROR && err != GPG_ERR_CANCELED) {
+      qDebug() << "[Error] Source: " << gpgme_strsource(err) << " String: " << gpgme_strerror(err);
+    }
+  }
+
+}
+
+
+
+
+
diff --git a/context.h b/context.h
new file mode 100644
index 0000000..101ae1e
--- /dev/null
+++ b/context.h
@@ -0,0 +1,79 @@
+/*
+ *      context.h
+ *
+ *      Copyright 2008 gpg4usb-team <[email protected]>
+ *
+ *      This program is free software; you can redistribute it and/or modify
+ *      it under the terms of the GNU General Public License as published by
+ *      the Free Software Foundation; either version 2 of the License, or
+ *      (at your option) any later version.
+ *
+ *      This program is distributed in the hope that it will be useful,
+ *      but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *      GNU General Public License for more details.
+ *
+ *      You should have received a copy of the GNU General Public License
+ *      along with this program; if not, write to the Free Software
+ *      Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ *      MA 02110-1301, USA.
+ */
+
+#ifndef __SGPGMEPP_CONTEXT_H__
+#define __SGPGMEPP_CONTEXT_H__
+
+#include <gpgme.h>
+#include <QByteArray>
+#include <QString>
+#include <QLinkedList>
+
+class GpgKey
+{
+  public:
+    QString id;
+    QString name;
+    QString email;
+    int privkey;
+    //bool privkey;
+};
+
+typedef QLinkedList< GpgKey > GpgKeyList;
+
+namespace GpgME {
+
+  class Context {
+
+  public:
+    Context(); // Consttructor
+    ~Context(); // Destructor
+
+    void importKeyFromFile(QString pathToFile);
+    void importKey(QByteArray inBuffer);
+    GpgKeyList listKeys();
+    void deleteKeys(QList<QString> *uidList);
+    bool encrypt(QList<QString> *uidList, const QByteArray& inBuffer, QByteArray* outBuffer);
+
+    bool decrypt(const QByteArray& inBuffer, QByteArray* outBuffer);
+    void clearCache();
+
+  private:
+    gpgme_ctx_t m_ctx;
+    gpgme_data_t in, out;
+    gpgme_error_t err;
+    gpgme_error_t readToBuffer(gpgme_data_t in, QByteArray* outBuffer);
+    QByteArray m_cache;
+    bool debug;
+    void checkErr(gpgme_error_t err) const;
+    void checkErr(gpgme_error_t err, QString comment) const;
+
+    static gpgme_error_t passphraseCb(void *hook, const char *uid_hint,
+                      const char *passphrase_info,
+                      int last_was_bad, int fd);
+    gpgme_error_t passphrase(const char *uid_hint,
+                 const char *passphrase_info,
+                 int last_was_bad, int fd);
+
+  };
+} // namespace GpgME
+
+#endif // __SGPGMEPP_CONTEXT_H__
diff --git a/gpg4usblib.ico b/gpg4usblib.ico
new file mode 100644
index 0000000..51c9b00
--- /dev/null
+++ b/gpg4usblib.ico
diff --git a/gpg4usblib.pro b/gpg4usblib.pro
new file mode 100644
index 0000000..627c5b6
--- /dev/null
+++ b/gpg4usblib.pro
@@ -0,0 +1,22 @@
+######################################################################
+# Automatically generated by qmake (2.01a) Mi Mai 21 02:28:39 2008
+######################################################################
+
+TEMPLATE = app
+TARGET =
+DEPENDPATH += .
+INCLUDEPATH += .
+
+# Input
+HEADERS += context.h gpgwin.h keylist.h
+SOURCES += context.cpp gpgwin.cpp main.cpp keylist.cpp
+RC_FILE = gpg4usblib.rc
+# For Static build on Linux: uncomment line below
+#LIBS += lib/libgpgme.a -static-libgcc -Llib
+#LIBS += lib/libgpgme.a
+LIBS += -lgpgme -lgpg-error
+#LIBS += lib/libgpgme.a -Llib
+DEFINES += _FILE_OFFSET_BITS=64
+
+TRANSLATIONS = ts/gpg4usblib_en.ts \
+			   ts/gpg4usblib_de.ts
diff --git a/gpg4usblib.rc b/gpg4usblib.rc
new file mode 100644
index 0000000..b61cda6
--- /dev/null
+++ b/gpg4usblib.rc
@@ -0,0 +1 @@
+IDI_ICON1               ICON    DISCARDABLE     "gpg4usblib.ico"

diff --git a/gpgwin.cpp b/gpgwin.cpp
new file mode 100644
index 0000000..f321616
--- /dev/null
+++ b/gpgwin.cpp
@@ -0,0 +1,404 @@
+/*
+ *      gpgwin.cpp
+ *
+ *      Copyright 2008 gpg4usb-team <[email protected]>
+ *
+ *      This program is free software; you can redistribute it and/or modify
+ *      it under the terms of the GNU General Public License as published by
+ *      the Free Software Foundation; either version 2 of the License, or
+ *      (at your option) any later version.
+ *
+ *      This program is distributed in the hope that it will be useful,
+ *      but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *      GNU General Public License for more details.
+ *
+ *      You should have received a copy of the GNU General Public License
+ *      along with this program; if not, write to the Free Software
+ *      Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ *      MA 02110-1301, USA.
+ */
+#include <QApplication>
+#include <QMainWindow>
+#include <QPlainTextEdit>
+#include <QWidget>
+#include <QVBoxLayout>
+#include <QGridLayout>
+#include <iostream>
+#include <QtGui>
+#include <QString>
+#include <QFileDialog>
+#include <QStringList>
+#include <QIcon>
+#include <QMessageBox>
+
+#include "context.h"
+#include "gpgwin.h"
+
+
+ GpgWin::GpgWin()
+ {
+     myCtx = new GpgME::Context();
+
+     edit = new QPlainTextEdit();
+     setCentralWidget(edit);
+
+     /* the list of Keys available*/
+     m_keyList = new KeyList();
+     m_keyList->setContext(myCtx);
+
+     createActions();
+     createMenus();
+     createToolBars();
+     createStatusBar();
+     createDockWindows();
+
+     setToolButtonStyle(Qt::ToolButtonTextUnderIcon);
+     setIconSize(QSize(32, 32));
+     setCurrentFile("");
+
+}
+
+void GpgWin::createActions()
+ {
+    /** Main Menu
+      */
+     openAct = new QAction(tr("&Open..."), this);
+     openAct->setIcon(QIcon("icons/fileopen.png"));
+     openAct->setShortcut(tr("Ctrl+O"));
+     openAct->setStatusTip(tr("Open an existing file"));
+     connect(openAct, SIGNAL(triggered()), this, SLOT(open()));
+
+     saveAct = new QAction(tr("&Save"), this);
+     saveAct->setIcon(QIcon("icons/filesave.png"));
+     saveAct->setShortcut(tr("Ctrl+S"));
+     saveAct->setStatusTip(tr("Save the current File"));
+     connect(saveAct, SIGNAL(triggered()), this, SLOT(save()));
+
+     saveAsAct = new QAction(tr("Save &As"), this);
+     saveAsAct->setIcon(QIcon("icons/filesaveas.png"));
+     saveAsAct->setShortcut(tr("Ctrl+A"));
+     saveAsAct->setStatusTip(tr("Save the current File as..."));
+     connect(saveAsAct, SIGNAL(triggered()), this, SLOT(saveAs()));
+
+     printAct = new QAction(tr("&Print"), this);
+     printAct->setIcon(QIcon("icons/fileprint.png"));
+     printAct->setShortcut(tr("Ctrl+P"));
+     printAct->setStatusTip(tr("Print Document"));
+     connect(printAct, SIGNAL(triggered()), this, SLOT(print()));
+
+     quitAct = new QAction(tr("&Quit"), this);
+     quitAct->setShortcut(tr("Ctrl+Q"));
+     quitAct->setIcon(QIcon("icons/exit.png"));
+     quitAct->setStatusTip(tr("Quit Program"));
+     connect(quitAct, SIGNAL(triggered()), this, SLOT(quit()));
+
+     /** Edit Menu
+      */
+     pasteAct = new QAction(tr("&Paste"), this);
+     pasteAct->setIcon(QIcon("icons/button_paste.png"));
+     pasteAct->setShortcut(tr("Ctrl+V"));
+     pasteAct->setStatusTip(tr("Paste Text From Clipboard"));
+     connect(pasteAct, SIGNAL(triggered()), edit, SLOT(paste()));
+
+     cutAct = new QAction(tr("Cu&t"), this);
+     cutAct->setIcon(QIcon("icons/button_cut.png"));
+     cutAct->setShortcut(tr("Ctrl+X"));
+     cutAct->setStatusTip(tr("Cut the current selection's contents to the "
+                             "clipboard"));
+     connect(cutAct, SIGNAL(triggered()), edit, SLOT(cut()));
+
+     copyAct = new QAction(tr("&Copy"), this);
+     copyAct->setIcon(QIcon("icons/button_copy.png"));
+     copyAct->setShortcut(tr("Ctrl+C"));
+     copyAct->setStatusTip(tr("Copy the current selection's contents to the "
+                              "clipboard"));
+     connect(copyAct, SIGNAL(triggered()), edit, SLOT(copy()));
+
+     selectallAct = new QAction(tr("Select &All"), this);
+     selectallAct->setIcon(QIcon("icons/edit.png"));
+     selectallAct->setShortcut(tr("Ctrl+A"));
+     selectallAct->setStatusTip(tr("Select the whole text"));
+     connect(selectallAct, SIGNAL(triggered()), edit, SLOT(selectAll()));
+
+     /** Crypt Menu
+      */
+     encryptAct = new QAction(tr("&Encrypt"), this);
+     encryptAct->setIcon(QIcon("icons/encrypted.png"));
+     encryptAct->setShortcut(tr("Ctrl+E"));
+     encryptAct->setStatusTip(tr("Encrypt Message"));
+     connect(encryptAct, SIGNAL(triggered()), this, SLOT(encrypt()));
+
+     decryptAct = new QAction(tr("&Decrypt"), this);
+     decryptAct->setIcon(QIcon("icons/decrypted.png"));
+     decryptAct->setShortcut(tr("Ctrl+D"));
+     decryptAct->setStatusTip(tr("Decrypt Message"));
+     connect(decryptAct, SIGNAL(triggered()), this, SLOT(decrypt()));
+
+     importKeyFromFileAct = new QAction(tr("&Import Key From File"), this);
+     importKeyFromFileAct->setIcon(QIcon("icons/kgpg_import.png"));
+     importKeyFromFileAct->setShortcut(tr("Ctrl+I"));
+     importKeyFromFileAct->setStatusTip(tr("Import New Key From File"));
+     connect(importKeyFromFileAct, SIGNAL(triggered()), this, SLOT(importKeyFromFile()));
+     
+     importKeyFromEditAct = new QAction(tr("Import Key From &Editor"), this);
+     importKeyFromEditAct->setIcon(QIcon("icons/importkey_editor.png"));
+     importKeyFromEditAct->setStatusTip(tr("Import New Key From Editor"));
+     connect(importKeyFromEditAct, SIGNAL(triggered()), this, SLOT(importKeyFromEdit()));     
+
+     /** About Menu
+      */
+     aboutAct = new QAction(tr("&About"), this);
+     aboutAct->setIcon(QIcon("icons/help.png"));
+     aboutAct->setStatusTip(tr("Show the application's About box"));
+     connect(aboutAct, SIGNAL(triggered()), this, SLOT(about()));
+}
+
+void GpgWin::createMenus()
+ {
+     fileMenu = menuBar()->addMenu(tr("&File"));
+     fileMenu->addAction(openAct);
+     fileMenu->addAction(saveAct);
+     fileMenu->addAction(saveAsAct);
+     fileMenu->addAction(printAct);
+     fileMenu->addSeparator();
+     fileMenu->addAction(quitAct);
+
+     fileMenu = menuBar()->addMenu(tr("&Edit"));
+     fileMenu->addAction(copyAct);
+     fileMenu->addAction(cutAct);
+     fileMenu->addAction(pasteAct);
+     fileMenu->addAction(selectallAct);
+
+     fileMenu = menuBar()->addMenu(tr("&Crypt"));
+     fileMenu->addAction(encryptAct);
+     fileMenu->addAction(decryptAct);
+     fileMenu->addSeparator();
+     fileMenu->addAction(importKeyFromFileAct);
+     fileMenu->addAction(importKeyFromEditAct);
+     
+     fileMenu = menuBar()->addMenu(tr("&Help"));
+     fileMenu->addAction(aboutAct);
+}
+
+void GpgWin::createToolBars()
+ {
+     fileToolBar = addToolBar(tr("File"));
+     fileToolBar->addAction(encryptAct);
+     fileToolBar->addAction(decryptAct);
+
+     editToolBar = addToolBar(tr("Edit"));
+     editToolBar->addAction(copyAct);
+     editToolBar->addAction(pasteAct);
+     editToolBar->addAction(selectallAct);
+}
+
+ void GpgWin::createStatusBar()
+ {
+     statusBar()->showMessage(tr("Ready"));
+ }
+
+void GpgWin::createDockWindows()
+{
+     QDockWidget *dock = new QDockWidget(tr("Encrypt for:"), this);
+     dock->setAllowedAreas(Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea);
+     addDockWidget(Qt::RightDockWidgetArea, dock);
+     dock->setWidget(m_keyList);
+}
+
+ void GpgWin::closeEvent(QCloseEvent *event)
+ {
+     if (maybeSave()) {
+         event->accept();
+     } else {
+         event->ignore();
+     }
+ }
+
+ void GpgWin::open()
+{
+  if (maybeSave()) {
+       QString fileName = QFileDialog::getOpenFileName(this);
+      if (!fileName.isEmpty())
+          loadFile(fileName);
+     }
+}
+
+void GpgWin::quit()
+{
+	 if (maybeSave()) {
+	 	save();
+	 }
+}
+
+
+ bool GpgWin::save()
+ {
+     if (curFile.isEmpty()) {
+         return saveAs();
+     } else {
+         return saveFile(curFile);
+     }
+ }
+
+ bool GpgWin::saveAs()
+ {
+     QString fileName = QFileDialog::getSaveFileName(this);
+     if (fileName.isEmpty())
+         return false;
+
+     return saveFile(fileName);
+ }
+
+ void GpgWin::loadFile(const QString &fileName)
+ {
+     QFile file(fileName);
+     if (!file.open(QFile::ReadOnly | QFile::Text)) {
+         QMessageBox::warning(this, tr("Application"),
+                              tr("Cannot read file %1:\n%2.")
+                              .arg(fileName)
+                              .arg(file.errorString()));
+         return;
+     }
+
+     QTextStream in(&file);
+     QApplication::setOverrideCursor(Qt::WaitCursor);
+     edit->setPlainText(in.readAll());
+     QApplication::restoreOverrideCursor();
+
+     setCurrentFile(fileName);
+     statusBar()->showMessage(tr("File loaded"), 2000);
+ }
+
+  void GpgWin::setCurrentFile(const QString &fileName)
+ {
+     curFile = fileName;
+     edit->document()->setModified(false);
+     setWindowModified(false);
+
+     QString shownName;
+     if (curFile.isEmpty())
+         shownName = tr("untitled.txt");
+     else
+         shownName = strippedName(curFile);
+
+     setWindowTitle(tr("%1[*] - %2").arg(shownName).arg(tr("gpg4usb")));
+ }
+
+ QString GpgWin::strippedName(const QString &fullFileName)
+ {
+     return QFileInfo(fullFileName).fileName();
+ }
+
+ bool GpgWin::maybeSave()
+ {
+     if (edit->document()->isModified()) {
+         QMessageBox::StandardButton ret;
+         ret = QMessageBox::warning(this, tr("Application"),
+                      tr("The document has been modified.\nDo you want to save your changes?"),
+                      QMessageBox::Save | QMessageBox::Discard | QMessageBox::Cancel);
+         if (ret == QMessageBox::Save)
+             return save();
+         else if (ret == QMessageBox::Cancel)
+             return false;
+     }
+     return true;
+ }
+
+bool GpgWin::saveFile(const QString &fileName)
+ {
+     /*QString fileName = QFileDialog::getSaveFileName(this,
+                         tr("Choose a file name"), ".",
+                         tr("Text (*.txt)","All (*)"));
+     if (fileName.isEmpty())
+         return false;*/
+     QFile file(fileName);
+     if (!file.open(QFile::WriteOnly | QFile::Text)) {
+         QMessageBox::warning(this, tr("File"),
+                              tr("Cannot write file %1:\n%2.")
+                              .arg(fileName)
+                              .arg(file.errorString()));
+         return false;
+     }
+     QTextStream out(&file);
+     QApplication::setOverrideCursor(Qt::WaitCursor);
+     out << edit->toPlainText();
+     QApplication::restoreOverrideCursor();
+     statusBar()->showMessage(tr("Saved '%1'").arg(fileName), 2000);
+     return true;
+ }
+
+void GpgWin::print(){
+ #ifndef QT_NO_PRINTER
+     QTextDocument *document = edit->document();
+     QPrinter printer;
+
+     QPrintDialog *dlg = new QPrintDialog(&printer, this);
+     if (dlg->exec() != QDialog::Accepted)
+         return;
+
+     document->print(&printer);
+
+     statusBar()->showMessage(tr("Ready"), 2000);
+ #endif
+ }
+
+void GpgWin::about(){
+    QMessageBox::about(this, tr("About gpg4usb"),
+             tr("<center>This Application allows you to do simple<br>"
+                "encryption/decryption of your text-files.<br>"
+                "It's licensed under the GPL v2.0<br><br>"
+                "<b>Developer:</b><br>"
+    "Bene, Heimer, Juergen, Nils, Ubbo<br><br>"
+                "If you have any questions and/or<br>"
+                "suggestions, contact us at<br>"
+                "gpg4usb at cpunk.de</a><br><br>"
+                "or feel free to meet us in our channel at<br>"
+                "gpg4usb at conference.jabber.ccc.de<br><br>"
+                "and always remember:<br>"
+                "cpunk is NOT a bot...</center>"));
+ }
+
+  void GpgWin::encrypt(){
+    QList<QString> *uidList = m_keyList->getChecked();
+
+    QByteArray *tmp = new QByteArray();
+    if ( myCtx->encrypt(uidList, edit->toPlainText().toAscii(), tmp) ) {
+      QString *tmp2 = new QString(*tmp);
+      edit->setPlainText(*tmp2);
+    }
+
+ }
+
+   void GpgWin::decrypt(){
+    QByteArray *tmp = new QByteArray();
+    myCtx->decrypt(edit->toPlainText().toAscii(), tmp);
+    if(!tmp->isEmpty()){
+      QString *tmp2 = new QString(*tmp);
+      edit->setPlainText(*tmp2);
+    }
+ }
+ 
+  void GpgWin::importKeyFromEdit(){
+    myCtx->importKey(edit->toPlainText().toAscii());
+    m_keyList->refresh();    
+ }
+
+
+  void GpgWin::importKeyFromFile(){
+  QString fileName = QFileDialog::getOpenFileName(this,tr("Open Key"),"", tr("Key Files")+" (*.asc *.txt);;All Files (*.*)");
+  if (! fileName.isNull()) {
+
+	QFile file;
+	file.setFileName(fileName);
+	if (!file.open(QIODevice::ReadOnly))
+	{
+		qDebug() << tr("couldn't open file: ")+fileName;
+	}
+	QByteArray inBuffer = file.readAll();
+        
+    myCtx->importKey(inBuffer);
+    m_keyList->refresh();
+  }
+}
+
diff --git a/gpgwin.h b/gpgwin.h
new file mode 100644
index 0000000..ae49a00
--- /dev/null
+++ b/gpgwin.h
@@ -0,0 +1,87 @@
+/*
+ *      gpgwin.h
+ *
+ *      Copyright 2008 gpg4usb-team <[email protected]>
+ *
+ *      This program is free software; you can redistribute it and/or modify
+ *      it under the terms of the GNU General Public License as published by
+ *      the Free Software Foundation; either version 2 of the License, or
+ *      (at your option) any later version.
+ *
+ *      This program is distributed in the hope that it will be useful,
+ *      but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *      GNU General Public License for more details.
+ *
+ *      You should have received a copy of the GNU General Public License
+ *      along with this program; if not, write to the Free Software
+ *      Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ *      MA 02110-1301, USA.
+ */
+#include <QWidget>
+#include <QMainWindow>
+#include <QtGui>
+#include "context.h"
+#include "keylist.h"
+
+class QAction;
+class QMenu;
+class QPlainTextEdit;
+
+class GpgWin : public QMainWindow
+ {
+   Q_OBJECT
+
+ public:
+     GpgWin();
+
+ protected:
+     void closeEvent(QCloseEvent *event);
+
+ public slots:
+     void encrypt();
+     void decrypt();
+     void importKeyFromFile();
+     void importKeyFromEdit();
+     void print();
+     void about();
+     bool save();
+     bool saveAs();
+     void open();
+     void quit();
+
+ private:
+   void createActions();	
+   void createMenus();
+   void createToolBars();   
+   void createStatusBar();
+   void createDockWindows();
+   bool saveFile(const QString &fileName);
+   void loadFile(const QString &fileName);
+   void setCurrentFile(const QString &fileName);
+   bool maybeSave();
+   QString strippedName(const QString &fullFileName);
+   
+   QPlainTextEdit *edit;
+   QMenu *fileMenu;
+   QToolBar *fileToolBar;
+   QToolBar *editToolBar;
+   QAction *openAct;
+   QAction *saveAct;
+   QAction *saveAsAct;
+   QAction *printAct;
+   QAction *quitAct;
+   QAction *encryptAct;
+   QAction *decryptAct;
+   QAction *importKeyFromFileAct;
+   QAction *importKeyFromEditAct;
+   QAction *copyAct;
+   QAction *cutAct;
+   QAction *pasteAct;
+   QAction *selectallAct;
+   QAction *aboutAct;
+
+   QString curFile;
+   KeyList *m_keyList;
+   GpgME::Context *myCtx;
+ };
diff --git a/icons/button_cancel.png b/icons/button_cancel.png
new file mode 100644
index 0000000..75980de
--- /dev/null
+++ b/icons/button_cancel.png
diff --git a/icons/button_copy.png b/icons/button_copy.png
new file mode 100644
index 0000000..a04d2f7
--- /dev/null
+++ b/icons/button_copy.png
diff --git a/icons/button_cut.png b/icons/button_cut.png
new file mode 100644
index 0000000..57c4711
--- /dev/null
+++ b/icons/button_cut.png
diff --git a/icons/button_ok.png b/icons/button_ok.png
new file mode 100644
index 0000000..94aac4b
--- /dev/null
+++ b/icons/button_ok.png
diff --git a/icons/button_paste.png b/icons/button_paste.png
new file mode 100644
index 0000000..099c51f
--- /dev/null
+++ b/icons/button_paste.png
diff --git a/icons/configure.png b/icons/configure.png
new file mode 100644
index 0000000..2bf463b
--- /dev/null
+++ b/icons/configure.png
diff --git a/icons/decrypted.png b/icons/decrypted.png
new file mode 100644
index 0000000..2b49969
--- /dev/null
+++ b/icons/decrypted.png
diff --git a/icons/edit.png b/icons/edit.png
new file mode 100644
index 0000000..bee2645
--- /dev/null
+++ b/icons/edit.png
diff --git a/icons/encrypted.png b/icons/encrypted.png
new file mode 100644
index 0000000..4ae41ee
--- /dev/null
+++ b/icons/encrypted.png
diff --git a/icons/exit.png b/icons/exit.png
new file mode 100644
index 0000000..08e97b4
--- /dev/null
+++ b/icons/exit.png
diff --git a/icons/fileopen.png b/icons/fileopen.png
new file mode 100644
index 0000000..7341929
--- /dev/null
+++ b/icons/fileopen.png
diff --git a/icons/fileprint.png b/icons/fileprint.png
new file mode 100644
index 0000000..05e1598
--- /dev/null
+++ b/icons/fileprint.png
diff --git a/icons/filesave.png b/icons/filesave.png
new file mode 100644
index 0000000..0006ad4
--- /dev/null
+++ b/icons/filesave.png
diff --git a/icons/filesaveas.png b/icons/filesaveas.png
new file mode 100644
index 0000000..2be6df2
--- /dev/null
+++ b/icons/filesaveas.png
diff --git a/icons/help.png b/icons/help.png
new file mode 100644
index 0000000..915f9fd
--- /dev/null
+++ b/icons/help.png
diff --git a/icons/importkey_editor.png b/icons/importkey_editor.png
new file mode 100644
index 0000000..4fa7e01
--- /dev/null
+++ b/icons/importkey_editor.png
diff --git a/icons/kgpg_export.png b/icons/kgpg_export.png
new file mode 100644
index 0000000..ba72a3d
--- /dev/null
+++ b/icons/kgpg_export.png
diff --git a/icons/kgpg_import.png b/icons/kgpg_import.png
new file mode 100644
index 0000000..0226c2f
--- /dev/null
+++ b/icons/kgpg_import.png
diff --git a/icons/kgpg_key2.png b/icons/kgpg_key2.png
new file mode 100644
index 0000000..43e5a52
--- /dev/null
+++ b/icons/kgpg_key2.png
diff --git a/icons/undo.png b/icons/undo.png
new file mode 100644
index 0000000..5cbf37d
--- /dev/null
+++ b/icons/undo.png
diff --git a/keylist.cpp b/keylist.cpp
new file mode 100644
index 0000000..28e1376
--- /dev/null
+++ b/keylist.cpp
@@ -0,0 +1,119 @@
+
+#include <QWidget>
+#include <QVBoxLayout>
+#include <QListWidgetItem>
+/*
+ *      keylist.cpp
+ *
+ *      Copyright 2008 gpg4usb-team <[email protected]>
+ *
+ *      This program is free software; you can redistribute it and/or modify
+ *      it under the terms of the GNU General Public License as published by
+ *      the Free Software Foundation; either version 2 of the License, or
+ *      (at your option) any later version.
+ *
+ *      This program is distributed in the hope that it will be useful,
+ *      but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *      GNU General Public License for more details.
+ *
+ *      You should have received a copy of the GNU General Public License
+ *      along with this program; if not, write to the Free Software
+ *      Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ *      MA 02110-1301, USA.
+ */
+#include <QLabel>
+#include <QMessageBox>
+#include <QtGui>
+#include "keylist.h"
+
+KeyList::KeyList(QWidget *parent)
+    : QWidget(parent)
+{
+    m_keyList = new QListWidget();
+    m_idList = new QList<QString>();
+    m_deleteButton = new QPushButton(tr("Delete Selected Keys"));
+
+    connect(m_deleteButton, SIGNAL(clicked()), this, SLOT( deleteKeys() ) );
+
+    QVBoxLayout *layout = new QVBoxLayout;
+    layout->addWidget(m_keyList);
+    layout->addWidget(m_deleteButton);
+    setLayout(layout);
+    createActions();
+
+}
+
+void KeyList::setContext(GpgME::Context *ctx) {
+  m_ctx = ctx;
+  refresh();
+}
+
+void KeyList::contextMenuEvent(QContextMenuEvent *event)
+{
+     QMenu menu(this);
+     menu.addAction(deleteKeyAct);
+     menu.exec(event->globalPos());
+}
+
+void KeyList::refresh() {
+  m_keyList->clear();
+  m_idList->clear();
+
+  GpgKeyList keys = m_ctx->listKeys();
+  GpgKeyList::iterator it = keys.begin();
+  while (it != keys.end()) {
+    QListWidgetItem *tmp = new QListWidgetItem(
+            it->name + " <" + it->email +">"
+    );
+    tmp->setFlags( Qt::ItemIsUserCheckable | Qt::ItemIsEnabled | Qt::ItemIsSelectable );
+    tmp->setCheckState( Qt::Unchecked );
+    if(it->privkey == 1)  tmp->setIcon(QIcon("icons/kgpg_key2.png"));
+    m_keyList->addItem(tmp);
+
+    *m_idList << QString(it->id);
+    it++;
+  }
+}
+
+
+QList<QString>* KeyList::getChecked() {
+  QList<QString> *ret = new QList<QString>();
+  for (int i = 0; i < m_keyList->count(); i++) {
+    if (m_keyList->item(i)->checkState() == Qt::Checked) {
+      *ret << m_idList->at(i);
+    }
+  }
+  return ret;
+}
+
+QList<QString>* KeyList::getSelected() {
+  QList<QString> *ret = new QList<QString>();
+  for (int i = 0; i < m_keyList->count(); i++) {
+    if (m_keyList->item(i)->isSelected() == 1) {
+      *ret << m_idList->at(i);
+    }
+  }
+  return ret;
+}
+
+void KeyList::deleteKeys() {
+
+  m_ctx->deleteKeys(getChecked());
+  refresh();
+
+}
+
+void KeyList::deleteKey() {
+
+  m_ctx->deleteKeys(getSelected());
+  refresh();
+
+}
+
+void KeyList::createActions()
+{
+     deleteKeyAct = new QAction(tr("Delete Key"), this);
+     deleteKeyAct->setStatusTip(tr("Delete the selected keys"));
+     connect(deleteKeyAct, SIGNAL(triggered()), this, SLOT(deleteKey()));
+}
diff --git a/keylist.h b/keylist.h
new file mode 100644
index 0000000..e50df64
--- /dev/null
+++ b/keylist.h
@@ -0,0 +1,54 @@
+/*
+ *      keylist.h
+ *
+ *      Copyright 2008 gpg4usb-team <[email protected]>
+ *
+ *      This program is free software; you can redistribute it and/or modify
+ *      it under the terms of the GNU General Public License as published by
+ *      the Free Software Foundation; either version 2 of the License, or
+ *      (at your option) any later version.
+ *
+ *      This program is distributed in the hope that it will be useful,
+ *      but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *      GNU General Public License for more details.
+ *
+ *      You should have received a copy of the GNU General Public License
+ *      along with this program; if not, write to the Free Software
+ *      Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ *      MA 02110-1301, USA.
+ */
+#include <QWidget>
+#include <QListWidget>
+#include <QPushButton>
+#include "context.h"
+
+ class QMenu;
+
+class KeyList : public QWidget
+{
+  Q_OBJECT
+
+  public slots:
+     void deleteKeys();
+     void deleteKey();
+     
+  public:
+    KeyList(QWidget *parent = 0);
+    void setContext(GpgME::Context *ctx);
+    QList<QString>* getChecked();
+    QList<QString>* getSelected();
+    void refresh();
+
+  private:
+    GpgME::Context *m_ctx;
+    QListWidget *m_keyList;
+    QList<QString> *m_idList;
+    QPushButton *m_deleteButton;
+    QAction *deleteKeyAct;
+    void createActions();
+
+    
+  protected:
+    void contextMenuEvent(QContextMenuEvent *event);
+};
diff --git a/lib/libgpgme.a b/lib/libgpgme.a
new file mode 100644
index 0000000..2f164f0
--- /dev/null
+++ b/lib/libgpgme.a
diff --git a/main.cpp b/main.cpp
new file mode 100644
index 0000000..c124dd6
--- /dev/null
+++ b/main.cpp
@@ -0,0 +1,50 @@
+/*
+ *      main.cpp
+ *
+ *      Copyright 2008 gpg4usb-team <[email protected]>
+ *
+ *      This program is free software; you can redistribute it and/or modify
+ *      it under the terms of the GNU General Public License as published by
+ *      the Free Software Foundation; either version 2 of the License, or
+ *      (at your option) any later version.
+ *
+ *      This program is distributed in the hope that it will be useful,
+ *      but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *      GNU General Public License for more details.
+ *
+ *      You should have received a copy of the GNU General Public License
+ *      along with this program; if not, write to the Free Software
+ *      Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ *      MA 02110-1301, USA.
+ */
+
+#include <QApplication>
+#include "gpgwin.h"
+
+ int main(int argc, char *argv[])
+ {
+
+#ifndef _WIN32
+     // do not use GPG_AGENTS like seahorse, because they may save
+     // a password an pc's not owned by user
+     unsetenv("GPG_AGENT_INFO");
+#endif
+     QApplication app(argc, argv);
+     
+     //internationalize
+     QString locale = QLocale::system().name();
+     QTranslator translator;
+     translator.load(QString("ts/gpg4usblib_") + locale);
+     app.installTranslator(&translator);
+     
+     GpgWin *window = new GpgWin();
+     window->resize(800, 450);
+
+     window->show();
+
+     return app.exec();
+ }
+
+
+
diff --git a/release/bin/gpg.exe b/release/bin/gpg.exe
new file mode 100644
index 0000000..3cf1811
--- /dev/null
+++ b/release/bin/gpg.exe
diff --git a/release/mingwm10.dll b/release/mingwm10.dll
new file mode 100644
index 0000000..d566c80
--- /dev/null
+++ b/release/mingwm10.dll
diff --git a/release/testdata/crypt1.txt b/release/testdata/crypt1.txt
new file mode 100644
index 0000000..09ca96d
--- /dev/null
+++ b/release/testdata/crypt1.txt
@@ -0,0 +1,13 @@
+-----BEGIN PGP MESSAGE-----
+Version: GnuPG v1.4.6 (GNU/Linux)
+
+hQEOAwh91+A4FwHEEAP6A5TMwuHyihbn+kh/jzh+ItU+T2OqyOe3zIRJxmEC4M0M
+Pw1vvXqDLx6V5Cd2OW4w0ucs73YT30P4FaGGlOiWXoBvnQYALdHaBiLPUa6bLoRR
+F9hgh3rlzlxKlQTxJ3nSWDjlEePJgtqhF/UJztsQnwdIOz1sX6tCOJ63hK7AZMgE
+AJYpwqq9fsdytix4KPMurGWA3/XN7jn3D55xascR8z5aWv6zT50uiI8VyzQKqyd7
+QsCTvfhii0ukb4PEDAZ+2KQzXI6C3y1k/YiyWu+MWT0bZDt6zyAZhX7dUAULcM5s
+9FWRdwpihKaYGWjxDyT9Fi7o23KY+5X1RsdzPqopPkDw0kIBoLM8SPd1YfvSLoC1
+DpXz7/GWDzeBxtj8HAwLb8JxdGXzK8L/A/3MoOB5IAvMxKb9rWuDYoRHxHMLgFyb
+bYw5ocI=
+=x93j
+-----END PGP MESSAGE-----
diff --git a/release/testdata/pubkey-1.asc b/release/testdata/pubkey-1.asc
new file mode 100644
index 0000000..bed1da3
--- /dev/null
+++ b/release/testdata/pubkey-1.asc
@@ -0,0 +1,26 @@
+-----BEGIN PGP PUBLIC KEY BLOCK-----
+Version: GnuPG v1.0.4b (GNU/Linux)
+Comment: For info see http://www.gnupg.org
+
+mQGiBDo41NoRBADSfQazKGYf8nokq6zUKH/6INtV6MypSzSGmX2XErnARkIIPPYj
+cQRQ8zCbGV7ZU2ezVbzhFLUSJveE8PZUzzCrLp1O2NSyBTRcR5HVSXW95nJfY8eV
+pOvZRAKul0BVLh81kYTsrfzaaCjh9VWNP26LoeN2r+PjZyktXe7gM3C4SwCgoTxK
+WUVi9HoT2HCLY7p7oig5hEcEALdCJal0UYomX3nJapIVLVZg3vkidr1RICYMb2vz
+58i17h8sxEtobD1vdIKNejulntaRAXs4n0tDYD9z7pRlwG1CLz1R9WxYzeOOqUDr
+fnVXdmU8L/oVWABat8v1V7QQhjMMf+41fuzVwDMMGqjVPLhu4X6wp3A8uyM3YDnQ
+VMN1A/4n2G5gHoOvjqxn8Ch5tBAdMGfO8gH4RjQOwzm2R1wPQss/yzUN1+tlMZGX
+K2dQ2FCWC/hDUSNaEQRlI15wxxBNZ2RQwlzE2A8v113DpvyzOtv0QO95gJ1teCXC
+7j/BN9asgHaBBc39JLO/TcpuI7Hf8PQ5VcP2F0UE3lczGhXbLLQ/Sm9lIFJhbmRv
+bSBIYWNrZXIgKHRlc3Qga2V5IHdpdGggcGFzc3BocmFzZSAieCIpIDxqb2VAc2V0
+cS5vcmc+iFcEExECABcFAjo41NoFCwcKAwQDFQMCAxYCAQIXgAAKCRCvgiRPnNn9
+VXm9AJ0auCQID9AQ4ic48A05OI4tcvs24ACgjsLML1iIYUtrSP1o6QSIYdnTUZy5
+AQ0EOjjU3RAEAJ50lvtCGbnQlI97VX6tJkosdPmdzeXaTWfv//A2wmSANbYnuych
+GMa1LN43Ew+H6FXMWJ3MB/exs6UBFCgGsw88qmcla2bosQN/aVLA7fqXT9ujqoNG
+aIVEmgdbK1MkSPFXBFyVW3hteod83D0UqFlltwp4A3ageCYFVJTp50d3AAMFA/44
+YCQQbg9x9JvzHX3VH7CRX+raEDkDL3Pbz0PHas7bwI7gzZ+GFyNKaCvrHQOyuR8R
+IKIbjtQYnXr1675ConCTceIXhysY32sTn5V6UFUW2t0xaRfas8sZBbLDyIJkpt4f
+yD+6OaRoui9KZqXMNwt7i/XFIto/sWd/OK3SIgZkAYhGBBgRAgAGBQI6ONTdAAoJ
+EK+CJE+c2f1VVJoAn36uPWUhCdGXbSLxGibYfBt7et71AJ9JgWeRlTDTIoXYN8J+
+qsPN0YCxtg==
+=4+Yp
+-----END PGP PUBLIC KEY BLOCK-----
diff --git a/release/testdata/pubkey-2.asc b/release/testdata/pubkey-2.asc
new file mode 100644
index 0000000..7281989
--- /dev/null
+++ b/release/testdata/pubkey-2.asc
@@ -0,0 +1,1851 @@
+-----BEGIN PGP PUBLIC KEY BLOCK-----
+Version: GnuPG v1.4.6 (GNU/Linux)
+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+=UX/S
+-----END PGP PUBLIC KEY BLOCK-----
diff --git a/release/testdata/seckey-1.asc b/release/testdata/seckey-1.asc
new file mode 100644
index 0000000..3934804
--- /dev/null
+++ b/release/testdata/seckey-1.asc
@@ -0,0 +1,30 @@
+-----BEGIN PGP PRIVATE KEY BLOCK-----
+Version: GnuPG v1.0.4b (GNU/Linux)
+Comment: For info see http://www.gnupg.org
+
+lQHPBDo41NoRBADSfQazKGYf8nokq6zUKH/6INtV6MypSzSGmX2XErnARkIIPPYj
+cQRQ8zCbGV7ZU2ezVbzhFLUSJveE8PZUzzCrLp1O2NSyBTRcR5HVSXW95nJfY8eV
+pOvZRAKul0BVLh81kYTsrfzaaCjh9VWNP26LoeN2r+PjZyktXe7gM3C4SwCgoTxK
+WUVi9HoT2HCLY7p7oig5hEcEALdCJal0UYomX3nJapIVLVZg3vkidr1RICYMb2vz
+58i17h8sxEtobD1vdIKNejulntaRAXs4n0tDYD9z7pRlwG1CLz1R9WxYzeOOqUDr
+fnVXdmU8L/oVWABat8v1V7QQhjMMf+41fuzVwDMMGqjVPLhu4X6wp3A8uyM3YDnQ
+VMN1A/4n2G5gHoOvjqxn8Ch5tBAdMGfO8gH4RjQOwzm2R1wPQss/yzUN1+tlMZGX
+K2dQ2FCWC/hDUSNaEQRlI15wxxBNZ2RQwlzE2A8v113DpvyzOtv0QO95gJ1teCXC
+7j/BN9asgHaBBc39JLO/TcpuI7Hf8PQ5VcP2F0UE3lczGhXbLP8DAwKVpe92I5n5
+JGBjXsTTnVLoJ1hrWTdbLvdbn882m5pHYeqFlvkqKYXJTf0mIzpEU0FfZmFjdG9y
+OgAAr0JzPBwQoEmNI3YSC1MwimZ77bpvVKP9JiM6RFNBX2ZhY3RvcjoAAK9/fVBz
+g73cYbgeNWbz2uITUwNd9KEN/SYjOkRTQV9mYWN0b3I6AACvWjjITYZwah6NiH6C
+YgX52m55Dy5PX7Q/Sm9lIFJhbmRvbSBIYWNrZXIgKHRlc3Qga2V5IHdpdGggcGFz
+c3BocmFzZSAieCIpIDxqb2VAc2V0cS5vcmc+iFcEExECABcFAjo41NoFCwcKAwQD
+FQMCAxYCAQIXgAAKCRCvgiRPnNn9VXm9AKCFQ/t23GQnQEfnnAnvbRNfRo4zIQCb
+BHwILsDBASB1rQzW68UA/XHze0WdAUYEOjjU3RAEAJ50lvtCGbnQlI97VX6tJkos
+dPmdzeXaTWfv//A2wmSANbYnuychGMa1LN43Ew+H6FXMWJ3MB/exs6UBFCgGsw88
+qmcla2bosQN/aVLA7fqXT9ujqoNGaIVEmgdbK1MkSPFXBFyVW3hteod83D0UqFll
+twp4A3ageCYFVJTp50d3AAMFA/44YCQQbg9x9JvzHX3VH7CRX+raEDkDL3Pbz0PH
+as7bwI7gzZ+GFyNKaCvrHQOyuR8RIKIbjtQYnXr1675ConCTceIXhysY32sTn5V6
+UFUW2t0xaRfas8sZBbLDyIJkpt4fyD+6OaRoui9KZqXMNwt7i/XFIto/sWd/OK3S
+IgZkAf8DAwKVpe92I5n5JGAHRuEKSSvGU+0my6zTf17bLWPpFPnICNJdaMfyx24Y
+RZZa+nDpYrRznJ89vohGBBgRAgAGBQI6ONTeAAoJEK+CJE+c2f1V7iIAn0WsYyUV
+Huz4ZZ/WxxN57Ku2Eqs9AJ9Klz9imzvZoUjuE9/Ihr0y56tVng==
+=lKvj
+-----END PGP PRIVATE KEY BLOCK-----
diff --git a/testdata/crypt1.txt b/testdata/crypt1.txt
new file mode 100644
index 0000000..09ca96d
--- /dev/null
+++ b/testdata/crypt1.txt
@@ -0,0 +1,13 @@
+-----BEGIN PGP MESSAGE-----
+Version: GnuPG v1.4.6 (GNU/Linux)
+
+hQEOAwh91+A4FwHEEAP6A5TMwuHyihbn+kh/jzh+ItU+T2OqyOe3zIRJxmEC4M0M
+Pw1vvXqDLx6V5Cd2OW4w0ucs73YT30P4FaGGlOiWXoBvnQYALdHaBiLPUa6bLoRR
+F9hgh3rlzlxKlQTxJ3nSWDjlEePJgtqhF/UJztsQnwdIOz1sX6tCOJ63hK7AZMgE
+AJYpwqq9fsdytix4KPMurGWA3/XN7jn3D55xascR8z5aWv6zT50uiI8VyzQKqyd7
+QsCTvfhii0ukb4PEDAZ+2KQzXI6C3y1k/YiyWu+MWT0bZDt6zyAZhX7dUAULcM5s
+9FWRdwpihKaYGWjxDyT9Fi7o23KY+5X1RsdzPqopPkDw0kIBoLM8SPd1YfvSLoC1
+DpXz7/GWDzeBxtj8HAwLb8JxdGXzK8L/A/3MoOB5IAvMxKb9rWuDYoRHxHMLgFyb
+bYw5ocI=
+=x93j
+-----END PGP MESSAGE-----
diff --git a/testdata/pubkey-1.asc b/testdata/pubkey-1.asc
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/testdata/pubkey-1.asc
@@ -0,0 +1 @@
+
diff --git a/testdata/pubkey-2.asc b/testdata/pubkey-2.asc
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/testdata/pubkey-2.asc
@@ -0,0 +1 @@
+
diff --git a/testdata/seckey-1.asc b/testdata/seckey-1.asc
new file mode 100644
index 0000000..3934804
--- /dev/null
+++ b/testdata/seckey-1.asc
@@ -0,0 +1,30 @@
+-----BEGIN PGP PRIVATE KEY BLOCK-----
+Version: GnuPG v1.0.4b (GNU/Linux)
+Comment: For info see http://www.gnupg.org
+
+lQHPBDo41NoRBADSfQazKGYf8nokq6zUKH/6INtV6MypSzSGmX2XErnARkIIPPYj
+cQRQ8zCbGV7ZU2ezVbzhFLUSJveE8PZUzzCrLp1O2NSyBTRcR5HVSXW95nJfY8eV
+pOvZRAKul0BVLh81kYTsrfzaaCjh9VWNP26LoeN2r+PjZyktXe7gM3C4SwCgoTxK
+WUVi9HoT2HCLY7p7oig5hEcEALdCJal0UYomX3nJapIVLVZg3vkidr1RICYMb2vz
+58i17h8sxEtobD1vdIKNejulntaRAXs4n0tDYD9z7pRlwG1CLz1R9WxYzeOOqUDr
+fnVXdmU8L/oVWABat8v1V7QQhjMMf+41fuzVwDMMGqjVPLhu4X6wp3A8uyM3YDnQ
+VMN1A/4n2G5gHoOvjqxn8Ch5tBAdMGfO8gH4RjQOwzm2R1wPQss/yzUN1+tlMZGX
+K2dQ2FCWC/hDUSNaEQRlI15wxxBNZ2RQwlzE2A8v113DpvyzOtv0QO95gJ1teCXC
+7j/BN9asgHaBBc39JLO/TcpuI7Hf8PQ5VcP2F0UE3lczGhXbLP8DAwKVpe92I5n5
+JGBjXsTTnVLoJ1hrWTdbLvdbn882m5pHYeqFlvkqKYXJTf0mIzpEU0FfZmFjdG9y
+OgAAr0JzPBwQoEmNI3YSC1MwimZ77bpvVKP9JiM6RFNBX2ZhY3RvcjoAAK9/fVBz
+g73cYbgeNWbz2uITUwNd9KEN/SYjOkRTQV9mYWN0b3I6AACvWjjITYZwah6NiH6C
+YgX52m55Dy5PX7Q/Sm9lIFJhbmRvbSBIYWNrZXIgKHRlc3Qga2V5IHdpdGggcGFz
+c3BocmFzZSAieCIpIDxqb2VAc2V0cS5vcmc+iFcEExECABcFAjo41NoFCwcKAwQD
+FQMCAxYCAQIXgAAKCRCvgiRPnNn9VXm9AKCFQ/t23GQnQEfnnAnvbRNfRo4zIQCb
+BHwILsDBASB1rQzW68UA/XHze0WdAUYEOjjU3RAEAJ50lvtCGbnQlI97VX6tJkos
+dPmdzeXaTWfv//A2wmSANbYnuychGMa1LN43Ew+H6FXMWJ3MB/exs6UBFCgGsw88
+qmcla2bosQN/aVLA7fqXT9ujqoNGaIVEmgdbK1MkSPFXBFyVW3hteod83D0UqFll
+twp4A3ageCYFVJTp50d3AAMFA/44YCQQbg9x9JvzHX3VH7CRX+raEDkDL3Pbz0PH
+as7bwI7gzZ+GFyNKaCvrHQOyuR8RIKIbjtQYnXr1675ConCTceIXhysY32sTn5V6
+UFUW2t0xaRfas8sZBbLDyIJkpt4fyD+6OaRoui9KZqXMNwt7i/XFIto/sWd/OK3S
+IgZkAf8DAwKVpe92I5n5JGAHRuEKSSvGU+0my6zTf17bLWPpFPnICNJdaMfyx24Y
+RZZa+nDpYrRznJ89vohGBBgRAgAGBQI6ONTeAAoJEK+CJE+c2f1V7iIAn0WsYyUV
+Huz4ZZ/WxxN57Ku2Eqs9AJ9Klz9imzvZoUjuE9/Ihr0y56tVng==
+=lKvj
+-----END PGP PRIVATE KEY BLOCK-----
diff --git a/ts/gpg4usblib_de.qm b/ts/gpg4usblib_de.qm
new file mode 100644
index 0000000..793ff8e
--- /dev/null
+++ b/ts/gpg4usblib_de.qm
diff --git a/ts/gpg4usblib_de.ts b/ts/gpg4usblib_de.ts
new file mode 100644
index 0000000..5aac5df
--- /dev/null
+++ b/ts/gpg4usblib_de.ts
@@ -0,0 +1,333 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE TS><TS version="1.1" language="de">
+<defaultcodec></defaultcodec>
+<context>
+    <name>GpgWin</name>
+    <message>
+        <location filename="../gpgwin.cpp" line="66"/>
+        <source>&amp;Open...</source>
+        <translation>Ö&amp;ffnen...</translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="68"/>
+        <source>Ctrl+O</source>
+        <translation></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="69"/>
+        <source>Open an existing file</source>
+        <translation>Öffen Datei</translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="72"/>
+        <source>&amp;Save</source>
+        <translation>&amp;Speichern</translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="74"/>
+        <source>Ctrl+S</source>
+        <translation></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="75"/>
+        <source>Save the current File</source>
+        <translation>Speichere Datei</translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="78"/>
+        <source>Save &amp;As</source>
+        <translation type="unfinished">Speichern &amp;unter</translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="120"/>
+        <source>Ctrl+A</source>
+        <translation></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="81"/>
+        <source>Save the current File as...</source>
+        <translation>Speichere aktuelle Datei als....</translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="84"/>
+        <source>&amp;Print</source>
+        <translation>&amp;Drucken</translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="86"/>
+        <source>Ctrl+P</source>
+        <translation></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="87"/>
+        <source>Print Document</source>
+        <translation>Drucken</translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="90"/>
+        <source>&amp;Quit</source>
+        <translation type="unfinished">&amp;Beenden</translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="91"/>
+        <source>Ctrl+Q</source>
+        <translation></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="93"/>
+        <source>Quit Program</source>
+        <translation>Beende das Programm</translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="98"/>
+        <source>&amp;Paste</source>
+        <translation type="unfinished">E&amp;infügen</translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="100"/>
+        <source>Ctrl+V</source>
+        <translation></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="101"/>
+        <source>Paste Text From Clipboard</source>
+        <translation>Füge Text aus der Zwischenablage ein</translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="104"/>
+        <source>Cu&amp;t</source>
+        <translation></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="106"/>
+        <source>Ctrl+X</source>
+        <translation></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="108"/>
+        <source>Cut the current selection&apos;s contents to the clipboard</source>
+        <translation>aktuelle Auswahl ausschneiden und in Zwischenablage einfügen</translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="111"/>
+        <source>&amp;Copy</source>
+        <translation>&amp;Kopieren</translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="113"/>
+        <source>Ctrl+C</source>
+        <translation></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="115"/>
+        <source>Copy the current selection&apos;s contents to the clipboard</source>
+        <translation>aktuelle Auswahl in Zwischenablage kopieren</translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="118"/>
+        <source>Select &amp;All</source>
+        <translation>Alles &amp;markieren</translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="121"/>
+        <source>Select the whole text</source>
+        <translation>Den ganzen Text markieren</translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="126"/>
+        <source>&amp;Encrypt</source>
+        <translation type="unfinished">&amp;Verschlüsseln</translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="128"/>
+        <source>Ctrl+E</source>
+        <translation></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="129"/>
+        <source>Encrypt Message</source>
+        <translation>Verschlüssele den Text</translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="132"/>
+        <source>&amp;Decrypt</source>
+        <translation type="unfinished">&amp;Entschlüsseln</translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="134"/>
+        <source>Ctrl+D</source>
+        <translation></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="135"/>
+        <source>Decrypt Message</source>
+        <translation>Entschlüssele den Text</translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="138"/>
+        <source>&amp;Import Key From File</source>
+        <translation type="unfinished">Importiere Schlüssel aus &amp;Datei</translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="140"/>
+        <source>Ctrl+I</source>
+        <translation></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="141"/>
+        <source>Import New Key From File</source>
+        <translation>Importiere einen neuen Schlüssel aus Datei</translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="144"/>
+        <source>Import Key From Editor</source>
+        <translation type="unfinished">Importiere Schlüssel aus &amp;Textfeld</translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="146"/>
+        <source>Import New Key From Editor</source>
+        <translation>Importiere einen neuen Schlüssel aus dem Textfeld</translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="151"/>
+        <source>&amp;About</source>
+        <translation>&amp;Info</translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="153"/>
+        <source>Show the application&apos;s About box</source>
+        <translation>Zeige die Information über die Anwendung</translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="159"/>
+        <source>&amp;File</source>
+        <translation>&amp;Datei</translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="167"/>
+        <source>&amp;Edit</source>
+        <translation>&amp;Bearbeiten</translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="173"/>
+        <source>&amp;Crypto</source>
+        <translation>&amp;Crypt</translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="180"/>
+        <source>&amp;Help</source>
+        <translation>&amp;Hilfe</translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="317"/>
+        <source>File</source>
+        <translation>Datei</translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="190"/>
+        <source>Edit</source>
+        <translation>Bearbeiten</translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="342"/>
+        <source>Ready</source>
+        <translation>Fertig</translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="203"/>
+        <source>Encrypt for:</source>
+        <translation>Verschlüssele für:</translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="297"/>
+        <source>Application</source>
+        <translation>Anwendung</translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="259"/>
+        <source>Cannot read file %1:
+%2.</source>
+        <translation>Kann Datei nicht lesen %1: %2.</translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="270"/>
+        <source>File loaded</source>
+        <translation>Datei geladen</translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="285"/>
+        <source>%1[*] - %2</source>
+        <translation></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="298"/>
+        <source>The document has been modified.
+Do you want to save your changes?</source>
+        <translation>Die Datei würde verändert. Möchten Sie die Änderung speichern?</translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="319"/>
+        <source>Cannot write file %1:
+%2.</source>
+        <translation>Kann Datei nicht lesen %1: %2.</translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="327"/>
+        <source>Saved &apos;%1&apos;</source>
+        <translation>%1 gespeichert</translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="347"/>
+        <source>About gpg4usb</source>
+        <translation>Über gpg4usb</translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="359"/>
+        <source>&lt;center&gt;This Application allows you to do simple&lt;br&gt;encryption/decryption of your text-files.&lt;br&gt;It&apos;s licensed under the GPL v2.0&lt;br&gt;&lt;br&gt;&lt;b&gt;Developer:&lt;/b&gt;&lt;br&gt;Bene, Heimer, Juergen, Nils, Ubbo&lt;br&gt;&lt;br&gt;If you have any questions and/or&lt;br&gt;suggestions, contact us at&lt;br&gt;gpg4usb at cpunk.de&lt;/a&gt;&lt;br&gt;&lt;br&gt;or feel free to meet us in our channel at&lt;br&gt;gpg4usb at conference.jabber.ccc.de&lt;br&gt;&lt;br&gt;and always remember:&lt;br&gt;cpunk is NOT a bot...&lt;/center&gt;</source>
+        <translation></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="389"/>
+        <source>Open Key</source>
+        <translation>Öffne Datei</translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="389"/>
+        <source>Key Files (*.asc *.txt);;All Files (*.*)</source>
+        <translation>Schhlüsseldateien (*.asc *.txt);;Alle Dateien (*.*)</translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="281"/>
+        <source>untitled.txt</source>
+        <translation>Neue Datei.txt</translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="396"/>
+        <source>couldn&apos;t open file: </source>
+        <translation>Konnte Datei nicht öffnen:</translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="285"/>
+        <source>gpg4usb</source>
+        <translation>gpg4usb</translation>
+    </message>
+</context>
+<context>
+    <name>KeyList</name>
+    <message>
+        <location filename="keylist.cpp" line="35"/>
+        <source>Delete Selected Keys</source>
+        <translation>Lösche die markierten Schlüssel</translation>
+    </message>
+    <message>
+        <location filename="keylist.cpp" line="116"/>
+        <source>Delete Key</source>
+        <translation>Lösche Schlüssel</translation>
+    </message>
+    <message>
+        <location filename="keylist.cpp" line="117"/>
+        <source>Delete the selected keys</source>
+        <translation>Lösche die markierten Schlüssel</translation>
+    </message>
+</context>
+</TS>
diff --git a/ts/gpg4usblib_en.qm b/ts/gpg4usblib_en.qm
new file mode 100644
index 0000000..768f0b0
--- /dev/null
+++ b/ts/gpg4usblib_en.qm
diff --git a/ts/gpg4usblib_en.ts b/ts/gpg4usblib_en.ts
new file mode 100644
index 0000000..b301ec4
--- /dev/null
+++ b/ts/gpg4usblib_en.ts
@@ -0,0 +1,332 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE TS><TS version="1.1">
+<context>
+    <name>GpgWin</name>
+    <message>
+        <location filename="../gpgwin.cpp" line="66"/>
+        <source>&amp;Open...</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="68"/>
+        <source>Ctrl+O</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="69"/>
+        <source>Open an existing file</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="72"/>
+        <source>&amp;Save</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="74"/>
+        <source>Ctrl+S</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="75"/>
+        <source>Save the current File</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="78"/>
+        <source>Save &amp;As</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="120"/>
+        <source>Ctrl+A</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="81"/>
+        <source>Save the current File as...</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="84"/>
+        <source>&amp;Print</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="86"/>
+        <source>Ctrl+P</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="87"/>
+        <source>Print Document</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="90"/>
+        <source>&amp;Quit</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="91"/>
+        <source>Ctrl+Q</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="93"/>
+        <source>Quit Program</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="98"/>
+        <source>&amp;Paste</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="100"/>
+        <source>Ctrl+V</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="101"/>
+        <source>Paste Text From Clipboard</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="104"/>
+        <source>Cu&amp;t</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="106"/>
+        <source>Ctrl+X</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="108"/>
+        <source>Cut the current selection&apos;s contents to the clipboard</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="111"/>
+        <source>&amp;Copy</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="113"/>
+        <source>Ctrl+C</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="115"/>
+        <source>Copy the current selection&apos;s contents to the clipboard</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="118"/>
+        <source>Select &amp;All</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="121"/>
+        <source>Select the whole text</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="126"/>
+        <source>&amp;Encrypt</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="128"/>
+        <source>Ctrl+E</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="129"/>
+        <source>Encrypt Message</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="132"/>
+        <source>&amp;Decrypt</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="134"/>
+        <source>Ctrl+D</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="135"/>
+        <source>Decrypt Message</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="138"/>
+        <source>&amp;Import Key From File</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="140"/>
+        <source>Ctrl+I</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="141"/>
+        <source>Import New Key From File</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="144"/>
+        <source>Import Key From Editor</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="146"/>
+        <source>Import New Key From Editor</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="151"/>
+        <source>&amp;About</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="153"/>
+        <source>Show the application&apos;s About box</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="159"/>
+        <source>&amp;File</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="167"/>
+        <source>&amp;Edit</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="173"/>
+        <source>&amp;Crypto</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="180"/>
+        <source>&amp;Help</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="317"/>
+        <source>File</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="190"/>
+        <source>Edit</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="342"/>
+        <source>Ready</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="203"/>
+        <source>Encrypt for:</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="297"/>
+        <source>Application</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="259"/>
+        <source>Cannot read file %1:
+%2.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="270"/>
+        <source>File loaded</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="281"/>
+        <source>untitled.txt</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="285"/>
+        <source>%1[*] - %2</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="285"/>
+        <source>gpg4usb</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="298"/>
+        <source>The document has been modified.
+Do you want to save your changes?</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="319"/>
+        <source>Cannot write file %1:
+%2.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="327"/>
+        <source>Saved &apos;%1&apos;</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="347"/>
+        <source>About gpg4usb</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="359"/>
+        <source>&lt;center&gt;This Application allows you to do simple&lt;br&gt;encryption/decryption of your text-files.&lt;br&gt;It&apos;s licensed under the GPL v2.0&lt;br&gt;&lt;br&gt;&lt;b&gt;Developer:&lt;/b&gt;&lt;br&gt;Bene, Heimer, Juergen, Nils, Ubbo&lt;br&gt;&lt;br&gt;If you have any questions and/or&lt;br&gt;suggestions, contact us at&lt;br&gt;gpg4usb at cpunk.de&lt;/a&gt;&lt;br&gt;&lt;br&gt;or feel free to meet us in our channel at&lt;br&gt;gpg4usb at conference.jabber.ccc.de&lt;br&gt;&lt;br&gt;and always remember:&lt;br&gt;cpunk is NOT a bot...&lt;/center&gt;</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="389"/>
+        <source>Open Key</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="389"/>
+        <source>Key Files</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="../gpgwin.cpp" line="396"/>
+        <source>couldn&apos;t open file: </source>
+        <translation type="unfinished"></translation>
+    </message>
+</context>
+<context>
+    <name>KeyList</name>
+    <message>
+        <location filename="../keylist.cpp" line="35"/>
+        <source>Delete Selected Keys</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="../keylist.cpp" line="116"/>
+        <source>Delete Key</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="../keylist.cpp" line="117"/>
+        <source>Delete the selected keys</source>
+        <translation type="unfinished"></translation>
+    </message>
+</context>
+</TS>
diff --git a/winbuild/static-win.zip b/winbuild/static-win.zip
new file mode 100644
index 0000000..b4ffc54
--- /dev/null
+++ b/winbuild/static-win.zip