path: root/lang/py3-pyme/examples/pygpa.py

#!/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]))