def __init__(self):
self.callbacks = {}
self.conf = SlogConf()
proxy = Proxy(self.conf)
self.google = GoogleEngine(proxy)
gladefile = os.path.join(path, "google.glade")
self.wtree = gtk.glade.XML(gladefile, domain="slog")
self.wtree.signal_autoconnect({
"on_btn_clear_clicked":
self.on_btn_clear_clicked,
"on_btn_translate_clicked":
self.on_translate_clicked
})
self.vbox = self.wtree.get_widget("vbox1")
self.vbox.unparent()
self.textview = self.wtree.get_widget("textview1")
self.cmb_target = self.wtree.get_widget("combo_targets")
cell = gtk.CellRendererText()
self.cmb_target.pack_start(cell, True)
self.cmb_target.add_attribute(cell, 'text', 0)
self.model = gtk.ListStore(str, str, str)
self.cmb_target.set_model(self.model)
reload_targets(self.google.languages, self.model,
self.conf.get_google_targets())
self.cmb_target.set_active(self.conf.google_target)
def __init__(self):
self.conf = SlogConf()
self.timer = 0
self.callbacks = {}
gladefile = os.path.join(path, "xsl.glade")
self.wtree = gtk.glade.XML(gladefile, domain="slog")
self.wtree.signal_autoconnect(self)
self.vbox = self.wtree.get_widget("sl_vbox")
self.vbox.unparent()
self.word_entry = self.wtree.get_widget("word_entry")
self.treestore = gtk.TreeStore(str)
self.treeview = self.wtree.get_widget("sl_tree")
self.treeview.set_model(self.treestore)
cell = gtk.CellRendererText()
cell.set_property("ellipsize", pango.ELLIPSIZE_END)
tvcolumn = gtk.TreeViewColumn("Result", cell, text=0)
self.treeview.append_column(tvcolumn)
self.treestore.append(None, [_("Enter the word, please...")])
self.word_selection = self.treeview.get_selection()
self.word_selection.connect("changed", self.on_wordlist_changed)
self.treemodel_lock = threading.Lock()
def __load(self):
conf = SlogConf()
used_dict_list = conf.get_used_dicts()
spy_file_list = conf.get_spy_dicts()
dict_list = []
try:
dict_list = os.listdir(conf.sl_dicts_dir)
except OSError, msg:
print str(msg)
def __load(self): conf = SlogConf() used_dict_list = conf.get_used_dicts() spy_file_list = conf.get_spy_dicts() dict_list = [] try: dict_list = os.listdir(conf.sl_dicts_dir) except OSError, msg: print str(msg)
def __init__(self):
gtk.VBox.__init__(self, False, 0)
self.conf = SlogConf()
self.timer = 0
self.callbacks = {}
tooltips = gtk.Tooltips()
hbox = gtk.HBox(False, 0)
hbox.set_border_width(4)
self.pack_start(hbox, False, False, 0)
self.word_entry = gtk.Entry()
self.word_entry.set_size_request(60, -1)
self.word_entry.connect("activate", self.on_word_entry_activate)
self.word_entry.connect("changed", self.on_word_entry_changed)
hbox.pack_start(self.word_entry, True, True, 4)
btn_clear = ghlp.create_speed_button(gtk.STOCK_CLEAR)
tooltips.set_tip(btn_clear, _("Clear field"))
btn_clear.connect("clicked", self.on_btn_clear_clicked)
hbox.pack_start(btn_clear, False, False, 0)
sw = gtk.ScrolledWindow()
sw.set_border_width(4)
sw.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
sw.set_shadow_type(gtk.SHADOW_IN)
self.pack_start(sw, True, True, 0)
self.treestore = gtk.TreeStore(str)
self.treeview = gtk.TreeView(self.treestore)
self.treeview.set_headers_visible(False)
self.treeview.set_rules_hint(True)
self.treeview.connect("row-activated", self.on_row_activated)
sw.add(self.treeview)
cell = gtk.CellRendererText()
cell.set_property("ellipsize", pango.ELLIPSIZE_END)
tvcolumn = gtk.TreeViewColumn("Result", cell, text=0)
self.treeview.append_column(tvcolumn)
self.treestore.append(None, [_("Enter the word, please...")])
self.word_selection = self.treeview.get_selection()
self.word_selection.connect("changed", self.on_wordlist_changed)
img = gtk.image_new_from_stock(gtk.STOCK_FIND, gtk.ICON_SIZE_MENU)
btn_fuzzy = gtk.Button(_("Fuzzy Search"))
btn_fuzzy.set_image(img)
btn_fuzzy.set_border_width(4)
btn_fuzzy.connect("clicked", self.on_btn_fuzzy_clicked)
self.pack_start(btn_fuzzy, False, True, 0)
def __init__(self):
self.conf = SlogConf()
gladefile = os.path.join(DATA_DIR, "slog.glade")
self.wtree = gtk.glade.XML(gladefile, domain="slog")
self.wtree.signal_autoconnect(self)
# Create tray icon
self.status_icon = gtk.status_icon_new_from_file(get_icon("slog.png"))
self.status_icon.set_tooltip(APP_NAME)
self.status_icon.connect("popup-menu", self.on_tray_popup)
self.status_icon.connect("activate", self.on_tray_clicked)
# Create main window
self.window = self.wtree.get_widget("mainWindow")
self.window.set_icon_from_file(get_icon("slog.png"))
self.window.set_title("%s %s" % (APP_NAME, VERSION))
self.window.set_size_request(396, 256)
# Restore window settings
(width, height) = self.conf.get_size()
(left, top) = self.conf.get_pos()
if left != 0 or top != 0:
self.window.move(left, top)
self.window.set_default_size(width, height)
self.wtree.get_widget("hPaned").set_position(self.conf.paned)
self.sidebar = self.wtree.get_widget("sideBar")
#Create Spy object
self.spy = Spy()
mb_menuitem_spy = self.wtree.get_widget("menuItemSpy1")
tray_menuitem_spy = self.wtree.get_widget("menuItemSpy2")
self.spy_action = gtk.ToggleAction("Spy", "_Spy", "Spy Service", None)
self.spy_action.connect("activate", self.on_spy_clicked)
self.spy_action.connect_proxy(tray_menuitem_spy)
self.spy_action.connect_proxy(mb_menuitem_spy)
if self.conf.tray_start == 0:
self.window.show_all()
if self.conf.spy_auto == 1:
self.spy_action.activate()
plugin_dir = os.path.join(DATA_DIR, "plugins")
self.plugin_manager = PluginManager()
self.plugin_manager.add_plugin_dir(plugin_dir)
self.plugin_manager.scan_for_plugins()
self.plugin_view = PluginView(self.wtree, self.plugin_manager)
self.__load_plugins()
def __init__(self):
self.callbacks = {}
self.conf = SlogConf()
proxy = Proxy(self.conf)
self.google = GoogleEngine(proxy)
gladefile = os.path.join(path, "google.glade")
self.wtree = gtk.glade.XML(gladefile, domain="slog")
self.wtree.signal_autoconnect({
"on_btn_clear_clicked" : self.on_btn_clear_clicked,
"on_btn_translate_clicked" : self.on_translate_clicked
})
self.vbox = self.wtree.get_widget("vbox1")
self.vbox.unparent()
self.textview = self.wtree.get_widget("textview1")
self.cmb_target = self.wtree.get_widget("combo_targets")
cell = gtk.CellRendererText()
self.cmb_target.pack_start(cell, True)
self.cmb_target.add_attribute(cell, 'text', 0)
self.model = gtk.ListStore(str, str, str)
self.cmb_target.set_model(self.model)
reload_targets(self.google.languages, self.model, self.conf.get_google_targets())
self.cmb_target.set_active(self.conf.google_target)
class GoogleView(object):
def __init__(self):
""" Google View Widget """
self.callbacks = {}
self.conf = SlogConf()
proxy = Proxy(self.conf)
self.google = GoogleEngine(proxy)
gladefile = os.path.join(path, "google.glade")
self.wtree = gtk.glade.XML(gladefile, domain="slog")
self.wtree.signal_autoconnect({
"on_btn_clear_clicked" : self.on_btn_clear_clicked,
"on_btn_translate_clicked" : self.on_translate_clicked
})
self.vbox = self.wtree.get_widget("vbox1")
self.vbox.unparent()
self.textview = self.wtree.get_widget("textview1")
self.cmb_target = self.wtree.get_widget("combo_targets")
cell = gtk.CellRendererText()
self.cmb_target.pack_start(cell, True)
self.cmb_target.add_attribute(cell, 'text', 0)
self.model = gtk.ListStore(str, str, str)
self.cmb_target.set_model(self.model)
reload_targets(self.google.languages, self.model, self.conf.get_google_targets())
self.cmb_target.set_active(self.conf.google_target)
def __fire_translate_changed(self, translate):
""" Оповестить обработчики о том, что перевод изменился"""
callback = self.callbacks["translate_it"]
if callback is not None:
callback("Google", translate)
def __fire_status_changed(self, message, needClear=False):
""" Оповестить обработчики о том, что статус изменился"""
callback = self.callbacks["changed"]
if callback is not None:
gobject.idle_add(callback, message)
if needClear:
gobject.timeout_add(5000, self.__fire_status_changed, "")
# Thread function
def request_google(self, src, dst, text):
try:
translate = self.google.translate(src, dst, text)
except urllib2.URLError, err:
msg = "Google error: %s" % err
print msg
self.__fire_status_changed(msg, True)
else:
def __load_plugins(self): for pname in self.plugins.get_available(): plugin = self.plugins.get_plugin(pname) enabled = pname in SlogConf().get_enabled_plugins() iter = self.model.append() self.model.set(iter, 0, enabled, 1, plugin.plugin_name)
def run(self):
if not os.path.exists(SL_TMP_DIR):
os.mkdir(SL_TMP_DIR)
try:
import socket
socket.setdefaulttimeout(5)
conf = SlogConf()
proxy = Proxy(conf)
downloader = proxy.get_ftp_downloader()
file_dist = os.path.join(SL_TMP_DIR, self.__filename)
url_dict = FTP_DICTS_URL + "/" + self.__filename
downloader.retrieve(url_dict, file_dist, self.url_hook_report)
except IOError, ioerr:
state = DL_STATE_ERROR
if self.__cancelled:
msg = "Download cancelled!"
state = DL_STATE_CANCEL
else:
t = ioerr.strerror
msg = "Network error while trying to get url: %s\n%s" % (
url_dict, t)
self.__finish(state, msg)
return
def __init__(self):
self.conf = SlogConf()
self.timer = 0
self.callbacks = {}
gladefile = os.path.join(path, "xsl.glade")
self.wtree = gtk.glade.XML(gladefile, domain="slog")
self.wtree.signal_autoconnect(self)
self.vbox = self.wtree.get_widget("sl_vbox")
self.vbox.unparent()
self.word_entry = self.wtree.get_widget("word_entry")
self.treestore = gtk.TreeStore(str)
self.treeview = self.wtree.get_widget("sl_tree")
self.treeview.set_model(self.treestore)
cell = gtk.CellRendererText()
cell.set_property("ellipsize", pango.ELLIPSIZE_END)
tvcolumn = gtk.TreeViewColumn("Result", cell, text=0)
self.treeview.append_column(tvcolumn)
self.treestore.append(None, [_("Enter the word, please...")])
self.word_selection = self.treeview.get_selection()
self.word_selection.connect("changed", self.on_wordlist_changed)
self.treemodel_lock = threading.Lock()
def __init__(self, filename, event, name="DictInstaller"):
threading.Thread.__init__(self, name=name)
self.__filename = filename
self.__event = event
self.__cancelled = False
self.__callbacks = []
self.conf = SlogConf()
def __init__(self, parent, plugins):
self.__plugins = plugins
gladefile = os.path.join(DATA_DIR, "slog.glade")
self.wtree = gtk.glade.XML(gladefile, "prefDialog", domain="slog")
self.wtree.signal_autoconnect(self)
self.dialog = self.wtree.get_widget("prefDialog")
self.dialog.set_transient_for(parent)
self.conf = SlogConf()
# Creating combobox for modifer keys
model = gtk.ListStore(str)
model.append(["Ctrl"])
model.append(["Alt"])
model.append(["Shift"])
model.append(["Win"])
model.append(["None"])
combo_keys = self.wtree.get_widget("comboKeys")
cell = gtk.CellRendererText()
combo_keys.pack_start(cell, True)
combo_keys.add_attribute(cell, "text", 0)
combo_keys.set_model(model)
combo_keys.set_active(self.conf.mod_key)
self.entry_proxy_host = self.wtree.get_widget("entryProxyHost")
self.entry_proxy_host.set_text(self.conf.proxy_host)
self.entry_proxy_port = self.wtree.get_widget("entryProxyPort")
self.entry_proxy_port.set_value(self.conf.proxy_port)
self.__setup_checkbox("chkSpyAutoStart", self.conf.spy_auto)
self.__setup_checkbox("chkTrayExit", self.conf.tray_exit)
self.__setup_checkbox("chkTrayInfo", self.conf.tray_info)
self.__setup_checkbox("chkTrayStart", self.conf.tray_start)
self.__setup_checkbox("chkProxyServer", self.conf.proxy)
self.plugins_model = gtk.ListStore(bool, str)
treeview = self.wtree.get_widget("tablePlugins")
treeview.set_model(self.plugins_model)
renderer = gtk.CellRendererToggle()
renderer.connect('toggled', self.on_item_toggled, self.plugins_model)
column = gtk.TreeViewColumn(_("Enabled"), renderer, active=0)
column.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
column.set_fixed_width(64)
treeview.append_column(column)
column = gtk.TreeViewColumn(_("Name"), gtk.CellRendererText(), text=1)
treeview.append_column(column)
self.__selection = treeview.get_selection()
self.__selection.connect("changed", self.on_plugin_clicked)
gobject.idle_add(self.__load_plugins)
class GoogleView(object):
def __init__(self):
self.callbacks = {}
self.conf = SlogConf()
proxy = Proxy(self.conf)
self.google = GoogleEngine(proxy)
gladefile = os.path.join(path, "google.glade")
self.wtree = gtk.glade.XML(gladefile, domain="slog")
self.wtree.signal_autoconnect({
"on_btn_clear_clicked":
self.on_btn_clear_clicked,
"on_btn_translate_clicked":
self.on_translate_clicked
})
self.vbox = self.wtree.get_widget("vbox1")
self.vbox.unparent()
self.textview = self.wtree.get_widget("textview1")
self.cmb_target = self.wtree.get_widget("combo_targets")
cell = gtk.CellRendererText()
self.cmb_target.pack_start(cell, True)
self.cmb_target.add_attribute(cell, 'text', 0)
self.model = gtk.ListStore(str, str, str)
self.cmb_target.set_model(self.model)
reload_targets(self.google.languages, self.model,
self.conf.get_google_targets())
self.cmb_target.set_active(self.conf.google_target)
def __fire_translate_changed(self, translate):
callback = self.callbacks["translate_it"]
if callback is not None:
callback("Google", translate)
def __fire_status_changed(self, message, needClear=False):
callback = self.callbacks["changed"]
if callback is not None:
gobject.idle_add(callback, message)
if needClear:
gobject.timeout_add(5000, self.__fire_status_changed, "")
# Thread function
def request_google(self, src, dst, text):
try:
translate = self.google.translate(src, dst, text)
except urllib2.URLError, err:
msg = "Google error: %s" % err
print msg
self.__fire_status_changed(msg, True)
else:
def download_repo_file(self, event):
try:
import socket
socket.setdefaulttimeout(5)
conf = SlogConf()
proxy = Proxy(conf)
downloader = proxy.get_ftp_downloader()
downloader.retrieve(FTP_REPO_URL, REPO_FILE)
except IOError, e:
print str(e)
def __init__(self):
gtk.VBox.__init__(self, False, 0)
self.conf = SlogConf()
self.timer = 0
self.callbacks = {}
tooltips = gtk.Tooltips()
hbox = gtk.HBox(False, 0)
hbox.set_border_width(4)
self.pack_start(hbox, False, False, 0)
self.word_entry = gtk.Entry()
self.word_entry.set_size_request(60, -1)
self.word_entry.connect("activate", self.on_word_entry_activate)
self.word_entry.connect("changed", self.on_word_entry_changed)
hbox.pack_start(self.word_entry, True, True, 4)
btn_clear = ghlp.create_speed_button(gtk.STOCK_CLEAR)
tooltips.set_tip(btn_clear, _("Clear field"))
btn_clear.connect("clicked", self.on_btn_clear_clicked)
hbox.pack_start(btn_clear, False, False, 0)
sw = gtk.ScrolledWindow()
sw.set_border_width(4)
sw.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
sw.set_shadow_type(gtk.SHADOW_IN)
self.pack_start(sw, True, True, 0)
self.treestore = gtk.TreeStore(str)
self.treeview = gtk.TreeView(self.treestore)
self.treeview.set_headers_visible(False)
self.treeview.set_rules_hint(True)
self.treeview.connect("row-activated", self.on_row_activated)
sw.add(self.treeview)
cell = gtk.CellRendererText()
cell.set_property("ellipsize", pango.ELLIPSIZE_END)
tvcolumn = gtk.TreeViewColumn("Result", cell, text=0)
self.treeview.append_column(tvcolumn)
self.treestore.append(None, [_("Enter the word, please...")])
self.word_selection = self.treeview.get_selection()
self.word_selection.connect("changed", self.on_wordlist_changed)
img = gtk.image_new_from_stock(gtk.STOCK_FIND, gtk.ICON_SIZE_MENU)
btn_fuzzy = gtk.Button(_("Fuzzy Search"))
btn_fuzzy.set_image(img)
btn_fuzzy.set_border_width(4)
btn_fuzzy.connect("clicked", self.on_btn_fuzzy_clicked)
self.pack_start(btn_fuzzy, False, True, 0)
def __init__(self):
self.conf = SlogConf()
gladefile = os.path.join(DATA_DIR, "slog.glade")
self.wtree = gtk.glade.XML(gladefile, domain="slog")
self.wtree.signal_autoconnect(self)
# Create tray icon
self.status_icon = gtk.status_icon_new_from_file(get_icon("slog.png"))
self.status_icon.set_tooltip(APP_NAME)
self.status_icon.connect("popup-menu", self.on_tray_popup)
self.status_icon.connect("activate", self.on_tray_clicked)
# Create main window
self.window = self.wtree.get_widget("mainWindow")
self.window.set_icon_from_file(get_icon("slog_logo.png"))
self.window.set_title("%s %s" % (APP_NAME, VERSION))
self.window.set_size_request(396, 256)
# Restore window settings
(width, height) = self.conf.get_size()
(left, top) = self.conf.get_pos()
if left != 0 or top != 0:
self.window.move(left, top)
self.window.set_default_size(width, height)
self.wtree.get_widget("hPaned").set_position(self.conf.paned)
self.sidebar = self.wtree.get_widget("sideBar")
#Create Spy object
self.spy = Spy()
mb_menuitem_spy = self.wtree.get_widget("menuItemSpy1")
tray_menuitem_spy = self.wtree.get_widget("menuItemSpy2")
self.spy_action = gtk.ToggleAction("Spy", "_Spy", "Spy Service", None)
self.spy_action.connect("activate", self.on_spy_clicked)
self.spy_action.connect_proxy(tray_menuitem_spy)
self.spy_action.connect_proxy(mb_menuitem_spy)
if self.conf.tray_start == 0:
self.window.show_all()
if self.conf.spy_auto == 1:
self.spy_action.activate()
plugin_dir = os.path.join(DATA_DIR, "plugins")
self.plugin_manager = PluginManager()
self.plugin_manager.add_plugin_dir(plugin_dir)
self.plugin_manager.scan_for_plugins()
self.plugin_view = PluginView(self.wtree, self.plugin_manager)
self.__load_plugins()
def configure(self, window):
conf = SlogConf()
dlg = gtk.Dialog(plugin_name, window, 0,
(gtk.STOCK_OK, gtk.RESPONSE_OK))
hbox = gtk.HBox(False, 8)
hbox.set_border_width(8)
dlg.vbox.pack_start(hbox, False, False, 0)
stock = gtk.image_new_from_stock(gtk.STOCK_DIALOG_QUESTION,
gtk.ICON_SIZE_DIALOG)
hbox.pack_start(stock, False, False, 0)
label = gtk.Label(_("Dictionaries dir:"))
hbox.pack_start(label, False, False, 0)
dir_entry = gtk.Entry()
dir_entry.set_text(conf.sl_dicts_dir)
hbox.pack_start(dir_entry, True, True, 0)
btn_browse = gtk.Button("...")
btn_browse.connect("clicked", self.on_browse_clicked, window,
dir_entry)
hbox.pack_start(btn_browse, False, False, 0)
label.set_mnemonic_widget(dir_entry)
dlg.show_all()
response = dlg.run()
if response == gtk.RESPONSE_OK:
ddir = dir_entry.get_text()
if not os.path.exists(ddir):
ghlp.show_error(window, _("Path not exists!"))
conf.sl_dicts_dir = ddir
dlg.destroy()
def configure(self, window):
conf = SlogConf()
dlg = gtk.Dialog(plugin_name, window, 0, (gtk.STOCK_OK, gtk.RESPONSE_OK))
hbox = gtk.HBox(False, 8)
hbox.set_border_width(8)
dlg.vbox.pack_start(hbox, False, False, 0)
stock = gtk.image_new_from_stock(
gtk.STOCK_DIALOG_QUESTION,
gtk.ICON_SIZE_DIALOG)
hbox.pack_start(stock, False, False, 0)
label = gtk.Label(_("Dictionaries dir:"))
hbox.pack_start(label, False, False, 0)
dir_entry = gtk.Entry()
dir_entry.set_text(conf.sl_dicts_dir)
hbox.pack_start(dir_entry, True, True, 0)
btn_browse = gtk.Button("...")
btn_browse.connect("clicked", self.on_browse_clicked, window, dir_entry)
hbox.pack_start(btn_browse, False, False, 0)
label.set_mnemonic_widget(dir_entry)
dlg.show_all()
response = dlg.run()
if response == gtk.RESPONSE_OK:
ddir = dir_entry.get_text()
if not os.path.exists(ddir):
ghlp.show_error(window, _("Path not exists!"))
conf.sl_dicts_dir = ddir
dlg.destroy()
def __init__(self, parent, plugins):
gtk.Dialog.__init__(self, _("Preferences"), parent,
gtk.DIALOG_MODAL, (gtk.STOCK_CLOSE, gtk.RESPONSE_OK))
self.conf = SlogConf()
notebook = gtk.Notebook()
self.vbox.pack_start(notebook, True, True, 0)
main_page = self.__create_main_page()
notebook.append_page(main_page, gtk.Label(_("Main")))
main_page.show()
plugins_page = PluginsView(self, plugins)
notebook.append_page(plugins_page, gtk.Label(_("Plugins")))
plugins_page.show()
notebook.show()
def __init__(self):
gtk.VBox.__init__(self, False, 0)
self.callbacks = {}
self.google = GoogleEngine()
self.conf = SlogConf()
tooltips = gtk.Tooltips()
hbox = gtk.HBox(False, 4)
hbox.set_border_width(4)
self.pack_start(hbox, False, False, 0)
self.cmb_target = gtk.combo_box_new_text()
for target in self.google.get_targets():
self.cmb_target.append_text(target)
self.cmb_target.set_active(self.conf.google_target)
hbox.pack_start(self.cmb_target, True, True, 0)
btn_clear = ghlp.create_speed_button(gtk.STOCK_CLEAR)
btn_clear.connect("clicked", self.on_btn_clear_clicked)
hbox.pack_start(btn_clear, False, False, 0)
sw = gtk.ScrolledWindow()
sw.set_border_width(4)
sw.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
sw.set_shadow_type(gtk.SHADOW_IN)
self.pack_start(sw, True, True, 0)
self.textview = gtk.TextView()
self.textview.set_wrap_mode(gtk.WRAP_WORD)
sw.add(self.textview)
btn_translate = gtk.Button(_("Translate"))
btn_translate.set_border_width(4)
btn_translate.connect("clicked", self.on_translate_clicked)
self.pack_start(btn_translate, False, True, 0)
def __init__(self, parent):
gtk.Dialog.__init__(self, _("Manage dictionaries"), parent,
gtk.DIALOG_DESTROY_WITH_PARENT,
(gtk.STOCK_CLOSE, gtk.RESPONSE_OK))
self.tooltips = gtk.Tooltips()
hbox = gtk.HBox(False, 0)
self.vbox.pack_start(hbox, True, True, 0)
frame_left = gtk.Frame(_(" Available "))
frame_left.set_border_width(4)
frame_right = gtk.Frame(_(" Installed "))
frame_right.set_border_width(4)
hbox_left = gtk.HBox(False, 4)
hbox_left.set_border_width(4)
hbox_right = gtk.HBox(False, 4)
hbox_right.set_border_width(4)
self.list_avail = AvailDataModel()
sw1, tree_avail = self.__create_treeview(self.list_avail)
avail_selection = tree_avail.get_selection()
cell = gtk.CellRendererText()
cell.set_property("ellipsize", pango.ELLIPSIZE_END)
column = gtk.TreeViewColumn(_("Name"), cell, text=COL_A_NAME)
column.set_sizing(gtk.TREE_VIEW_COLUMN_AUTOSIZE)
column.set_expand(True)
column.set_resizable(True)
column.set_sort_column_id(COL_A_NAME)
column.set_reorderable(True)
tree_avail.append_column(column)
column = gtk.TreeViewColumn(_("Target"),
gtk.CellRendererText(),
text=COL_A_TARGET)
column.set_sort_column_id(COL_A_TARGET)
column.set_reorderable(True)
tree_avail.append_column(column)
column = gtk.TreeViewColumn(_("Size"),
gtk.CellRendererText(),
text=COL_A_SIZE)
column.set_sort_column_id(COL_A_SIZE)
column.set_reorderable(True)
tree_avail.append_column(column)
#self.list_avail.set_sort_column_id(COL_A_TARGET, gtk.SORT_ASCENDING)
self.list_inst = InstDataModel()
sw2, tree_inst = self.__create_treeview(self.list_inst)
inst_selection = tree_inst.get_selection()
renderer = gtk.CellRendererToggle()
renderer.connect('toggled', self.on_item_toggled, self.list_inst)
renderer.set_data("column", COL_I_USED)
column = gtk.TreeViewColumn(_("Used"), renderer, active=COL_I_USED)
column.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
column.set_fixed_width(64)
tree_inst.append_column(column)
renderer = gtk.CellRendererToggle()
renderer.connect('toggled', self.on_item_toggled, self.list_inst)
renderer.set_data("column", COL_I_SPY)
column = gtk.TreeViewColumn(_("Spy"), renderer, active=COL_I_SPY)
column.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
column.set_fixed_width(64)
tree_inst.append_column(column)
cell = gtk.CellRendererText()
cell.set_property("ellipsize", pango.ELLIPSIZE_END)
column = gtk.TreeViewColumn(_("Name"), cell, text=COL_I_NAME)
column.set_sizing(gtk.TREE_VIEW_COLUMN_AUTOSIZE)
column.set_expand(True)
column.set_resizable(True)
column.set_sort_column_id(COL_I_NAME)
column.set_reorderable(True)
tree_inst.append_column(column)
column = gtk.TreeViewColumn(_("Target"),
gtk.CellRendererText(),
text=COL_I_TARGET)
column.set_sort_column_id(COL_I_TARGET)
column.set_reorderable(True)
tree_inst.append_column(column)
btn_fresh = self.__create_button(gtk.STOCK_REFRESH, _("Refresh"))
btn_fresh.connect("clicked", self.on_btn_fresh_clicked)
btn_right = self.__create_button(gtk.STOCK_GO_FORWARD, _("Add"))
btn_right.connect("clicked", self.on_btn_right_clicked,
avail_selection)
btn_left = self.__create_button(gtk.STOCK_GO_BACK, _("Remove"))
btn_left.connect("clicked", self.on_btn_left_clicked, inst_selection)
btn_up = self.__create_button(gtk.STOCK_GO_UP, _("Up"))
btn_up.connect("clicked", self.on_btn_up_clicked, inst_selection)
btn_down = self.__create_button(gtk.STOCK_GO_DOWN, _("Down"))
btn_down.connect("clicked", self.on_btn_down_clicked, inst_selection)
vbox_left, vbox_1 = self.__create_bbox()
vbox_right, vbox_2 = self.__create_bbox()
vbox_1.pack_start(btn_fresh, False, False, 0)
vbox_1.pack_start(btn_right, False, False, 0)
vbox_2.pack_start(btn_up, False, False, 0)
vbox_2.pack_start(btn_left, False, False, 0)
vbox_2.pack_start(btn_down, False, False, 0)
hbox_left.pack_start(sw1, True, True, 0)
hbox_left.pack_start(vbox_left, False, False, 0)
hbox_right.pack_start(vbox_right, False, False, 0)
hbox_right.pack_start(sw2, True, True, 0)
frame_left.add(hbox_left)
frame_right.add(hbox_right)
hbox.pack_start(frame_left, True, True, 0)
hbox.pack_start(frame_right, True, True, 0)
hbox.show_all()
self.conf = SlogConf()
def __init__(self, parent):
gladefile = os.path.join(DATA_DIR, "slog.glade")
self.wtree = gtk.glade.XML(gladefile, "dictsDialog", domain="slog")
self.wtree.signal_autoconnect(self)
self.dialog = self.wtree.get_widget("dictsDialog")
self.conf = SlogConf()
self.list_avail = AvailDataModel()
#self.avail_filter = self.list_avail.filter_new()
tree_avail = self.wtree.get_widget("tableAvailDicts")
tree_avail.set_model(self.list_avail)
self.__avail_selection = tree_avail.get_selection()
cell = gtk.CellRendererText()
cell.set_property("ellipsize", pango.ELLIPSIZE_END)
column = gtk.TreeViewColumn(_("Name"), cell, text=COL_A_NAME)
column.set_sizing(gtk.TREE_VIEW_COLUMN_AUTOSIZE)
column.set_expand(True)
column.set_resizable(True)
column.set_sort_column_id(COL_A_NAME)
column.set_reorderable(True)
tree_avail.append_column(column)
column = gtk.TreeViewColumn(_("Target"),
gtk.CellRendererText(),
text=COL_A_TARGET)
column.set_sort_column_id(COL_A_TARGET)
column.set_reorderable(True)
tree_avail.append_column(column)
column = gtk.TreeViewColumn(_("Size"),
gtk.CellRendererText(),
text=COL_A_SIZE)
column.set_sort_column_id(COL_A_SIZE)
column.set_reorderable(True)
tree_avail.append_column(column)
self.list_avail.set_sort_column_id(COL_A_TARGET, gtk.SORT_ASCENDING)
self.list_inst = InstDataModel()
self.list_inst.connect("row-changed", self.on_row_changed)
self.list_inst.connect("row-inserted", self.on_row_inserted)
tree_inst = self.wtree.get_widget("tableInstDicts")
tree_inst.set_model(self.list_inst)
self.__inst_selection = tree_inst.get_selection()
renderer = gtk.CellRendererToggle()
renderer.connect('toggled', self.on_item_toggled, self.list_inst)
renderer.set_data("column", COL_I_USED)
column = gtk.TreeViewColumn(_("Used"), renderer, active=COL_I_USED)
column.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
column.set_fixed_width(64)
tree_inst.append_column(column)
renderer = gtk.CellRendererToggle()
renderer.connect('toggled', self.on_item_toggled, self.list_inst)
renderer.set_data("column", COL_I_SPY)
column = gtk.TreeViewColumn(_("Spy"), renderer, active=COL_I_SPY)
column.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
column.set_fixed_width(64)
tree_inst.append_column(column)
cell = gtk.CellRendererText()
cell.set_property("ellipsize", pango.ELLIPSIZE_END)
column = gtk.TreeViewColumn(_("Name"), cell, text=COL_I_NAME)
column.set_sizing(gtk.TREE_VIEW_COLUMN_AUTOSIZE)
column.set_expand(True)
column.set_resizable(True)
column.set_sort_column_id(COL_I_NAME)
column.set_reorderable(True)
tree_inst.append_column(column)
column = gtk.TreeViewColumn(_("Target"),
gtk.CellRendererText(),
text=COL_I_TARGET)
column.set_sort_column_id(COL_I_TARGET)
column.set_reorderable(True)
tree_inst.append_column(column)
class MainWindow(object):
def __init__(self):
self.conf = SlogConf()
gladefile = os.path.join(DATA_DIR, "slog.glade")
self.wtree = gtk.glade.XML(gladefile, domain="slog")
self.wtree.signal_autoconnect(self)
# Create tray icon
self.status_icon = gtk.status_icon_new_from_file(get_icon("slog.png"))
self.status_icon.set_tooltip(APP_NAME)
self.status_icon.connect("popup-menu", self.on_tray_popup)
self.status_icon.connect("activate", self.on_tray_clicked)
# Create main window
self.window = self.wtree.get_widget("mainWindow")
self.window.set_icon_from_file(get_icon("slog.png"))
self.window.set_title("%s %s" % (APP_NAME, VERSION))
self.window.set_size_request(396, 256)
# Restore window settings
(width, height) = self.conf.get_size()
(left, top) = self.conf.get_pos()
if left != 0 or top != 0:
self.window.move(left, top)
self.window.set_default_size(width, height)
self.wtree.get_widget("hPaned").set_position(self.conf.paned)
self.sidebar = self.wtree.get_widget("sideBar")
#Create Spy object
self.spy = Spy()
mb_menuitem_spy = self.wtree.get_widget("menuItemSpy1")
tray_menuitem_spy = self.wtree.get_widget("menuItemSpy2")
self.spy_action = gtk.ToggleAction("Spy", "_Spy", "Spy Service", None)
self.spy_action.connect("activate", self.on_spy_clicked)
self.spy_action.connect_proxy(tray_menuitem_spy)
self.spy_action.connect_proxy(mb_menuitem_spy)
if self.conf.tray_start == 0:
self.window.show_all()
if self.conf.spy_auto == 1:
self.spy_action.activate()
plugin_dir = os.path.join(DATA_DIR, "plugins")
self.plugin_manager = PluginManager()
self.plugin_manager.add_plugin_dir(plugin_dir)
self.plugin_manager.scan_for_plugins()
self.plugin_view = PluginView(self.wtree, self.plugin_manager)
self.__load_plugins()
def __load_plugins(self):
list_enabled = self.conf.get_enabled_plugins()
if list_enabled == []:
return
self.sidebar.remove_page(0)
for plugin in self.plugin_manager.get_available():
if plugin not in list_enabled:
continue
self.plugin_manager.enable_plugin(plugin)
while gtk.events_pending():
gtk.main_iteration(False)
self.plugin_view.set_active(self.conf.get_engine())
def __create_notify(self, title, message, timeout=3000):
n = pynotify.Notification(title, message)
n.attach_to_status_icon(self.status_icon)
n.set_urgency(pynotify.URGENCY_NORMAL)
n.set_timeout(timeout)
n.set_icon_from_pixbuf(gtk.gdk.pixbuf_new_from_file_at_size(get_icon("slog.png"), 48, 48))
return n
#################
# GUI Callbacks #
#################
def on_window_closed(self, widget, data=None):
if self.conf.tray_exit != 0:
self.window.destroy(widget, data)
if self.conf.tray_info != 0:
n = self.__create_notify(APP_NAME, "Close in system tray")
if not n.show():
print "Failed to send notification"
self.window.hide()
return True
def on_window_exit(self, widget, data=None):
(width, height) = self.window.get_size()
(left, top) = self.window.get_position()
self.conf.paned = self.wtree.get_widget("hPaned").get_position()
self.conf.set_size(width, height)
self.conf.set_pos(left, top)
self.conf.set_engine(self.plugin_view.get_active())
self.conf.save()
gtk.main_quit()
def on_spy_clicked(self, widget):
if widget.get_active():
self.status_icon.set_from_file(get_icon("slog_spy.png"))
self.spy.start()
else:
self.status_icon.set_from_file(get_icon("slog.png"))
self.spy.stop()
def on_preferences_activate(self, widget, data=None):
dialog = PrefsDialog(self.window, self.plugin_manager)
dialog.run()
dialog.destroy()
def on_dicts_manage_activate(self, widget, data=None):
dialog = DictsDialog(self.window)
dialog.run()
dialog.destroy()
def on_about_activate(self, action):
dialog = gtk.AboutDialog()
dialog.set_name(APP_NAME)
dialog.set_logo(gtk.gdk.pixbuf_new_from_file(get_icon("slog.png")))
dialog.set_copyright("\302\251 Copyright 2007,2008 Renat Nasyrov ([email protected])")
dialog.set_website(WEBSITE)
dialog.set_version(VERSION)
dialog.set_license(LICENSE)
dialog.connect ("response", lambda d, r: d.destroy())
dialog.show()
def on_tray_clicked(self, args):
self.window_toggle()
def on_tray_popup(self, icon, event_button, event_time):
tray_menu = self.wtree.get_widget("trayMenu")
tray_menu.popup(None, None, gtk.status_icon_position_menu, event_button, event_time, self.status_icon)
###########
# Private #
###########
def window_toggle(self):
if self.window.get_property("visible"):
self.window.hide()
else:
self.window.show_all()
gobject.idle_add(self.window_present_and_focus)
def window_present_and_focus(self):
self.window.present()
self.window.grab_focus()
def run(self):
self.ipc = SLogDBus(self)
if not pynotify.init("SLog Notification"):
print "Failed init python-notify module"
gobject.threads_init()
gtk.gdk.threads_enter()
gtk.main()
gtk.gdk.threads_leave()
def __init__(self): self.timer = 0; self.prev_selection = "" self.clipboard = gtk.clipboard_get(gdk.SELECTION_PRIMARY) self.conf = SlogConf() self.spy_view = None
class Spy:
def __init__(self):
self.timer = 0;
self.prev_selection = ""
self.clipboard = gtk.clipboard_get(gdk.SELECTION_PRIMARY)
self.conf = SlogConf()
self.spy_view = None
#Thread function
def __fuzzy_search(self, word):
""" Выполняет нечеткий поиск слова <word>, в словарях
отмеченных в конфигурации как <spy>. Выводит результат
как список, элементами которого являются гипер-ссылки на
похожие слова.
"""
all_lines = []
used_dicts = self.conf.get_sl_spy_dicts()
for dic in used_dicts:
filename = self.conf.get_dic_path(dic)
lines = libsl.find_word(word, libsl.SL_FIND_FUZZY, filename)
if lines != []:
html = []
html.append(libsl.get_dict_html_block(filename))
html.append("<dl>")
for item in lines:
html.append("<li><a href='%s|%s'>%s</a></li>" % (dic, item, item))
html.append("</dl>")
all_lines.append("".join(html))
# Cancelled..
if not self.spy_view.get_property("visible"):
return
translate = "<body>%s</body>" % ("".join(all_lines))
gobject.idle_add(self.spy_view.set_translate, word, translate)
def __get_translate(self, word):
""" Возвращает доступные статьи перевода слова <word>, в словарях
отмеченных в конфигурации как <spy>.
"""
all_lines = []
used_dicts = self.conf.get_sl_spy_dicts()
for dic in used_dicts:
filename = self.conf.get_dic_path(dic)
lines = libsl.find_word(word, libsl.SL_FIND_MATCH, filename)
if lines != []:
all_lines.append("".join(lines))
return all_lines
def __on_clipboard_text_received(self, clipboard, text, data):
""" Обработчик события появления текста в буффере обмена.
Выполняет поиск слова, если не найдено ни одной статьи перевода,
в отдельном потоке запускается функция нечеткого поиска.
"""
if text is None:
return
selection = text.lower().strip()
if selection == "" or selection == self.prev_selection:
return
self.prev_selection = selection
word = selection
all_lines = self.__get_translate(word)
if len(all_lines) == 0:
translate = """
<body>This word not found.<br/>
<span style='color:#4c4c4c; font-size:80%'>Searching similar words...</span>
</body>"""
thread = threading.Thread(target = self.__fuzzy_search, args = (word, ))
thread.start()
else:
translate = "<body>%s</body>" % ("".join(all_lines))
self.spy_view.set_translate(word, translate)
self.spy_view.popup()
def __on_timer_timeout(self):
if self.timer == 0:
return False
display = gdk.display_get_default()
screen, x, y, mask = display.get_pointer()
mask = mask & ((1<<13)-1)
if mask & self.conf.get_mod_key():
if self.spy_view.get_property("visible") is False:
self.clipboard.request_text(self.__on_clipboard_text_received)
else:
if self.spy_view.get_property("visible"):
self.spy_view.hide()
return True
def __on_url_click(self, document, link):
dic, word = link.split("|")
filename = self.conf.get_dic_path(dic)
lines = libsl.find_word(word, libsl.SL_FIND_MATCH, filename)
translate = "<body>%s</body>" % ("".join(lines))
self.spy_view.set_translate(word, translate)
def start(self):
self.spy_view = SpyView()
self.spy_view.set_url_callback(self.__on_url_click)
self.clipboard.set_text("")
self.prev_selection = ""
self.timer = gobject.timeout_add(300, self.__on_timer_timeout)
def stop(self):
self.timer = 0
self.spy_view.destroy()
def __init__(self): self.timer = 0; self.prev_selection = "" self.clipboard = gtk.clipboard_get(gdk.SELECTION_PRIMARY) self.conf = SlogConf() self.spy_view = None
class Spy:
def __init__(self):
self.timer = 0;
self.prev_selection = ""
self.clipboard = gtk.clipboard_get(gdk.SELECTION_PRIMARY)
self.conf = SlogConf()
self.spy_view = None
#Thread function
def __fuzzy_search(self, word):
""" Выполняет нечеткий поиск слова <word>, в словарях
отмеченных в конфигурации как <spy>. Выводит результат
как список, элементами которого являются гипер-ссылки на
похожие слова.
"""
all_lines = []
used_dicts = self.conf.get_sl_spy_dicts()
for dic in used_dicts:
filename = self.conf.get_dic_path(dic)
lines = libsl.find_word(word, libsl.SL_FIND_FUZZY, filename)
if lines != []:
html = []
html.append(libsl.get_dict_html_block(filename))
html.append("<dl>")
for item in lines:
html.append("<li><a href='%s|%s'>%s</a></li>" % (dic, item, item))
html.append("</dl>")
all_lines.append("".join(html))
# Cancelled..
if not self.spy_view.get_property("visible"):
return
translate = "<body>%s</body>" % ("".join(all_lines))
gobject.idle_add(self.spy_view.set_translate, word, translate)
def __get_translate(self, word):
""" Возвращает доступные статьи перевода слова <word>, в словарях
отмеченных в конфигурации как <spy>.
"""
all_lines = []
used_dicts = self.conf.get_sl_spy_dicts()
for dic in used_dicts:
filename = self.conf.get_dic_path(dic)
lines = libsl.find_word(word, libsl.SL_FIND_MATCH, filename)
if lines != []:
all_lines.append("".join(lines))
return all_lines
def __on_clipboard_text_received(self, clipboard, text, data):
""" Обработчик события появления текста в буффере обмена.
Выполняет поиск слова, если не найдено ни одной статьи перевода,
в отдельном потоке запускается функция нечеткого поиска.
"""
if text is None:
return
selection = text.lower().strip()
if selection == "" or selection == self.prev_selection:
return
self.prev_selection = selection
word = selection
all_lines = self.__get_translate(word)
if len(all_lines) == 0:
translate = """
<body>This word not found.<br/>
<span style='color:#4c4c4c; font-size:80%'>Searching similar words...</span>
</body>"""
thread = threading.Thread(target = self.__fuzzy_search, args = (word, ))
thread.start()
else:
translate = "<body>%s</body>" % ("".join(all_lines))
self.spy_view.set_translate(word, translate)
self.spy_view.popup()
def __on_timer_timeout(self):
if self.timer == 0:
return False
display = gdk.display_get_default()
screen, x, y, mask = display.get_pointer()
mask = mask & ((1<<13)-1)
if mask & self.conf.get_mod_key():
if self.spy_view.get_property("visible") is False:
self.clipboard.request_text(self.__on_clipboard_text_received)
else:
if self.spy_view.get_property("visible"):
self.spy_view.hide()
return True
def __on_url_click(self, view, url, type_):
dic, word = url.split("|")
filename = self.conf.get_dic_path(dic)
lines = libsl.find_word(word, libsl.SL_FIND_MATCH, filename)
translate = "<body>%s</body>" % ("".join(lines))
self.spy_view.set_translate(word, translate)
def start(self):
self.spy_view = SpyView()
self.spy_view.set_url_callback(self.__on_url_click)
self.clipboard.set_text("")
self.prev_selection = ""
self.timer = gobject.timeout_add(300, self.__on_timer_timeout)
def stop(self):
self.timer = 0
self.spy_view.destroy()
class Spy:
def __init__(self):
self.timer = 0;
self.prev_selection = ""
self.clipboard = gtk.clipboard_get(gdk.SELECTION_PRIMARY)
self.conf = SlogConf()
self.spy_view = None
#Thread function
def __fuzzy_search(self, word):
all_lines = []
used_dicts = self.conf.get_spy_dicts()
for dic in used_dicts:
filename = self.conf.get_dic_path(dic)
lines = libsl.find_word(word, libsl.SL_FIND_FUZZY, filename)
if lines != []:
html = []
html.append(libsl.get_dict_html_block(filename))
html.append("<dl>")
for item in lines:
html.append("<li><a href='%s|%s'>%s</a></li>" % (dic, item, item))
html.append("</dl>")
all_lines.append("".join(html))
# Cancelled..
if not self.spy_view.get_property("visible"):
return
translate = "<body>%s</body>" % ("".join(all_lines))
gobject.idle_add(self.spy_view.set_translate, word, translate)
def __get_translate(self, word):
all_lines = []
used_dicts = self.conf.get_spy_dicts()
for dic in used_dicts:
filename = self.conf.get_dic_path(dic)
lines = libsl.find_word(word, libsl.SL_FIND_MATCH, filename)
if lines != []:
all_lines.append("".join(lines))
return all_lines
def __on_clipboard_text_received(self, clipboard, text, data):
if text is None:
return
selection = text.lower().strip()
if selection == "" or selection == self.prev_selection:
return
self.prev_selection = selection
#TODO: remove characters like , . ;
word = selection
all_lines = self.__get_translate(word)
if len(all_lines) == 0:
translate = """
<body>This word not found.<br/>
<span style='color:#4c4c4c; font-size:80%'>Searching similar words...</span>
</body>"""
thread = threading.Thread(target = self.__fuzzy_search, args = (word, ))
thread.start()
else:
translate = "<body>%s</body>" % ("".join(all_lines))
self.spy_view.set_translate(word, translate)
self.spy_view.popup()
def __on_timer_timeout(self):
if self.timer == 0:
return False
display = gdk.display_get_default()
screen, x, y, mask = display.get_pointer()
mask = mask & ((1<<13)-1)
if mask & self.conf.get_mod_key():
if self.spy_view.get_property("visible") is False:
self.clipboard.request_text(self.__on_clipboard_text_received)
else:
if self.spy_view.get_property("visible"):
self.spy_view.hide()
return True
def __on_url_click(self, view, url, type_):
dic, word = url.split("|")
filename = self.conf.get_dic_path(dic)
lines = libsl.find_word(word, libsl.SL_FIND_MATCH, filename)
translate = "<body>%s</body>" % ("".join(lines))
self.spy_view.set_translate(word, translate)
def start(self):
self.spy_view = SpyView()
self.spy_view.set_url_callback(self.__on_url_click)
self.clipboard.set_text("")
self.prev_selection = ""
self.timer = gobject.timeout_add(300, self.__on_timer_timeout)
def stop(self):
self.timer = 0
self.spy_view.destroy()
class SLView(object):
def __init__(self):
self.conf = SlogConf()
self.timer = 0
self.callbacks = {}
gladefile = os.path.join(path, "xsl.glade")
self.wtree = gtk.glade.XML(gladefile, domain="slog")
self.wtree.signal_autoconnect(self)
self.vbox = self.wtree.get_widget("sl_vbox")
self.vbox.unparent()
self.word_entry = self.wtree.get_widget("word_entry")
self.treestore = gtk.TreeStore(str)
self.treeview = self.wtree.get_widget("sl_tree")
self.treeview.set_model(self.treestore)
cell = gtk.CellRendererText()
cell.set_property("ellipsize", pango.ELLIPSIZE_END)
tvcolumn = gtk.TreeViewColumn("Result", cell, text=0)
self.treeview.append_column(tvcolumn)
self.treestore.append(None, [_("Enter the word, please...")])
self.word_selection = self.treeview.get_selection()
self.word_selection.connect("changed", self.on_wordlist_changed)
self.treemodel_lock = threading.Lock()
def __fire_status_changed(self, message):
callback = self.callbacks["changed"]
if callback is not None:
callback(message)
def __fire_translate_changed(self, word, translate, newtab):
callback = self.callbacks["translate_it"]
if callback is not None:
callback(word, translate, newtab)
def on_btn_fuzzy_clicked(self, widget, data=None):
word = self.word_entry.get_text()
self.find_all(word, mode = libsl.SL_FIND_FUZZY)
def on_btn_clear_clicked(self, widget, data=None):
self.word_entry.set_text("")
self.word_entry.grab_focus()
self.treestore.clear()
self.treestore.append(None, [_("Enter the word, please...")])
self.__fire_status_changed("")
def on_timer_timeout(self):
self.timer = 0;
word = self.word_entry.get_text().lower()
self.find_all(word)
def on_word_changed(self, widget, data=None):
if self.timer == 0:
self.timer = gobject.timeout_add(500, self.on_timer_timeout)
def on_word_entry_activate(self, widget, data=None):
word = widget.get_text().lower()
self.find_all(word)
def on_wordlist_changed(self, selection):
model, treeiter = selection.get_selected()
self.find_word(treeiter, newTab = False)
def __thread_find(self, node, word, mode, dict_name):
filename = self.conf.get_dic_path(dict_name)
items = libsl.find_word(word, mode, filename)
self.treemodel_lock.acquire()
if items == []:
self.treestore.remove(node)
else:
for item in items:
self.treestore.append(node, [item])
self.treemodel_lock.release()
def __get_n_rows(self):
""" Функция возвращает количество выведенных
вариантов слова
"""
count = 0
it = self.treestore.get_iter_first()
while it:
if self.treestore.iter_has_child(it):
ti = self.treestore.iter_children(it)
while ti:
count += 1
ti = self.treestore.iter_next(ti)
it = self.treestore.iter_next(it)
return count
def find_all(self, word, mode = libsl.SL_FIND_LIST):
""" Выполняет поиск слова в отмеченных пользователем
словарях, и добавляет найденные варианты на панель
результатов поиска.
"""
if word == "":
return
self.treestore.clear()
threads = []
dictionaries = self.conf.get_sl_used_dicts()
for dic in dictionaries:
node = self.treestore.append(None, [dic])
t = threading.Thread(target = self.__thread_find, args = (node, word, mode, dic))
threads.append(t)
t.start()
for t in threads:
t.join()
count = self.__get_n_rows()
if count>0:
self.treeview.expand_all()
self.word_selection.select_path((0,0))
else:
self.treestore.append(None, [_("This word is not found")])
self.__fire_status_changed(_("Total: %i") % (count))
def find_word(self, treeiter, mode = libsl.SL_FIND_MATCH, newTab=False):
if treeiter is None:
return
parentiter = self.treestore.iter_parent(treeiter)
if parentiter is None:
return
word = self.treestore.get_value(treeiter, 0)
dic = self.treestore.get_value(parentiter, 0)
filename = self.conf.get_dic_path(dic)
lines = libsl.find_word(word, mode, filename)
translate = "<body>%s</body>" % ("".join(lines))
self.__fire_translate_changed(word, translate, newTab)
# ================================ SLog Plugins API ============================
def connect(self, event, callback):
self.callbacks[event] = callback
def get_panel(self):
return self.vbox
def grab_focus(self):
self.word_entry.grab_focus()
def clear(self):
self.word_entry.set_text("")
self.word_entry.grab_focus()
def configure(self, window):
dlg = self.wtree.get_widget("pref_dialog")
dlg.set_transient_for(window)
dir_entry = self.wtree.get_widget("entry_folder")
dir_entry.set_current_folder(self.conf.sl_dicts_dir)
response = dlg.run()
if response == gtk.RESPONSE_OK:
self.conf.sl_dicts_dir = dir_entry.get_filename()
dlg.hide()
class SLView(object):
def __init__(self):
self.conf = SlogConf()
self.timer = 0
self.callbacks = {}
gladefile = os.path.join(path, "xsl.glade")
self.wtree = gtk.glade.XML(gladefile, domain="slog")
self.wtree.signal_autoconnect(self)
self.vbox = self.wtree.get_widget("sl_vbox")
self.vbox.unparent()
self.word_entry = self.wtree.get_widget("word_entry")
self.treestore = gtk.TreeStore(str)
self.treeview = self.wtree.get_widget("sl_tree")
self.treeview.set_model(self.treestore)
cell = gtk.CellRendererText()
cell.set_property("ellipsize", pango.ELLIPSIZE_END)
tvcolumn = gtk.TreeViewColumn("Result", cell, text=0)
self.treeview.append_column(tvcolumn)
self.treestore.append(None, [_("Enter the word, please...")])
self.word_selection = self.treeview.get_selection()
self.word_selection.connect("changed", self.on_wordlist_changed)
self.treemodel_lock = threading.Lock()
def __fire_status_changed(self, message):
callback = self.callbacks["changed"]
if callback is not None:
callback(message)
def __fire_translate_changed(self, word, translate, newtab):
callback = self.callbacks["translate_it"]
if callback is not None:
callback(word, translate, newtab)
def on_btn_fuzzy_clicked(self, widget, data=None):
word = self.word_entry.get_text()
self.find_all(word, mode=libsl.SL_FIND_FUZZY)
def on_btn_clear_clicked(self, widget, data=None):
self.word_entry.set_text("")
self.word_entry.grab_focus()
self.treestore.clear()
self.treestore.append(None, [_("Enter the word, please...")])
self.__fire_status_changed("")
def on_timer_timeout(self):
self.timer = 0
word = self.word_entry.get_text().lower()
self.find_all(word)
def on_word_changed(self, widget, data=None):
if self.timer == 0:
self.timer = gobject.timeout_add(500, self.on_timer_timeout)
def on_word_entry_activate(self, widget, data=None):
word = widget.get_text().lower()
self.find_all(word)
def on_wordlist_changed(self, selection):
model, treeiter = selection.get_selected()
self.find_word(treeiter, newTab=False)
def __thread_find(self, node, word, mode, dict_name):
filename = self.conf.get_dic_path(dict_name)
items = libsl.find_word(word, mode, filename)
self.treemodel_lock.acquire()
if items == []:
self.treestore.remove(node)
else:
for item in items:
self.treestore.append(node, [item])
self.treemodel_lock.release()
def __get_n_rows(self):
""" Функция возвращает количество выведенных
вариантов слова
"""
count = 0
it = self.treestore.get_iter_first()
while it:
if self.treestore.iter_has_child(it):
ti = self.treestore.iter_children(it)
while ti:
count += 1
ti = self.treestore.iter_next(ti)
it = self.treestore.iter_next(it)
return count
def find_all(self, word, mode=libsl.SL_FIND_LIST):
""" Выполняет поиск слова в отмеченных пользователем
словарях, и добавляет найденные варианты на панель
результатов поиска.
"""
if word == "":
return
self.treestore.clear()
threads = []
dictionaries = self.conf.get_sl_used_dicts()
for dic in dictionaries:
node = self.treestore.append(None, [dic])
t = threading.Thread(target=self.__thread_find,
args=(node, word, mode, dic))
threads.append(t)
t.start()
for t in threads:
t.join()
count = self.__get_n_rows()
if count > 0:
self.treeview.expand_all()
self.word_selection.select_path((0, 0))
else:
self.treestore.append(None, [_("This word is not found")])
self.__fire_status_changed(_("Total: %i") % (count))
def find_word(self, treeiter, mode=libsl.SL_FIND_MATCH, newTab=False):
if treeiter is None:
return
parentiter = self.treestore.iter_parent(treeiter)
if parentiter is None:
return
word = self.treestore.get_value(treeiter, 0)
dic = self.treestore.get_value(parentiter, 0)
filename = self.conf.get_dic_path(dic)
lines = libsl.find_word(word, mode, filename)
translate = "<body>%s</body>" % ("".join(lines))
self.__fire_translate_changed(word, translate, newTab)
# ================================ SLog Plugins API ============================
def connect(self, event, callback):
self.callbacks[event] = callback
def get_panel(self):
return self.vbox
def grab_focus(self):
self.word_entry.grab_focus()
def clear(self):
self.word_entry.set_text("")
def configure(self, window):
dlg = self.wtree.get_widget("pref_dialog")
dlg.set_transient_for(window)
dir_entry = self.wtree.get_widget("entry_folder")
dir_entry.set_current_folder(self.conf.sl_dicts_dir)
response = dlg.run()
if response == gtk.RESPONSE_OK:
self.conf.sl_dicts_dir = dir_entry.get_filename()
dlg.hide()
class SLView(gtk.VBox):
def __init__(self):
gtk.VBox.__init__(self, False, 0)
self.conf = SlogConf()
self.timer = 0
self.callbacks = {}
tooltips = gtk.Tooltips()
hbox = gtk.HBox(False, 0)
hbox.set_border_width(4)
self.pack_start(hbox, False, False, 0)
self.word_entry = gtk.Entry()
self.word_entry.set_size_request(60, -1)
self.word_entry.connect("activate", self.on_word_entry_activate)
self.word_entry.connect("changed", self.on_word_entry_changed)
hbox.pack_start(self.word_entry, True, True, 4)
btn_clear = ghlp.create_speed_button(gtk.STOCK_CLEAR)
tooltips.set_tip(btn_clear, _("Clear field"))
btn_clear.connect("clicked", self.on_btn_clear_clicked)
hbox.pack_start(btn_clear, False, False, 0)
sw = gtk.ScrolledWindow()
sw.set_border_width(4)
sw.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
sw.set_shadow_type(gtk.SHADOW_IN)
self.pack_start(sw, True, True, 0)
self.treestore = gtk.TreeStore(str)
self.treeview = gtk.TreeView(self.treestore)
self.treeview.set_headers_visible(False)
self.treeview.set_rules_hint(True)
self.treeview.connect("row-activated", self.on_row_activated)
sw.add(self.treeview)
cell = gtk.CellRendererText()
cell.set_property("ellipsize", pango.ELLIPSIZE_END)
tvcolumn = gtk.TreeViewColumn("Result", cell, text=0)
self.treeview.append_column(tvcolumn)
self.treestore.append(None, [_("Enter the word, please...")])
self.word_selection = self.treeview.get_selection()
self.word_selection.connect("changed", self.on_wordlist_changed)
img = gtk.image_new_from_stock(gtk.STOCK_FIND, gtk.ICON_SIZE_MENU)
btn_fuzzy = gtk.Button(_("Fuzzy Search"))
btn_fuzzy.set_image(img)
btn_fuzzy.set_border_width(4)
btn_fuzzy.connect("clicked", self.on_btn_fuzzy_clicked)
self.pack_start(btn_fuzzy, False, True, 0)
def __fire_status_changed(self, message):
callback = self.callbacks["changed"]
if callback is not None:
callback(message)
def __fire_translate_changed(self, word, translate, newtab):
callback = self.callbacks["translate_it"]
if callback is not None:
callback(word, translate, newtab)
def on_row_activated(self, widget, path, column, data=None):
treeiter = self.treestore.get_iter(path)
self.find_word(treeiter, newTab = True)
def on_btn_fuzzy_clicked(self, widget, data=None):
word = self.word_entry.get_text().lower()
self.find_list(word, mode = libsl.SL_FIND_FUZZY)
def on_btn_clear_clicked(self, widget, data=None):
self.word_entry.set_text("")
self.word_entry.grab_focus()
self.treestore.clear()
self.treestore.append(None, [_("Enter the word, please...")])
self.__fire_status_changed("")
def on_timer_timeout(self):
self.timer = 0;
word = self.word_entry.get_text().lower()
self.find_list(word)
def on_word_entry_changed(self, widget, data=None):
if self.timer == 0:
self.timer = gobject.timeout_add(500, self.on_timer_timeout)
def on_word_entry_activate(self, widget, data=None):
word = widget.get_text().lower()
self.find_list(word)
def on_wordlist_changed(self, selection):
model, treeiter = selection.get_selected()
self.find_word(treeiter, newTab = False)
def find_list(self, word, mode = libsl.SL_FIND_LIST):
if word == "":
return
count = 0
model = self.treestore
model.clear()
dictionaries = self.conf.get_used_dicts()
for dic in dictionaries:
filename = self.conf.get_dic_path(dic)
items = libsl.find_word(word, mode, filename)
count += len(items)
if items == []:
continue
root_node = model.append(None, [dic])
for item in items:
model.append(root_node, [item])
if count>0:
self.treeview.expand_all()
self.word_selection.select_path((0,0))
else:
model.append(None, [_("This word is not found")])
self.__fire_status_changed(_("Total: %i") % (count))
def find_word(self, treeiter, mode = libsl.SL_FIND_MATCH, newTab=False):
if treeiter is None:
return
parentiter = self.treestore.iter_parent(treeiter)
if parentiter is None:
return
word = self.treestore.get_value(treeiter, 0)
dic = self.treestore.get_value(parentiter, 0)
filename = self.conf.get_dic_path(dic)
lines = libsl.find_word(word, mode, filename)
translate = "<body>%s</body>" % ("".join(lines))
self.__fire_translate_changed(word, translate, newTab)
def connect(self, event, callback):
self.callbacks[event] = callback
def grab_focus(self):
self.word_entry.grab_focus()
# ================================ Plugin support ============================
def configure(self, window):
conf = SlogConf()
dlg = gtk.Dialog(plugin_name, window, 0, (gtk.STOCK_OK, gtk.RESPONSE_OK))
hbox = gtk.HBox(False, 8)
hbox.set_border_width(8)
dlg.vbox.pack_start(hbox, False, False, 0)
stock = gtk.image_new_from_stock(
gtk.STOCK_DIALOG_QUESTION,
gtk.ICON_SIZE_DIALOG)
hbox.pack_start(stock, False, False, 0)
label = gtk.Label(_("Dictionaries dir:"))
hbox.pack_start(label, False, False, 0)
dir_entry = gtk.Entry()
dir_entry.set_text(conf.sl_dicts_dir)
hbox.pack_start(dir_entry, True, True, 0)
btn_browse = gtk.Button("...")
btn_browse.connect("clicked", self.on_browse_clicked, window, dir_entry)
hbox.pack_start(btn_browse, False, False, 0)
label.set_mnemonic_widget(dir_entry)
dlg.show_all()
response = dlg.run()
if response == gtk.RESPONSE_OK:
ddir = dir_entry.get_text()
if not os.path.exists(ddir):
ghlp.show_error(window, _("Path not exists!"))
conf.sl_dicts_dir = ddir
dlg.destroy()
def on_browse_clicked(self, widget, window, entry):
chooser = gtk.FileChooserDialog("Open..", window, gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER,
(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_OK, gtk.RESPONSE_OK))
dicts_dir = entry.get_text()
if os.path.exists(dicts_dir):
chooser.set_current_folder(dicts_dir)
response = chooser.run()
if response == gtk.RESPONSE_OK:
path = chooser.get_filename()
entry.set_text(path)
chooser.destroy()
class MainWindow(object):
def __init__(self):
self.conf = SlogConf()
gladefile = os.path.join(DATA_DIR, "slog.glade")
self.wtree = gtk.glade.XML(gladefile, domain="slog")
self.wtree.signal_autoconnect(self)
# Create tray icon
self.status_icon = gtk.status_icon_new_from_file(get_icon("slog.png"))
self.status_icon.set_tooltip(APP_NAME)
self.status_icon.connect("popup-menu", self.on_tray_popup)
self.status_icon.connect("activate", self.on_tray_clicked)
# Create main window
self.window = self.wtree.get_widget("mainWindow")
self.window.set_icon_from_file(get_icon("slog_logo.png"))
self.window.set_title("%s %s" % (APP_NAME, VERSION))
self.window.set_size_request(396, 256)
# Restore window settings
(width, height) = self.conf.get_size()
(left, top) = self.conf.get_pos()
if left != 0 or top != 0:
self.window.move(left, top)
self.window.set_default_size(width, height)
self.wtree.get_widget("hPaned").set_position(self.conf.paned)
self.sidebar = self.wtree.get_widget("sideBar")
#Create Spy object
self.spy = Spy()
mb_menuitem_spy = self.wtree.get_widget("menuItemSpy1")
tray_menuitem_spy = self.wtree.get_widget("menuItemSpy2")
self.spy_action = gtk.ToggleAction("Spy", "_Spy", "Spy Service", None)
self.spy_action.connect("activate", self.on_spy_clicked)
self.spy_action.connect_proxy(tray_menuitem_spy)
self.spy_action.connect_proxy(mb_menuitem_spy)
if self.conf.tray_start == 0:
self.window.show_all()
if self.conf.spy_auto == 1:
self.spy_action.activate()
plugin_dir = os.path.join(DATA_DIR, "plugins")
self.plugin_manager = PluginManager()
self.plugin_manager.add_plugin_dir(plugin_dir)
self.plugin_manager.scan_for_plugins()
self.plugin_view = PluginView(self.wtree, self.plugin_manager)
self.__load_plugins()
def __load_plugins(self):
list_enabled = self.conf.get_enabled_plugins()
if list_enabled == []:
return
self.sidebar.remove_page(0)
for plugin in self.plugin_manager.get_available():
if plugin not in list_enabled:
continue
self.plugin_manager.enable_plugin(plugin)
while gtk.events_pending():
gtk.main_iteration(False)
self.plugin_view.set_active(self.conf.get_engine())
def __create_notify(self, title, message, timeout=3000):
n = pynotify.Notification(title, message)
n.attach_to_status_icon(self.status_icon)
n.set_urgency(pynotify.URGENCY_NORMAL)
n.set_timeout(timeout)
n.set_icon_from_pixbuf(gtk.gdk.pixbuf_new_from_file_at_size(get_icon("slog.png"), 48, 48))
return n
#################
# GUI Callbacks #
#################
def on_window_closed(self, widget, data=None):
if self.conf.tray_exit != 0:
self.window.destroy(widget, data)
if self.conf.tray_info != 0:
n = self.__create_notify(APP_NAME, "Closed to system tray")
if not n.show():
print "Warning: Failed to show notification"
self.window.hide()
return True
def on_window_exit(self, widget, data=None):
(width, height) = self.window.get_size()
(left, top) = self.window.get_position()
self.conf.paned = self.wtree.get_widget("hPaned").get_position()
self.conf.set_size(width, height)
self.conf.set_pos(left, top)
self.conf.set_engine(self.plugin_view.get_active_engine())
self.conf.save()
gtk.main_quit()
def on_spy_clicked(self, widget):
if widget.get_active():
self.status_icon.set_from_file(get_icon("slog_spy.png"))
self.spy.start()
else:
self.status_icon.set_from_file(get_icon("slog.png"))
self.spy.stop()
def on_preferences_activate(self, widget, data=None):
dialog = PrefsDialog(self.window, self.plugin_manager)
dialog.run()
dialog.destroy()
def on_dicts_manage_activate(self, widget, data=None):
dialog = DictsDialog(self.window)
dialog.run()
dialog.destroy()
def on_about_activate(self, action):
dialog = gtk.AboutDialog()
dialog.set_name(APP_NAME)
dialog.set_logo(gtk.gdk.pixbuf_new_from_file(get_icon("slog_logo.png")))
dialog.set_copyright("\302\251 Copyright 2007-2009, Renat Nasyrov ([email protected])")
dialog.set_website(WEBSITE)
dialog.set_version(VERSION)
dialog.set_license(LICENSE)
dialog.connect("response", lambda d, r: d.destroy())
dialog.show()
def on_tray_clicked(self, args):
self.window_toggle()
def on_tray_popup(self, icon, event_button, event_time):
tray_menu = self.wtree.get_widget("trayMenu")
tray_menu.popup(None, None, gtk.status_icon_position_menu, event_button, event_time, self.status_icon)
###########
# Private #
###########
def window_toggle(self):
if self.window.get_property("visible"):
self.window.hide()
else:
self.window.show_all()
gobject.idle_add(self.window_present_and_focus)
def window_present_and_focus(self):
self.window.present()
self.window.grab_focus()
def run(self):
self.ipc = SLogDBus(self)
if not pynotify.init("SLog Notification"):
print "Failed init python-notify module"
gobject.threads_init()
gtk.gdk.threads_enter()
gtk.main()
gtk.gdk.threads_leave()
def __init__(self):
gtk.ListStore.__init__(self, bool, bool, str, str)
self.conf = SlogConf()
self.__load()
class SLView(gtk.VBox):
def __init__(self):
gtk.VBox.__init__(self, False, 0)
self.conf = SlogConf()
self.timer = 0
self.callbacks = {}
tooltips = gtk.Tooltips()
hbox = gtk.HBox(False, 0)
hbox.set_border_width(4)
self.pack_start(hbox, False, False, 0)
self.word_entry = gtk.Entry()
self.word_entry.set_size_request(60, -1)
self.word_entry.connect("activate", self.on_word_entry_activate)
self.word_entry.connect("changed", self.on_word_entry_changed)
hbox.pack_start(self.word_entry, True, True, 4)
btn_clear = ghlp.create_speed_button(gtk.STOCK_CLEAR)
tooltips.set_tip(btn_clear, _("Clear field"))
btn_clear.connect("clicked", self.on_btn_clear_clicked)
hbox.pack_start(btn_clear, False, False, 0)
sw = gtk.ScrolledWindow()
sw.set_border_width(4)
sw.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
sw.set_shadow_type(gtk.SHADOW_IN)
self.pack_start(sw, True, True, 0)
self.treestore = gtk.TreeStore(str)
self.treeview = gtk.TreeView(self.treestore)
self.treeview.set_headers_visible(False)
self.treeview.set_rules_hint(True)
self.treeview.connect("row-activated", self.on_row_activated)
sw.add(self.treeview)
cell = gtk.CellRendererText()
cell.set_property("ellipsize", pango.ELLIPSIZE_END)
tvcolumn = gtk.TreeViewColumn("Result", cell, text=0)
self.treeview.append_column(tvcolumn)
self.treestore.append(None, [_("Enter the word, please...")])
self.word_selection = self.treeview.get_selection()
self.word_selection.connect("changed", self.on_wordlist_changed)
img = gtk.image_new_from_stock(gtk.STOCK_FIND, gtk.ICON_SIZE_MENU)
btn_fuzzy = gtk.Button(_("Fuzzy Search"))
btn_fuzzy.set_image(img)
btn_fuzzy.set_border_width(4)
btn_fuzzy.connect("clicked", self.on_btn_fuzzy_clicked)
self.pack_start(btn_fuzzy, False, True, 0)
def __fire_status_changed(self, message):
callback = self.callbacks["changed"]
if callback is not None:
callback(message)
def __fire_translate_changed(self, word, translate, newtab):
callback = self.callbacks["translate_it"]
if callback is not None:
callback(word, translate, newtab)
def on_row_activated(self, widget, path, column, data=None):
treeiter = self.treestore.get_iter(path)
self.find_word(treeiter, newTab=True)
def on_btn_fuzzy_clicked(self, widget, data=None):
word = self.word_entry.get_text().lower()
self.find_list(word, mode=libsl.SL_FIND_FUZZY)
def on_btn_clear_clicked(self, widget, data=None):
self.word_entry.set_text("")
self.word_entry.grab_focus()
self.treestore.clear()
self.treestore.append(None, [_("Enter the word, please...")])
self.__fire_status_changed("")
def on_timer_timeout(self):
self.timer = 0
word = self.word_entry.get_text().lower()
self.find_list(word)
def on_word_entry_changed(self, widget, data=None):
if self.timer == 0:
self.timer = gobject.timeout_add(500, self.on_timer_timeout)
def on_word_entry_activate(self, widget, data=None):
word = widget.get_text().lower()
self.find_list(word)
def on_wordlist_changed(self, selection):
model, treeiter = selection.get_selected()
self.find_word(treeiter, newTab=False)
def find_list(self, word, mode=libsl.SL_FIND_LIST):
if word == "":
return
count = 0
model = self.treestore
model.clear()
dictionaries = self.conf.get_used_dicts()
for dic in dictionaries:
filename = self.conf.get_dic_path(dic)
items = libsl.find_word(word, mode, filename)
count += len(items)
if items == []:
continue
root_node = model.append(None, [dic])
for item in items:
model.append(root_node, [item])
if count > 0:
self.treeview.expand_all()
self.word_selection.select_path((0, 0))
else:
model.append(None, [_("This word is not found")])
self.__fire_status_changed(_("Total: %i") % (count))
def find_word(self, treeiter, mode=libsl.SL_FIND_MATCH, newTab=False):
if treeiter is None:
return
parentiter = self.treestore.iter_parent(treeiter)
if parentiter is None:
return
word = self.treestore.get_value(treeiter, 0)
dic = self.treestore.get_value(parentiter, 0)
filename = self.conf.get_dic_path(dic)
lines = libsl.find_word(word, mode, filename)
translate = "<body>%s</body>" % ("".join(lines))
self.__fire_translate_changed(word, translate, newTab)
def connect(self, event, callback):
self.callbacks[event] = callback
def grab_focus(self):
self.word_entry.grab_focus()
# ================================ Plugin support ============================
def configure(self, window):
conf = SlogConf()
dlg = gtk.Dialog(plugin_name, window, 0,
(gtk.STOCK_OK, gtk.RESPONSE_OK))
hbox = gtk.HBox(False, 8)
hbox.set_border_width(8)
dlg.vbox.pack_start(hbox, False, False, 0)
stock = gtk.image_new_from_stock(gtk.STOCK_DIALOG_QUESTION,
gtk.ICON_SIZE_DIALOG)
hbox.pack_start(stock, False, False, 0)
label = gtk.Label(_("Dictionaries dir:"))
hbox.pack_start(label, False, False, 0)
dir_entry = gtk.Entry()
dir_entry.set_text(conf.sl_dicts_dir)
hbox.pack_start(dir_entry, True, True, 0)
btn_browse = gtk.Button("...")
btn_browse.connect("clicked", self.on_browse_clicked, window,
dir_entry)
hbox.pack_start(btn_browse, False, False, 0)
label.set_mnemonic_widget(dir_entry)
dlg.show_all()
response = dlg.run()
if response == gtk.RESPONSE_OK:
ddir = dir_entry.get_text()
if not os.path.exists(ddir):
ghlp.show_error(window, _("Path not exists!"))
conf.sl_dicts_dir = ddir
dlg.destroy()
def on_browse_clicked(self, widget, window, entry):
chooser = gtk.FileChooserDialog("Open..", window,
gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER,
(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL,
gtk.STOCK_OK, gtk.RESPONSE_OK))
dicts_dir = entry.get_text()
if os.path.exists(dicts_dir):
chooser.set_current_folder(dicts_dir)
response = chooser.run()
if response == gtk.RESPONSE_OK:
path = chooser.get_filename()
entry.set_text(path)
chooser.destroy()
def __init__(self):
self.plugins = {}
self.enabled_plugins = {}
self.conf = SlogConf()
