More GTK2 removalpyme3

* Missed a couple of files, these 2 go for the same reason as the
  previous 3.

1 files changed, 0 insertions, 1457 deletions

diff --git a/lang/py3-pyme/examples/pygpa.py b/lang/py3-pyme/examples/pygpa.py
deleted file mode 100755
index 341a87cb..00000000
--- a/lang/py3-pyme/examples/pygpa.py
+++ /dev/null
@@ -1,1457 +0,0 @@
-#!/usr/bin/env python3
-# $Id$
-# Copyright (C) 2005,2008 Igor Belyi <[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
-
-import gtk, gobject, gtk.glade
-import gettext
-import time, sys, os
-from pyme import errors, core
-from pyme.core import Context, Data, pubkey_algo_name
-from pyme.constants import validity, status, keylist, sig, sigsum
-
-# Enable internationalization using gpa translation pages.
-gettext.install('gpa', None, 1)
-gtk.glade.bindtextdomain('gpa')
-gtk.glade.textdomain('gpa')
-
-# Thanks to Bernhard Reiter for pointing out the following:
-# gpgme_check_version() necessary for initialisation according to 
-# gpgme 1.1.6 and this is not done automatically in pyme-0.7.0
-print("gpgme version:", core.check_version())
-
-# Helper functions to convert non-string data into printable strings
-def sec2str(secs, empty="_(Unknown)"):
-    "Convert seconds since 1970 into mm/dd/yy string"
-    if secs > 0:    return time.strftime("%m/%d/%y", time.localtime(secs))
-    elif secs == 0: return empty
-    else:           return ""
-
-trusts = {
-    validity.UNDEFINED: "Unknown",
-    validity.NEVER: "Never",
-    validity.MARGINAL: "Marginal",
-    validity.FULL: "Full",
-    validity.ULTIMATE: "Ultimate"
-    }
-
-def validity2str(valid):
-    "Convert trust integer into a human understandable string"
-    if valid in trusts: return _("%s" % trusts[valid])
-    else:                     return _("Unknown")
-
-def keyvalid2str(key):
-    "Create a string representing validity of a key"
-    if key.owner_trust==validity.ULTIMATE:
-        return _("Fully Valid")
-    if key.revoked: return _("Revoked")
-    if key.expired: return _("Expired")
-    if key.disabled: return _("Disabled")
-    if not key.uids or key.uids[0].invalid: return _("Incomplete")
-    return _("Unknown")
-
-def subvalid2str(subkey):
-    "Create a string representing validity of a subkey"
-    if subkey.revoked: return _("Revoked")
-    if subkey.expired: return _("Expired")
-    if subkey.disabled: return _("Disabled")
-    if subkey.invalid: return _("Unsigned")
-    return _("Valid")
-
-def signstat2str(sig):
-    "Create a string representing validity of a signature"
-    status = _("Unknown")
-    if sig.status == 1: status = _("Valid")
-    elif sig.status == 2: status = _("Bad")
-    if sig.expired: status = _("Expired")
-    elif sig.revoked: status = _("Revoked")
-    return status
-
-def sigsum2str(summary):
-    if summary & sigsum.VALID: return _("Valid")
-    if summary & sigsum.RED: return _("Bad")
-    if summary & sigsum.KEY_MISSING: return _("Unknown Key")
-    if summary & sigsum.KEY_REVOKED: return _("Revoked Key")
-    if summary & sigsum.KEY_EXPIRED: return _("Expired Key")
-    return _("Key NOT valid")
-
-def class2str(cls):
-    "Convert signature class integer into a human understandable string"    
-    if cls==0x10: return _("Generic")
-    if cls==0x11: return _("Persona")
-    if cls==0x12: return _("Casual")
-    if cls==0x13: return _("Positive")
-    return _("Unknown")
-
-def algo2str(algo):
-    "Convert algorithm integer into a human understandable string"
-    return pubkey_algo_name(algo)
-
-def fpr2str(fpr):
-    "Convert fpr string in a sparsely spaced string for easy reading"
-    result = []
-    while fpr:
-        result.append(fpr[:4])
-        fpr = fpr[4:]
-    return " ".join(result)
-
-# Helper functions for tasks unrelated to any class
-def obj2model(objs, columns):
-    "Create a model from the obj (key, subkey, or signature) using columns"
-    model = gtk.ListStore(*[x.ctype for x in columns])
-    for obj in objs:
-        model.append([x.cfunc(obj) for x in columns])
-    return model
-
-def labels2table(key_labels):
-    "Create a gtk.Table from an array of 2-tuples of strings"
-    table = gtk.Table(len(key_labels), 2)
-    for i, row in enumerate(key_labels):
-        if len(row) != 2:
-            raise ValueError("Unexpected number of rows in labels2table call")
-        label1 = gtk.Label(row[0])
-        label1.set_alignment(1.0, 0.5)
-        label2 = gtk.Label(row[1])
-        label2.set_alignment(0.0, 0.5)
-        label2.set_padding(5, 0)
-        table.attach(label1, 0, 1, i, i+1, gtk.FILL, gtk.FILL)
-        table.attach(label2, 1, 2, i, i+1, gtk.FILL, gtk.FILL)
-    return table
-
-status2str = {}
-for name in dir(status):
-    if not name.startswith('__') and name != "util":
-        status2str[getattr(status, name)] = name
-
-def editor_func(status, args, val_dict):
-    prompt = "%s %s" % (val_dict["state"], args)
-    if prompt in val_dict:
-        val_dict["state"] = val_dict[prompt][0]
-        return val_dict[prompt][1]
-    elif args and "ignore %s" % status2str[status] not in val_dict:
-        for error in ["error %s" % status2str[status], "error %s" % prompt]:
-            if error in val_dict:
-                raise errors.GPGMEError(val_dict[error])
-        sys.stderr.write(_("Unexpected status and prompt in editor_func: " +
-                           "%s %s\n") % (status2str[status], prompt))
-        raise EOFError()
-    return ""
-
-common_dict = {
-        "state": "start",
-        "quit keyedit.save.okay": ("save", "Y"),
-        "ignore NEED_PASSPHRASE": None,
-        "ignore NEED_PASSPHRASE_SYM": None,
-        "ignore BAD_PASSPHRASE": None,
-        "ignore USERID_HINT": None
-        }  
-
-def change_key_expire(context, key, date):
-    "Change key's expiration date to date"
-    val_dict = common_dict.copy()
-    val_dict.update({
-        "start keyedit.prompt": ("expire", "expire"),
-        "expire keygen.valid": ("date", date),
-        "date keyedit.prompt": ("quit", "quit")
-        })
-    out = Data()
-    context.op_edit(key, editor_func, val_dict, out)
-
-def change_key_trust(context, key, new_trust):
-    "Change key's trust to new_trust"
-    val_dict = common_dict.copy()
-    val_dict.update({
-        "start keyedit.prompt": ("trust", "trust"),
-        "trust edit_ownertrust.value": ("value", "%d" % new_trust),
-        "value edit_ownertrust.set_ultimate.okay": ("value", "Y"),
-        "value keyedit.prompt": ("quit", "quit")
-        })
-    out = Data()
-    context.op_edit(key, editor_func, val_dict, out)
-
-def sign_key(context, key, sign_key, local):
-    "Sign key using sign_key. Signature is exportable if local is False"
-    # Values copied from <gpg-error.h>
-    GPG_ERR_CONFLICT = 70
-    GPG_ERR_UNUSABLE_PUBKEY = 53
-    val_dict = common_dict.copy()
-    val_dict.update({
-        "start keyedit.prompt": ("sign", (local and "lsign") or "sign"),
-        "sign keyedit.sign_all.okay": ("sign", "Y"),
-        "sign sign_uid.expire": ("sign", "Y"),
-        "sign sign_uid.class": ("sign", "0"),
-        "sign sign_uid.okay": ("okay", "Y"),
-        "okay keyedit.prompt": ("quit", "quit"),
-        "error ALREADY_SIGNED": GPG_ERR_CONFLICT,
-        "error sign keyedit.prompt": GPG_ERR_UNUSABLE_PUBKEY
-        })
-    out = Data()
-    context.signers_clear()
-    context.signers_add(sign_key)
-    context.op_edit(key, editor_func, val_dict, out)
-
-def trigger_change_password(context, key):
-    "Trigger sequence of passphrase_cb callbacks to change password of the key"
-    val_dict = common_dict.copy()
-    val_dict.update({
-        "start keyedit.prompt": ("passwd", "passwd"),
-        "passwd keyedit.prompt": ("quit", "quit")
-        })
-    out = Data()
-    context.op_edit(key, editor_func, val_dict, out)
-
-# Helper classes whose instances are used in the major PyGpa class
-class KeyInfo:
-    """Helper class to represent key information in different views.
-    If KeyInfo instance is initialized with an integer as a key the views
-    correspond to a state when multiple or no keys are selected"""
-    def __init__(self, key, secret=None):
-        self.key = key
-        self.secret = secret
-
-    def key_print_labels(self, fpr=False):
-        "Create an array of 2-tuples for 'User Name' and 'Key ID' fields"
-        labels = []
-        if type(self.key) != int:
-            if self.key.uids:
-                labels.append((_("User Name:"), self.key.uids[0].uid))
-		for uid in self.key.uids[1:]:
-                    labels.append(("", uid.uid))
-            if fpr:
-                labels += [(_("Fingerprint:"), fpr2str(self.key.subkeys[0].fpr))]
-            else:
-                labels += [(_("Key ID:"), self.key.subkeys[0].keyid[-8:])]
-        return labels
-
-    def key_expires_label(self):
-        return sec2str(self.key.subkeys[0].expires,_("never expires"))
-
-    def details(self):
-        "Create a widget for 'Details' notebook tab"
-        if type(self.key) == int:
-            if self.key:
-                details=gtk.Label(_("%d keys selected") % self.key)
-            else:
-                details=gtk.Label(_("No keys selected"))
-            details.set_alignment(0.5, 0)
-            return details
-        
-        if self.secret:
-            header = _("The key has both a private and a public part")
-        else:
-            header = _("The key has only a public part")
-        key_info_labels = [("", header)]
-
-        if self.key.can_certify:
-            if self.key.can_sign:
-                if self.key.can_encrypt:
-                    ability = _("The key can be used for certification, " +
-                                "signing and encryption.")
-                else:
-                    ability = _("The key can be used for certification and " +
-                                "signing, but not for encryption.")
-            else:
-                if self.key.can_encrypt:
-                    ability = _("The key can be used for certification and " +
-                                "encryption.")
-                else:
-                    ability = _("The key can be used only for certification.")
-        else:
-            if self.key.can_sign:
-                if self.key.can_encrypt:
-                    ability = _("The key can be used only for signing and " +
-                                "encryption, but not for certification.")
-                else:
-                    ability = _("The key can be used only for signing.")
-            else:
-                if self.key.can_encrypt:
-                    ability = _("The key can be used only for encryption.")
-                else:
-                    ability = _("This key is useless.")
-        key_info_labels.append(("", ability))
-
-        key_info_labels += self.key_print_labels() + [
-            (_("Fingerprint:"), fpr2str(self.key.subkeys[0].fpr)),
-            (_("Expires at:"), self.key_expires_label()),
-            (_("Owner Trust:"), validity2str(self.key.owner_trust)),
-            (_("Key Validity:"), keyvalid2str(self.key)),
-            (_("Key Type:"), _("%s %u bits") % \
-             (algo2str(self.key.subkeys[0].pubkey_algo),self.key.subkeys[0].length)),
-            (_("Created at:"), sec2str(self.key.subkeys[0].timestamp))
-            ]
-
-        return labels2table(key_info_labels)
-
-    def sign_model(self):
-        "Create a model for ComboBox of uids in 'Signatures' notebook tab"
-        model = gtk.ListStore(str, gtk.ListStore)
-        if type(self.key) != int:
-            for uid in self.key.uids:
-                model.append([uid.uid, obj2model(uid.signatures,sign_columns)])
-        return model
-
-    def subkey_model(self):
-        "Create a model for TreeView in 'Subkeys' notebook tab"
-        if type(self.key) == int:
-            return gtk.ListStore(*[x.ctype for x in subkey_columns])
-        else:
-            return obj2model(self.key.subkeys, subkey_columns)
-
-class Column:
-    "Helper class to represent a column in a TreeView"
-    def __init__(self, name, ctype, cfunc, detail=False):
-        """Column(name, ctype, cfunc):
-        name  - Name to use as a column header
-        ctype - type to use in a model definition for this column
-        cfunc - function retrieving column's infromation from an object
-        detail- indicate if it's a detail visible only in detailed view"""
-        self.name = name
-        self.ctype = ctype
-        self.cfunc = cfunc
-        self.detail = detail
-
-# Columns for the list of keys which can be used as default
-def_keys_columns = [
-    Column(_("Key ID"), str, lambda x,y: x.subkeys[0].keyid[-8:]),
-    Column(_("User Name"), str,
-           lambda x,y: (x.uids and x.uids[0].uid) or _("[Unknown user ID]")),
-    Column(None, gobject.TYPE_PYOBJECT, lambda x,y: KeyInfo(x,y))
-    ]
-
-# Columns for the list of all keys in the keyring
-keys_columns = [
-    Column("", str, lambda x,y: (y and "sec") or "pub"),
-    def_keys_columns[0],
-    Column(_("Expiry Date"), str,
-           lambda x,y: sec2str(x.subkeys[0].expires, _("never expires")), True),
-    Column(_("Owner Trust"),str,lambda x,y:validity2str(x.owner_trust),True),
-    Column(_("Key Validity"), str, lambda x,y: keyvalid2str(x), True)
-    ] + def_keys_columns[1:]
-
-# Columns for the list of signatures on a uid
-sign_columns = [
-    Column(_("Key ID"), str, lambda x: x.keyid[-8:]),
-    Column(_("Status"), str, lambda x: signstat2str(x)),
-    Column(_("Level"), str, lambda x: class2str(x.sig_class)),
-    Column(_("Local"), type(True), lambda x: x.exportable==0),
-    Column(_("User Name"), str, lambda x: x.uid or _("[Unknown user ID]"))
-    ]
-
-# Columns for the list of subkeys
-subkey_columns = [
-    Column(_("Subkey ID"), str, lambda x: x.keyid[-8:]),
-    Column(_("Status"), str, lambda x: subvalid2str(x)),
-    Column(_("Algorithm"), str, lambda x: algo2str(x.pubkey_algo)),
-    Column(_("Size"), str, lambda x: _("%u bits") % x.length),
-    Column(_("Expiry Date"), str,
-           lambda x: sec2str(x.expires, _("never expires"))),
-    Column(_("Can sign"), type(True), lambda x: x.can_sign),
-    Column(_("Can certify"), type(True), lambda x: x.can_certify),
-    Column(_("Can encrypt"), type(True), lambda x: x.can_encrypt),
-    Column(_("Can authenticate"), type(True), lambda x: x.can_authenticate)
-    ]
-
-file_columns = [
-    Column(_("File"), str, lambda x: x)
-    ]
-
-class PyGpa:
-    "Major class representing PyGpa application"
-    def popup(self, dialog, parent=None, title=None):
-        "Common way to popup a dialog defined in Glade"
-        dialog.set_transient_for(parent or self.main_window)
-        if title: dialog.set_title(title)
-        result = dialog.run()
-        dialog.hide()
-        return result
-
-    def file_popup(self, dialog, parent=None, title=None):
-        return self.popup(dialog, parent or self.filemanager_window, title)
-        
-    def error_message(self, text, parent=None, title=_("Warning")):
-        "Pop up an error message dialog"
-        if type(text) == int:
-            text = errors.GPGMEError(text).getstring()
-            title = "GPGME error"
-        elif isinstance(text, errors.GPGMEError):
-            text = text.getstring()
-            title = "GPGME error"
-        self.error_label.set_text(text)
-        self.popup(self.error_dialog, parent, title)
-
-    def file_error_message(self, text, parent=None, title=_("Warning")):
-        self.error_message(text, parent or self.filemanager_window, title)
-
-    def info_message(self, text, parent=None, title=_("Information")):
-        "Pop up an information dialog"
-        self.info_label.set_text(text)
-        self.popup(self.info_dialog, parent, title)
-
-    def yesno_message(self, text, parent=None):
-        "Pop up a dialog requiring yes/no answer"
-        self.yesno_label.set_text(text)
-        return self.popup(self.yesno_dialog, parent,
-                          _("Warning")) == gtk.RESPONSE_YES
-
-    def on_uid_list_changed(self, uid_list):
-        "this callback is called when uid selection is changed"
-        index = uid_list.get_active()
-        if index == -1:
-            self.sign_treeview.set_model(KeyInfo(0).sign_model())
-        else:
-            self.sign_treeview.set_model(uid_list.get_model()[index][1])
-
-    def get_selected_keys(self, treeview=None):
-        "Helper function to get all selected rows in a treeview"
-        if not treeview:
-            treeview = self.keys_treeview
-        model, rows = treeview.get_selection().get_selected_rows()
-        return [model[path] for path in rows]
-
-    def on_keys_changed(self, keys_treeview):
-        "this callback is called when key selection is changed"
-        selection = keys_treeview.get_selection()
-        count = selection.count_selected_rows()
-        if count == 1:
-            key_info = self.get_selected_keys()[0][-1]
-        else:
-            key_info = KeyInfo(count)
-
-        self.update_menu(key_info)
-
-        # Update Details tab of the notebook
-        old_child = self.details_view.get_child()
-        if old_child: self.details_view.remove(old_child)
-        self.details_view.add(key_info.details())
-        self.details_view.show_all()
-
-        # Update Subkeys tab of the notebook
-        self.subkeys_treeview.set_model(key_info.subkey_model())
-
-        # Update Signatures tab of the notebook
-        sign_model = key_info.sign_model()
-        self.uid_list.set_model(sign_model)
-        if len(sign_model) < 2:
-            self.uid_list_box.hide()
-        else:
-            self.uid_list_box.show_all()
-        self.uid_list.set_active(0)
-        self.on_uid_list_changed(self.uid_list)
-
-    def on_keys_button_press(self, obj, event):
-        "callback on a mouse press in the keys_treeview"
-        if event.button == 3:
-            self.popup_menu.popup(None, None, None, event.button, event.time)
-            return True
-        return False
-
-    def create_popup_menu(self):
-        "create the popup menu shown on right mouse click"
-        self.items = [
-            (gtk.ImageMenuItem(gtk.STOCK_COPY), self.on_copy_activate),
-            (gtk.ImageMenuItem(gtk.STOCK_PASTE), self.on_paste_activate),
-            (gtk.ImageMenuItem(gtk.STOCK_DELETE), self.on_delete_activate),
-            (gtk.SeparatorMenuItem(), None),
-            (gtk.MenuItem(_("_Sign Keys...")), self.on_sign_keys_activate),
-            (gtk.MenuItem(_("Set _Owner Trust...")),
-             self.on_set_owner_trust_activate),
-            (gtk.MenuItem(_("_Edit Private Key...")),
-             self.on_edit_private_key_activate),
-            (gtk.SeparatorMenuItem(), None),
-            (gtk.MenuItem(_("E_xport Keys...")), self.on_export_keys_activate)
-            ]
-        self.popup_menu = gtk.Menu()
-        for item, callback in self.items:
-            if callback: item.connect("activate", callback)
-            self.popup_menu.append(item)
-        self.popup_menu.show_all()        
-    
-    def update_menu(self, key_info):
-        "update sensitivity of menu items depending on what keys are selected"
-        #                  copy, delete, sign, trust, edit, export
-        if key_info.secret == None:
-            if key_info.key:            # more than one key selected
-                values = ( True,  True,  True, False, False,  True)
-            else:                       # no keys selected
-                values = (False, False, False, False, False, False)
-        elif key_info.secret:
-            if key_info.key == self.default_key: # default key seleted
-                values = ( True,  True, False,  True,  True,  True)
-            else:                       # secret (not default) key selected
-                values = ( True,  True,  True,  True,  True,  True)
-        else:                           # public key selected
-            values   =   ( True,  True,  True,  True, False,  True)
-
-        for w,v in zip((self.copy, self.delete, self.sign_keys,
-                        self.set_owner_trust, self.edit_private_key,
-                        self.export_keys), values):
-            w.set_sensitive(v)
-        for w,v in zip((self.items[0][0], self.items[2][0], self.items[4][0],
-                        self.items[5][0], self.items[6][0], self.items[8][0]),
-                       values):
-            w.set_sensitive(v)                
-    
-    def setup_columns(self):
-        "Helper function to setup columns of different treeviews"
-        for treeview, columns in \
-                [(self.keys_treeview, keys_columns),
-                 (self.sign_treeview, sign_columns),
-                 (self.subkeys_treeview, subkey_columns),
-                 (self.def_keys_treeview, def_keys_columns),
-                 (self.sign_with_keys_treeview, def_keys_columns),
-                 (self.encrypt_with_keys_treeview, def_keys_columns),
-                 (self.files_treeview, file_columns)]:
-            for index, item in enumerate([x for x in columns if x.name!=None]):
-                if item.ctype == str:
-                    renderer = gtk.CellRendererText()
-                    attrs = {"text": index}
-                else:
-                    renderer = gtk.CellRendererToggle()
-                    attrs = {"active": index}
-                column = treeview.insert_column_with_attributes(
-                    index, item.name, renderer, **attrs)
-                column.set_sort_column_id(index)
-                column.set_visible(not item.detail)
-
-        for index,item in enumerate([x for x in keys_columns if x.name!=None]):
-            if item.name and not item.detail:
-                renderer = gtk.CellRendererText()
-                column = gtk.TreeViewColumn(item.name, renderer, text=index)
-                column.set_sort_column_id(index)
-                self.encrypt_for_keys_treeview.append_column(column)
-
-        for treeview in [self.encrypt_with_keys_treeview, self.keys_treeview,
-                         self.encrypt_for_keys_treeview, self.files_treeview,
-                         self.sign_with_keys_treeview]:
-            treeview.get_selection().set_mode(gtk.SELECTION_MULTIPLE)
-        self.def_keys_treeview.get_selection().set_mode(gtk.SELECTION_SINGLE)
-
-        cell = gtk.CellRendererText()
-        self.uid_list.pack_start(cell, True)
-        self.uid_list.add_attribute(cell, 'text', 0)
-
-        model = gtk.ListStore(str, str)
-        for lines in [(_("days"), "d"), (_("weeks"), "w"),
-                      (_("months"), "m"), (_("years"), "y")]:
-            model.append(lines)
-        self.new_expire_unit_combo.set_model(model)
-        self.new_expire_unit_combo.child.set_editable(False)
-        self.new_algorithm_combo.child.set_editable(False)
-
-        self.files_treeview.set_model(gtk.ListStore(str))
-
-    def setup_default_views(self):
-        "Setup initial values for different views"
-        self.update_default_keys()
-        self.on_advanced_mode_toggled(self.advanced_mode_rb)
-        self.create_popup_menu()
-        self.on_keys_changed(self.keys_treeview)
-
-    def load_keys(self):
-        "Download keys from the keyring"
-        context = Context()
-        sec_keys = {}
-        for key in context.op_keylist_all(None, 1):
-            sec_keys[key.subkeys[0].fpr] = 1
-        model = gtk.ListStore(*[x.ctype for x in keys_columns])
-        encrypt_model = gtk.ListStore(*[x.ctype for x in keys_columns])
-        context.set_keylist_mode(keylist.mode.SIGS)
-        for key in context.op_keylist_all(None, 0):
-            secret = key.subkeys[0].fpr in sec_keys
-            data = [x.cfunc(key, secret) for x in keys_columns]
-            if key.can_encrypt: encrypt_model.append(data)
-            model.append(data)
-        self.keys_treeview.set_model(model)
-        self.encrypt_for_keys_treeview.set_model(encrypt_model)
-
-    def set_default_key(self, key):
-        "Setup default key and update status bar with it"
-        self.default_key = key
-        self.status_uid.set_text((key.uids and key.uids[0].uid) or \
-                                 _("[Unknown user ID]"))
-        self.status_keyid.set_text(key.subkeys[0].keyid[-8:])
-
-    def on_default_keys_changed(self, treeview):
-        "This callback is called when default key is changed in Preferences"
-        model, rows = treeview.get_selection().get_selected_rows()
-        if model and rows:
-            self.set_default_key(model[rows[0]][-1].key)
-
-    def add_default_key(self, model, path, iter, def_model):
-        "Helper function to add secret keys to the list of possible defaults"
-        key = model[path][-1]
-        if key.secret:
-            def_model.append([x.cfunc(key.key,True) for x in def_keys_columns])
-
-    def add_sig_key(self, model, path, iter, sign_model):
-        "Helper function to add secret keys to the list of possible defaults"
-        key = model[path][-1].key
-        if key.can_sign:
-            sign_model.append([x.cfunc(key,True) for x in def_keys_columns])
-
-    def select_default_key(self, model, path, iter):
-        "Helper function to select current default key from the available list"
-        if model[path][-1].key == self.default_key:
-            self.def_keys_treeview.get_selection().select_path(path)
-
-    def update_default_keys(self):
-        "Update list of default keys"
-        model = gtk.ListStore(*[x.ctype for x in def_keys_columns])
-        self.keys_treeview.get_model().foreach(self.add_default_key, model)
-        self.def_keys_treeview.set_model(model)
-        model.foreach(self.select_default_key)
-        selection = self.def_keys_treeview.get_selection()
-        if selection.count_selected_rows() != 1:
-            selection.select_path((0,))
-            self.on_default_keys_changed(self.def_keys_treeview)
-        model = gtk.ListStore(*[x.ctype for x in def_keys_columns])
-        self.def_keys_treeview.get_model().foreach(self.add_sig_key, model)
-        self.sign_with_keys_treeview.set_model(model)
-        self.encrypt_with_keys_treeview.set_model(model)
-
-    def on_select_all_activate(self, obj):
-        "This callback is called when SelectAll menu item is selected"
-        self.keys_treeview.get_selection().select_all()
-
-    def on_file_preferences_activate(self, obj):
-        "Callback called when Preferences menu item is selected in filemanager"
-        self.show_preferences(self.filemanager_window)
-
-    def on_preferences_activate(self, obj):
-        "Callback called when Preferences menu item is selected in key editor"
-        self.show_preferences(None)
-
-    def show_preferences(self, parent):
-        "Show preferences positioning its window in the middle of the parent"
-        self.popup(self.preferences_dialog, parent)
-        self.def_keyserver = self.default_keyserver_combox.child.get_text()
-
-    def on_advanced_mode_toggled(self, radiobutton):
-        "This callback is called when Advanced Mode selection is changed"
-        if radiobutton.get_active():
-            self.subkeys_notebook_tab.show()
-            self.get_generate_params = self.get_advanced_generate_params
-        else:
-            self.subkeys_notebook_tab.hide()
-            self.get_generate_params = self.get_novice_generate_params
-
-    def popup_progress_dialog(self, label, parent):
-        self.progress_dialog.set_transient_for(parent)
-        self.progress_label.set_text(label)
-        self.progress_dialog.show_all()
-        gobject.timeout_add(100, self.update_progress)
-
-    def on_progress_cancel_clicked(self, obj):
-        self.progress_context.cancel()
-
-    def update_progress(self):
-        "Helper function to show progress while a work on a key is being done"
-        try:
-            status = self.progress_context.wait(0)
-            if status == None or self.progress_func(status):
-                self.new_progressbar.pulse()
-                return True
-        except errors.GPGMEError as exc:
-            self.error_message(exc)
-        
-        self.progress_context = None
-        self.progress_func = None
-        self.progress_dialog.hide()
-
-        # Let callback to be removed.
-        return False
-
-    def key_generate_done(self, status):
-        "Helper function called on the completion of a key generation"
-        if status == 0:
-            fpr = self.progress_context.op_genkey_result().fpr
-            self.progress_context.set_keylist_mode(keylist.mode.SIGS)
-            key = self.progress_context.get_key(fpr, 0)
-            data = [x.cfunc(key, True) for x in keys_columns]
-            self.keys_treeview.get_model().append(data)
-            if key.can_encrypt:
-                self.encrypt_for_keys_treeview.get_model().append(data)
-            self.update_default_keys()
-        else:
-            self.error_message(status)
-        return False
-
-    def on_new_activate(self, obj):
-        "Callback for 'New Key' menu item"
-        params = self.get_generate_params()
-        if params == None:
-            return
-
-        (key_algo, subkeys, size, userid, email,
-         comment, expire, password, backup) = params
-
-        gen_string = "<GnupgKeyParms format=\"internal\">\n" + \
-                         "Key-Type: %s\n" % key_algo + \
-                         "Key-Length: %d\n" % size
-        if subkeys:
-            gen_string += "Subkey-Type: %s\n" % subkeys + \
-                          "Subkey-Length: %d\n" % size
-        gen_string += "Name-Real: %s\n" % userid
-        if email:
-            gen_string += "Name-Email: %s\n" % email
-        if comment:
-            gen_string += "Name-Comment: %s\n" % comment
-        if expire:
-            gen_string += "Expire-Date: %s\n" % expire
-        if password:
-            gen_string += "Passphrase: %s\n" % password
-        gen_string += "</GnupgKeyParms>\n"
-
-        self.progress_context = Context()
-        self.progress_context.op_genkey_start(gen_string, None, None)
-        self.progress_func = self.key_generate_done
-        self.popup_progress_dialog(_("Generating Key..."), self.main_window)
-
-    def check_passphrase(self, passphrase, repeat_passphrase, parent):
-        """Helper function to check that enetered password satisfies our
-        requirements"""
-        if not passphrase:
-            self.error_message(_('You did not enter a passphrase.\n' +
-                                 'It is needed to protect your private key.'),
-                               parent)
-        elif repeat_passphrase != passphrase:
-            self.error_message(_('In "Passphrase" and "Repeat passphrase",\n' +
-                                 'you must enter the same passphrase.'),
-                               parent)
-        else:
-            return True
-        return False
-
-    def get_novice_generate_params(self):
-        "Helper function to get generate key parameter in Novice mode"
-        dialogs = [self.generate_userid_dialog,
-                   self.generate_email_dialog,
-                   self.generate_comment_dialog,
-                   self.generate_passphrase_dialog,
-                   self.generate_backup_dialog]
-        step = 0
-        params = None
-        while step>=0:
-            dialog = dialogs[step]
-            dialog.set_transient_for(self.main_window)
-            result = dialog.run()
-            newstep = step
-            if result == 2:
-                if step == 0:
-                    userid = self.generate_novice_userid_entry.get_text()
-                    if userid: newstep = step + 1
-                    else: self.error_message(_("Please insert your name."))
-                elif step == 1:
-                    email = self.generate_novice_email_entry.get_text()
-                    if email: newstep = step + 1
-                    else:
-                        self.error_message(_("Please insert your email address"))
-                elif step == 2:
-                    comment = self.generate_novice_comment_entry.get_text()
-                    newstep = step + 1
-                elif step == 3:
-                    passphrase=self.generate_novice_passphrase_entry.get_text()
-                    if self.check_passphrase(
-                        passphrase,
-                        self.generate_novice_repeat_passphrase_entry.get_text(),
-                        dialog):
-                        newstep = step + 1
-                elif step == 4:
-                    backup = self.generate_novice_backup_rb.get_active()
-                    params = ("DSA", "ELG-E", 1024, userid, email,
-                              comment, "", passphrase, backup)
-                    newstep = -1
-            elif result == 1:
-                newstep = step - 1
-            else:
-                newstep = -1
-
-            if newstep != step:
-                dialog.hide()
-                step = newstep
-
-        self.generate_novice_userid_entry.set_text("")
-        self.generate_novice_email_entry.set_text("")
-        self.generate_novice_comment_entry.set_text("")
-        self.generate_novice_passphrase_entry.set_text("")
-        self.generate_novice_repeat_passphrase_entry.set_text("")
-        return params
-
-    def on_new_expire_on_rb_toggled(self, expireon_rb):
-        self.new_expire_calendar.set_sensitive(expireon_rb.get_active())
-
-    def on_new_expire_after_rb_toggled(self, expireafter_rb):
-        active = expireafter_rb.get_active()
-        self.new_expire_count_entry.set_sensitive(active)
-        self.new_expire_unit_combo.set_sensitive(active)
-
-    def get_advanced_generate_params(self):
-        "Helper function to get generate key parameter in Advanced mode"
-        params = None
-        self.new_expire_unit_combo.set_active(0)
-        self.new_algorithm_combo.set_active(0)
-        self.new_key_size_combo.set_active(1)
-        self.generate_dialog.set_transient_for(self.main_window)
-        while params == None and self.generate_dialog.run() == gtk.RESPONSE_OK:
-            passphrase = self.new_passphrase_entry.get_text()
-            if not self.check_passphrase(
-                passphrase,
-                self.new_repeat_passphrase_entry.get_text(),
-                self.generate_dialog):
-                continue
-            key_algo, subkeys = {
-                'DSA and ElGamal (default)': ("DSA", "ELG-E"),
-                'DSA (sign only)': ("DSA", ""),
-                'RSA (sign only)': ("RSA", "")
-                }[self.new_algorithm_combo.child.get_text()]
-            try:
-                size = int(self.new_key_size_combo.child.get_text())
-            except ValueError:
-                self.new_key_size_combo.child.grab_focus()
-                continue
-            userid = self.new_userid_entry.get_text()
-            email = self.new_email_entry.get_text()
-            comment = self.new_comment_entry.get_text()
-            expire = ""
-            if self.new_expire_after_rb.get_active():
-                model = self.new_expire_unit_combo.get_model()
-                unit = model[(self.new_expire_unit_combo.get_active(),)][1]
-                try:
-                    value = int(self.new_expire_count_entry.get_text())
-                except ValueError:
-                    self.new_expire_count_entry.grab_focus()
-                    continue
-                expire = "%d%s" % (value, unit)
-            elif self.new_expire_on_rb.get_active():
-                (year, month, day) = self.new_expire_calendar.get_date()
-                expire = "%04d-%02d-%02d" % (year, month+1, day)
-            params = (key_algo, subkeys, size, userid, email,
-                      comment, expire, passphrase, False)
-        self.generate_dialog.hide()
-        self.new_passphrase_entry.set_text("")
-        self.new_repeat_passphrase_entry.set_text("")
-        return params
-
-    def del_key(self, key, treeview):
-        "Helper function to delete a key from a treeview list"
-        row_list = []
-        treeview.get_model().foreach(lambda m,p,i,l: l.append(m[p]), row_list)
-        for row in row_list:
-            if row[-1].key.subkeys[0].fpr == key.subkeys[0].fpr:
-                row.model.remove(row.iter)
-
-    def on_delete_activate(self, obj):
-        "Callback for 'Delete Keys' menu item"
-        message = {
-            True:  _("This key has a secret key. Deleting this key cannot be"+
-                     " undone, unless you have a backup copy."),
-            False: _("This key is a public key. Deleting this key cannot be "+
-                     "undone easily, although you may be able to get a new " +
-                     "copy  from the owner or from a key server.")
-            }
-        keytag = self.delete_key_keyinfo
-        for row in self.get_selected_keys():
-            self.delete_key_label.set_text(message[row[-1].secret])
-            table = labels2table(row[-1].key_print_labels())
-            keytag.add(table)
-            keytag.show_all()
-            if self.popup(self.delete_key_dialog) == gtk.RESPONSE_YES:
-                context = Context()
-                context.op_delete(row[-1].key, 1)
-                if row[-1].key.can_encrypt:
-                    self.del_key(row[-1].key, self.encrypt_for_keys_treeview)
-                row.model.remove(row.iter)
-                self.update_default_keys()
-                self.on_keys_changed(self.keys_treeview)
-            keytag.remove(table)
-
-    def password_cb(self, hint, desc, prev_bad, hook=None):
-        "Callback to setup verification of a passphrase"
-        if prev_bad:
-            header = _("Wrong passphrase, please try again:")
-        else:
-            header = _("Please enter the passphrase for the following key:")
-        self.password_prompt_label.set_text(header)
-        keyid, userid = hint.split(" ", 1)
-        table = labels2table([(_("User Name:"), userid),
-                              (_("Key ID:"), keyid[-8:])])
-        self.password_prompt_keyinfo.add(table)
-        self.password_prompt_keyinfo.show_all()
-        password = None
-        if self.popup(self.password_prompt_dialog) == gtk.RESPONSE_OK:
-            password = self.password_prompt_entry.get_text()
-        self.password_prompt_keyinfo.remove(table)
-        self.password_prompt_entry.set_text("")
-        if not password:
-            GPG_ERR_CANCELED = 99
-            raise errors.GPGMEError(GPG_ERR_CANCELED)
-        return password
-
-    def password_change_cb(self, hint, desc, prev_bad, hook):
-        "Callback to setup for passphrase change"
-        if not prev_bad:
-            hook["count"] += 1
-            
-        if hook["count"] == 1:
-            return self.password_cb(hint, desc, prev_bad)
-        else:
-            password = None
-            self.password_change_dialog.set_transient_for(self.main_window)
-            while password == None and \
-                      self.password_change_dialog.run() == gtk.RESPONSE_OK:
-                password = self.password_change_passphrase.get_text()
-                if not self.check_passphrase(
-                    password,
-                    self.password_change_repeat_passphrase.get_text(),
-                    self.password_change_dialog):
-                    password = None
-            self.password_change_dialog.hide()
-            self.password_change_passphrase.set_text("")
-            self.password_change_repeat_passphrase.set_text("")
-            if not password:
-                GPG_ERR_CANCELED = 99
-                raise errors.GPGMEError(GPG_ERR_CANCELED)
-            return password
-
-    def on_sign_keys_activate(self, obj):
-        "Callback for 'Sign keys' menu item"
-        context = Context()
-        context.set_passphrase_cb(self.password_cb)
-        context.set_keylist_mode(keylist.mode.SIGS)
-        keytag = self.sign_key_keyinfo
-        for row in self.get_selected_keys():
-            if row[-1].key == self.default_key:
-                continue
-            if len(row[-1].key.uids) > 1:
-                self.sign_manyuids_label.show()
-            else:
-                self.sign_manyuids_label.hide()
-            table = labels2table(row[-1].key_print_labels(True))
-            keytag.add(table)
-            keytag.show_all()
-            if self.popup(self.sign_key_dialog) == gtk.RESPONSE_YES:
-                try:
-                    sign_key(context, row[-1].key, self.default_key,
-                             self.sign_locally_cb.get_active())
-                    row[-1].key=context.get_key(row[-1].key.subkeys[0].fpr,0)
-                    self.on_keys_changed(self.keys_treeview)
-                except errors.GPGMEError as exc:
-                    self.error_message(exc)
-            keytag.remove(table)
-
-    def on_change_passphrase_clicked(self, obj, key_info):
-        "Callback for 'Change passphrase' button in editor for a private key"
-        try:
-            context = Context()
-            context.set_passphrase_cb(self.password_change_cb, {"count": 0})
-            trigger_change_password(context, key_info.key)
-        except errors.GPGMEError as exc:
-            self.error_message(exc)
-
-    def on_change_expiry_expireon_rb_toggled(self, expire_rb):
-        "Callback for 'never expire' radiobutton in editor for a private key"
-        self.change_expiry_calendar.set_sensitive(expire_rb.get_active())
-
-    def on_change_expiration_clicked(self, obj, key_info):
-        "Callback for 'Change expiration' button in editor for a private key"
-        if key_info.key.subkeys[0].expires:
-            year, month, day = time.localtime(key_info.key.subkeys[0].expires)[:3]
-            self.change_expiry_calendar.select_month(month-1, year)
-            self.change_expiry_calendar.select_day(day)
-            self.change_expiry_expireon_rb.set_active(True)
-        else:
-            self.change_expiry_never_rb.set_active(True)
-        if self.popup(self.change_expiry_dialog,
-                      self.edit_key_dialog) == gtk.RESPONSE_OK:
-            year, month, day = self.change_expiry_calendar.get_date()
-            expire = "%04d-%02d-%02d" % (year, month+1, day)
-            try:
-                context = Context()
-                context.set_passphrase_cb(self.password_cb)
-                change_key_expire(context, key_info.key, expire)
-                context.set_keylist_mode(keylist.mode.SIGS)
-                key_info.key=context.get_key(key_info.key.subkeys[0].fpr,0)
-                self.on_keys_changed(self.keys_treeview)
-                self.edit_key_date_label.set_text(key_info.key_expires_label())
-            except errors.GPGMEError as exc:
-                self.error_message(exc)
-
-    def on_edit_private_key_activate(self, obj):
-        "Callback for 'Edit Private Key' menu item"
-        keys = self.get_selected_keys()
-        if len(keys) != 1 or not keys[0][-1].secret:
-            return
-        
-        key_info = keys[0][-1]
-        table = labels2table(key_info.key_print_labels())
-        self.edit_key_date_label.set_text(key_info.key_expires_label())
-        self.edit_key_keyinfo.add(table)
-        self.edit_key_keyinfo.show_all()
-        connect1_id = self.edit_key_change_expiration.connect(
-            "clicked", self.on_change_expiration_clicked, key_info)
-        connect2_id = self.edit_key_change_passphrase.connect(
-            "clicked", self.on_change_passphrase_clicked, key_info)
-        self.popup(self.edit_key_dialog)
-        self.edit_key_change_expiration.disconnect(connect1_id)
-        self.edit_key_change_passphrase.disconnect(connect2_id)
-        self.edit_key_keyinfo.remove(table)
-
-    def on_set_owner_trust_activate(self, obj):
-        "Callback for 'Set Owner Trust' menu item"
-        keys = self.get_selected_keys()
-        if len(keys) != 1:
-            return
-
-        key_info = keys[0][-1]
-        table = labels2table(key_info.key_print_labels())
-        self.ownertrust_key.add(table)
-        self.ownertrust_key.show_all()
-        trust = key_info.key.owner_trust
-        if trust < 0 or trust not in trusts:
-            trust = validity.UNDEFINED
-        getattr(self, "ownertrust_"+trusts[trust]).set_active(True)
-        if self.popup(self.ownertrust_dialog) == gtk.RESPONSE_OK:
-            for trust, name in trusts.items():
-                if getattr(self, "ownertrust_"+name).get_active():
-                    try:
-                        context = Context()
-                        change_key_trust(context, key_info.key, trust)
-                        key_info.key.owner_trust = trust
-                        self.on_keys_changed(self.keys_treeview)
-                    except errors.GPGMEError as exc:
-                        self.error_message(exc)            
-                    break
-        self.ownertrust_key.remove(table)
-
-    def import_keys_from_data(self, data):
-        "Helper function to import keys into application from a Data() object"
-        context = Context()
-        status = context.op_import(data)
-        if status:
-            self.error_message(status)
-        else:
-            result = context.op_import_result()
-            if result.considered == 0:
-                self.error_message(_("No keys were found."))
-            else:
-                self.load_keys()
-                self.info_message(_("%i public keys read\n" +
-                                    "%i public keys imported\n" +
-                                    "%i public keys unchanged\n" +
-                                    "%i secret keys read\n" +
-                                    "%i secret keys imported\n" +
-                                    "%i secret keys unchanged") % \
-                                  (result.considered,
-                                   result.imported,
-                                   result.unchanged,
-                                   result.secret_read,
-                                   result.secret_imported,
-                                   result.secret_unchanged))
-
-    def import_from_clipboard(self, clipboard, text, data):
-        "Callback to setup extraction of data from a clipboard"
-        if text:
-            self.import_keys_from_data(Data(text))
-
-    def on_paste_activate(self, obj):
-        "Callback for 'Paste' menu item"
-        gtk.clipboard_get().request_text(self.import_from_clipboard)
-
-    def on_import_keys_activate(self, obj):
-        "Callback for 'Import Keys' menu item"
-        import_file = None
-        dialog = self.import_file_dialog
-        dialog.set_transient_for(self.main_window)
-        while import_file == None and dialog.run() == gtk.RESPONSE_OK:
-            try:
-                import_file = open(dialog.get_filename(), "rb")
-            except IOError as strerror:
-                self.error_message(strerror, dialog)
-                import_file = None
-        dialog.hide()
-        if import_file != None:
-            self.import_keys_from_data(Data(file=import_file))
-            import_file.close()
-
-    def export_selected_keys(self, armor):
-        "Helper function to export selected keys into a Data() object"
-        context = Context()
-        context.set_armor(armor)
-        export_keys = Data()
-        for row in self.get_selected_keys():
-            context.op_export(row[-1].key.subkeys[0].fpr, 0, export_keys)
-        export_keys.seek(0,0)
-        return export_keys
-        
-    def on_copy_activate(self, obj):
-        "Callback for 'Copy' menu item"
-        if self.keys_treeview.get_selection().count_selected_rows() > 0:
-            export_keys = self.export_selected_keys(True)
-            gtk.clipboard_get().set_text(export_keys.read())
-
-    def verify_output(self, filename, parent):
-        "Helper function to verify that user can write into the filename"
-        if os.path.exists(filename):
-            if os.path.isdir(filename):
-                self.error_message(_("%s is a directory")%filename, parent)
-                return False
-            else:
-                return self.yesno_message(_("The file %s already exists.\n" +
-                                            "Do you want to overwrite it?") %
-                                          filename, parent)
-        return True
-        
-    def on_export_keys_activate(self, obj):
-        "Callback for 'Export Keys' menu item"
-        if self.keys_treeview.get_selection().count_selected_rows() < 1:
-            return
-
-        export_file = None
-        dialog = self.export_file_dialog
-        dialog.set_transient_for(self.main_window)
-        while export_file == None and dialog.run() == gtk.RESPONSE_OK:
-            filename = dialog.get_filename()
-            if self.verify_output(filename, dialog):
-                try:
-                    export_file = open(filename, "wb")
-                except IOError as strerror:
-                    self.error_message(strerror, dialog)
-                    export_file = None
-        dialog.hide()
-        if export_file == None:
-            return
-
-        export_keys = self.export_selected_keys(export_armor_cb.get_active())
-        export_file.write(export_keys.read())
-        export_file.close()                
-
-    def on_files_changed(self, obj):
-        "Callback called when selection of files in filemanager is changed"
-        if self.files_treeview.get_selection().count_selected_rows() < 1:
-            value = False
-        else:
-            value = True
-        for item in (self.sign, self.verify, self.encrypt, self.decrypt):
-            item.set_sensitive(value)
-
-    def open(self, filename, complain=False):
-        "Helper function to add a file into filemanager treeview"
-        model = self.files_treeview.get_model()
-        row_list = []
-        model.foreach(lambda m,p,i,l: l.append(m[p][0]), row_list)
-        if filename in row_list:
-            if complain:
-                self.file_error_message(_("The file is already open."))
-        else:
-            item = model.append([filename])
-            self.files_treeview.get_selection().select_iter(item)
-            self.on_files_changed(None)        
-
-    def on_open_activate(self, obj):
-        "Callback for 'Open' menu item"
-        if self.file_popup(self.open_file_dialog) == gtk.RESPONSE_OK:
-            self.add_file(self.open_file_dialog.get_filename(), True)
-        self.open_file_dialog.unselect_all()
-
-    def get_selected_files(self):
-        "Helper function to return selected rows in filemanager treeview"
-        return self.get_selected_keys(self.files_treeview)
-
-    def on_clear_activate(self, obj):
-        "Callback for 'Clear' menu item"
-        for row in self.get_selected_files():
-            row.model.remove(row.iter)
-
-    def process_file_start(self, in_name, out_name):
-        "Helper function to start asynchronous processing of one file"
-        if self.verify_output(out_name, self.filemanager_window):
-            try:
-                self.in_data = Data(file=in_name)
-                self.out_data = Data()
-                self.out_name = out_name
-                self.file_func(self.in_data, self.out_data)
-            except errors.GPGMEError as exc:
-                self.file_error_message(exc)
-
-    def process_file_done(self, status):
-        "The function called when asynchronous processing of the file is done."
-        try:
-            errors.errorcheck(status)
-            self.out_data.seek(0,0)
-            out_file = file(self.out_name, "wb")
-            out_file.write(self.out_data.read())
-            out_file.close()
-            self.add_file(self.out_name)
-            if self.file_list:
-                self.process_file_start(*(self.file_list.pop(0)))
-                return True
-        except (errors.GPGMEError, IOError) as exc:
-            self.file_error_message(exc)
-
-        # Let python to free the memory.
-        self.out_data = None
-        self.in_data = None
-        self.out_name = None
-        self.file_list = []
-        self.file_func = None
-        return False
-
-    def process_files_async(self, file_list, func, label):
-        "Helper function to initialize async processing of the file list"
-        self.file_list = file_list
-        self.file_func = func
-        self.progress_func = self.process_file_done
-        self.process_file_start(*(self.file_list.pop(0)))
-        self.popup_progress_dialog(label, self.filemanager_window)
-
-    def on_sign_activate(self, obj):
-        "Callback for 'Sign' menu item"
-        files = self.get_selected_files()
-        if not files: return
-        
-        if self.file_popup(self.sign_dialog) == gtk.RESPONSE_OK:
-            context = Context()
-            context.set_passphrase_cb(self.password_cb)
-            context.set_armor(self.sign_armor_cb.get_active())
-            for rw in self.get_selected_keys(self.sign_with_keys_treeview):
-                context.signers_add(rw[-1].key)
-            for cb,md,ext in [(self.sign_normal, sig.mode.NORMAL, ".gpg"),
-                              (self.sign_clear, sig.mode.CLEAR, ".asc"),
-                              (self.sign_separate,sig.mode.DETACH,".sig")]:
-                if cb.get_active():
-                    sigmode = md
-                    sigext = ext
-                    break
-            self.progress_context = context
-            def sign(x,y):self.progress_context.op_sign_start(x,y,sigmode)
-            self.process_files_async([(f[0], f[0]+sigext) for f in files],
-                                     sign, _("Signing..."))
-
-    def verify_file_start(self, in_name, out_name):
-        "Helper function to start file signature verification process"
-        try:
-            self.in_name = in_name
-            self.out_name = out_name
-            self.signed = Data(file=self.in_name)
-            if out_name:
-                self.plain1 = Data(file=self.out_name)
-                self.plain2 = None
-            else:
-                self.plain1 = None
-                self.plain2 = Data()
-            self.progress_context.op_verify_start(self.signed, self.plain1,
-                                                  self.plain2)
-        except errors.GPGMEError as exc:
-            self.file_error_message(exc)
-
-    def verify_file_done(self, status):
-        "The function called when asynchronous file signature verify is done."
-        try:
-            errors.errorcheck(status)
-            result = self.progress_context.op_verify_result()
-
-            model = gtk.ListStore(str, str, str)
-            treeview = gtk.TreeView(model)
-            treeview.set_rules_hint(True)
-            for index, title in enumerate([_("Key ID"), _("Status"),
-                                           _("User Name")]):
-                treeview.append_column(gtk.TreeViewColumn(
-                    title, gtk.CellRendererText(), text=index))
-            for sign in result.signatures:
-                key = self.progress_context.get_key(sign.fpr, 0)
-                if key and key.uids:
-                    keyid = key.subkeys[0].keyid[-8:]
-                    userid = key.uids[0].uid
-                else:
-                    keyid = sign.fpr[-8:]
-                    userid = _("[Unknown user ID]")
-                model.append([keyid, sigsum2str(sign.summary), userid])
-                    
-            vbox = gtk.VBox()
-            if self.out_name:
-                vbox.add(gtk.Label(_("Verified data in file: %s") %
-                                   self.out_name))
-            label = gtk.Label(_("Signatures:"))
-            label.set_alignment(0, 1)
-            vbox.add(label)
-            vbox.add(treeview)
-            self.verified.append((vbox, gtk.Label(self.in_name)))
-            if self.file_list:
-                self.verify_file_start(*(self.file_list.pop(0)))
-                return True
-        except errors.GPGMEError as exc:
-            self.file_error_message(exc)
-
-        # Let python to free the memory.
-        self.signed = None
-        self.plain1 = None
-        self.plain2 = None
-        self.in_name = None
-        self.out_name = None
-        self.file_list = []
-        self.progress_dialog.hide()
-        
-        if self.verified:
-            notebook = gtk.Notebook()
-            for page in self.verified: notebook.append_page(*page)
-            self.verify_result.add(notebook)
-            self.verify_result.show_all()
-            self.file_popup(self.verify_dialog)
-            self.verify_result.remove(notebook)
-            self.verified = []
-        
-        return False
-
-    def on_verify_activate(self, obj):
-        "Callback for 'Verify' menu item"
-        files = self.get_selected_files()
-        if not files: return
-        
-        self.file_list = []
-        for onefile in files:
-            in_name = onefile[0]
-            if in_name[-4:] == ".sig":
-                out_name = in_name[:-4]
-            elif in_name[-5:] == ".sign":
-                out_name = in_name[:-5]
-            else:
-                out_name = None
-            self.file_list.append((in_name, out_name))
-        self.verified = []
-        self.progress_context = Context()
-        self.progress_func = self.verify_file_done
-        self.verify_file_start(*(self.file_list.pop(0)))
-        self.popup_progress_dialog(_("Verifying..."), self.filemanager_window)
-
-    def on_encrypt_sign_toggled(self, cb):
-        "Callback for change of the 'Sign' check box in 'Encrypt files' dialog"
-        self.encrypt_with_keys_treeview.set_sensitive(cb.get_active())
-
-    def on_encrypt_activate(self, obj):
-        "Callback for 'Encrypt' menu item"
-        files = self.get_selected_files()
-        if not files: return
-        
-        self.on_encrypt_sign_toggled(self.encrypt_sign_cb)
-        if self.file_popup(self.encrypt_dialog) == gtk.RESPONSE_OK:
-            context = Context()
-            context.set_passphrase_cb(self.password_cb)
-            if self.encrypt_armor_cb.get_active():
-                context.set_armor(True)
-                ext = ".asc"
-            else:
-                context.set_armor(False)
-                ext = ".gpg"
-            keylist = [row[-1].key for row in self.get_selected_keys(
-                self.encrypt_for_keys_treeview)]
-            if self.encrypt_sign_cb.get_active():
-                for row in self.get_selected_keys(
-                    self.encrypt_with_keys_treeview):
-                    context.signers_add(row[-1].key)
-                def encrypt(x,y):
-                    self.progress_context.op_encrypt_sign_start(
-                        keylist, 1, x, y)
-            else:
-                def encrypt(x,y):
-                    self.progress_context.op_encrypt_start(
-                        keylist, 1, x, y)
-            self.progress_context = context
-            self.process_files_async([(f[0], f[0]+sigext) for f in files],
-                                     encrypt, _("Encrypting..."))
-                
-    def on_decrypt_activate(self, obj):
-        "Callback for 'Decrypt' menu item"
-        files = self.get_selected_files()
-        if not files: return
-        
-        file_list = []
-        for onefile in self.get_selected_files():
-            in_name = onefile[0]
-            if in_name[-4:] in [".asc", ".gpg", ".pgp"]:
-                out_name = in_name[:-4]
-            else:
-                out_name = in_name + ".txt"
-            file_list.append((in_name, out_name))
-        self.process_context = Context()
-        self.process_files_async(file_list,
-                                 self.process_context.op_decrypt_start,
-                                 _("Decrypting..."))
-
-    def on_select_all_files_activate(self, obj):
-        "Callback for 'Select All' menu item in filemanager"
-        self.files_treeview.get_selection().select_all()
-
-    def on_keyring_editor_activate(self, obj):
-        "Callback for 'Keyring Editor' menu item"
-        self.main_window.show()
-
-    def on_keyring_editor_close_activate(self, obj, event=None):
-        "Callback for 'Close' menu item in Keyring Editor"
-        if self.filemanager_window.get_property("visible"):
-            self.main_window.hide()
-            return True
-        else:
-            self.on_quit_activate(None)    
-
-    def on_filemanager_activate(self, obj):
-        "Callback for 'Filemanager' menu item"
-        self.on_files_changed(None)
-        self.filemanager_window.show()
-
-    def on_filemanager_close_activate(self, obj, event=None):
-        "Callback for 'Close' menu item in Filemanager"
-        if self.main_window.get_property("visible"):
-            self.filemanager_window.hide()
-            return True
-        else:
-            self.on_quit_activate(None)
-
-    def on_about_activate(self, obj):
-        "Callback for 'About' menu item"
-        self.popup(self.about_dialog)
-
-    def __repr__(self):
-        return self.__class__.__name__
-
-    def __getattr__(self, name):
-        "Dynamic retrieval of widgets from the glade XML"
-        if name.startswith("on_"):
-            self.__dict__[name] = lambda x: sys.stderr.write(
-                _("Callback %s is not implimented yet\n") % name)
-        elif name.startswith("_"):
-            return None
-        else:
-            self.__dict__[name] = self.wtree.get_widget(name)
-            return self.__dict__[name]
-        
-    def __init__(self, path):
-        "PyGpa(path) - path is where pygpa.glade file can be found"
-        gladefile = os.path.join(path, "pygpa.glade")
-        self.wtree = gtk.glade.XML(gladefile, None, gtk.glade.textdomain())
-        self.wtree.signal_autoconnect(self)
-
-        self.default_key = None
-        self.load_keys()
-        self.setup_columns()
-        self.setup_default_views()
-        self.in_progress = {}
-        
-        gtk.main()
-
-    def on_quit_activate(self, obj):
-        gtk.main_quit()
-
-PyGpa(os.path.dirname(sys.argv[0]))