Ticker_0.4.5pre17/ 0040755 0000766 0000000 00000000000 10026157351 012375 5 ustar rene root Ticker_0.4.5pre17/AppletRun 0120777 0000766 0000766 00000000000 10025334471 015725 2start.py ustar rene rene Ticker_0.4.5pre17/findrox.py 0100644 0000766 0000000 00000005235 10024415153 014415 0 ustar rene root # Most of the common code needed by ROX applications is in ROX-Lib2.
# Except this code, which is needed to find ROX-Lib2 in the first place!
# Just make sure you import findrox before importing anything inside
# ROX-Lib2...
import os, sys
from os.path import exists
import string
def version(major, minor, micro):
"""Find ROX-Lib2, with a version >= (major, minor, micro), and
add it to sys.path. If version is missing or too old, either
prompt the user, or (if possible) upgrade it automatically."""
if os.path.exists('/uri/0install/rox.sourceforge.net'):
# We're using ZeroInstall. Good :-)
zpath = '/uri/0install/rox.sourceforge.net/lib/ROX-Lib2/' \
'latest'
if os.path.exists(zpath):
vs = os.readlink(zpath).split('-')[-1]
v = map(int, vs.split('.'))
if v[0] < major or v[1] < minor or v[2] < micro:
if os.system('cd /uri/0install/rox.sourceforge.net; 0refresh'):
report_error('Using ROX-Lib in Zero Install, but cached version (%s) is too old (need %d.%d.%d) and updating failed (is zero-install running?)' % (vs, major, minor, micro))
sys.path.append(zpath + '/python')
return
print >>sys.stderr, "Using Zero Install, but failed to " \
"fetch", zpath, "-- trying non-0install system."
try:
path = os.environ['LIBDIRPATH']
paths = string.split(path, ':')
except KeyError:
paths = [os.environ['HOME'] + '/lib',
'/usr/local/lib', '/usr/lib' ]
for p in paths:
p = os.path.join(p, 'ROX-Lib2')
if exists(p):
# TODO: check version is new enough
sys.path.append(os.path.join(p, 'python'))
break
else:
report_error("This program needs ROX-Lib2 to run.\n" + \
"I tried all of these places:\n\n" + \
string.join(paths, '\n') + '\n\n' + \
"ROX-Lib2 is available from:\n" + \
"http://rox.sourceforge.net")
def report_error(err):
"Write 'error' to stderr and, if possible, display a dialog box too."
try:
sys.stderr.write('*** ' + err + '\n')
except:
pass
try:
import pygtk; pygtk.require('2.0')
import gtk; g = gtk
except:
import gtk
win = gtk.GtkDialog()
message = gtk.GtkLabel(err +
'\n\nAlso, pygtk2 needs to be present')
win.set_title('Missing ROX-Lib2')
win.set_position(gtk.WIN_POS_CENTER)
message.set_padding(20, 20)
win.vbox.pack_start(message)
ok = gtk.GtkButton("OK")
ok.set_flags(gtk.CAN_DEFAULT)
win.action_area.pack_start(ok)
ok.connect('clicked', gtk.mainquit)
ok.grab_default()
win.connect('destroy', gtk.mainquit)
win.show_all()
gtk.mainloop()
else:
box = g.MessageDialog(None, g.MESSAGE_ERROR, 0,
g.BUTTONS_OK, err)
box.set_title('Missing ROX-Lib2')
box.set_position(g.WIN_POS_CENTER)
box.set_default_response(g.RESPONSE_OK)
box.run()
sys.exit(1)
Ticker_0.4.5pre17/overview.py 0100644 0000766 0000000 00000063337 10025360135 014621 0 ustar rene root #!/usr/bin/env python
from __future__ import generators
# import findrox; findrox.version(1,9,12)
# it uses a patched version of ROX-Lib2 in rox/
import rox
from rox import g, tasks
from Options import *
import RETicker
import tool
import ticker_menu
import time
class StatusLine(g.HBox):
def __init__(self, Options, overview = None):
self.__overview = overview
self.__Options = Options
g.HBox.__init__(self)
self.__feed = None
self.__i_act = tool.EventImage(g.STOCK_NO, lambda x,y: self.emit("switch_active", self.__feed), "inactive (click to change)")
self.__i_act.set_small()
self.pack_start(self.__i_act, g.FALSE, g.FALSE, 1)
self.__i_ref = tool.EventImage(g.STOCK_REFRESH, lambda x,y: self.emit("refresh_feed", self.__feed), "refresh this source")
self.__i_ref.set_small()
self.pack_start(self.__i_ref, g.FALSE, g.FALSE, 1)
self.__label=g.Label()
self.__label.set_size_request(-1,-1)
self.__label.set_alignment(0,0)
self.__label.set_padding(3,0)
self.__label.show()
self.add(self.__label)
self.sig_switch_active = None
self.refresh_colors()
self.show
self.__Options.connect("refresh_ov_colors", self.refresh_colors)
def refresh_colors(self, dummy = None):
if self.__overview: bg_color = self.__Options.ov_bg_stat.value; fg_color = self.__Options.ov_color_old_msg.value
else: bg_color = self.__Options.tt_a_bg_stat.value; fg_color = self.__Options.tt_a_color_old_msg.value
self.__i_act.modify_bg(g.STATE_NORMAL,self.__i_act.get_colormap().alloc_color(bg_color))
self.__i_ref.modify_bg(g.STATE_NORMAL,self.__i_ref.get_colormap().alloc_color(bg_color))
self.__label.modify_fg(g.STATE_NORMAL,self.__label.get_colormap().alloc_color(fg_color))
def reinit(self, feed):
if self.sig_switch_active: self.__Options.sources.get_by_ticker(self.__feed.ticker).disconnect(self.sig_switch_active)
self.__feed = feed
self.sig_switch_active = self.__Options.sources.get_by_ticker(self.__feed.ticker).connect("change_active", self.reset_active)
if self.__feed:
text = self.__feed.title
if not(text) or text == "": text = self.__feed.ticker
if self.__feed.get_active() == 1:
self.__i_act.set_from_stock(g.STOCK_YES); self.__i_act.set_tip("active (click to change)")
else:
self.__i_act.set_from_stock(g.STOCK_NO); self.__i_act.set_tip("inactive (click to change)")
else: text = "no messages to show"; self.__i_act = tool.EventImage(g.STOCK_MISSING_IMAGE, None, None)
self.__label.set_text(text)
self.__i_act.set_small()
def reset_active(self, dummy):
if self.__feed:
if self.__feed.get_active() == 1:
self.__i_act.set_from_stock(g.STOCK_YES); self.__i_act.set_tip("active (click to change)")
else:
self.__i_act.set_from_stock(g.STOCK_NO); self.__i_act.set_tip("inactive (click to change)")
else: self.__i_act = tool.EventImage(g.STOCK_MISSING_IMAGE, None, None)
self.__i_act.set_small()
#self.__i_act.modify_bg(g.STATE_NORMAL,self.__i_act.get_colormap().alloc_color('#eee2b4'))
gobject.signal_new("switch_active", StatusLine, gobject.SIGNAL_RUN_LAST,gobject.TYPE_NONE, (gobject.TYPE_PYOBJECT,))
gobject.signal_new("refresh_feed", StatusLine, gobject.SIGNAL_RUN_LAST,gobject.TYPE_NONE, (gobject.TYPE_PYOBJECT,))
class NavLine(g.HBox):
def __init__(self, Options, overview = None):
self.__Options = Options
self.__overview = overview
g.HBox.__init__(self)
self.i_prev = tool.EventImage(g.STOCK_GO_BACK, lambda x,y: self.emit("prev_feed"), "previous feed")
self.i_next = tool.EventImage(g.STOCK_GO_FORWARD, lambda x,y: self.emit("next_feed"), "next feed")
self.__i_icon = tool.EventImage(g.STOCK_MISSING_IMAGE, lambda x,y: self.emit("open_feed_page"), None)
self.pack_start(self.i_prev, g.FALSE, g.FALSE, 0)
self.pack_start(self.__i_icon, g.FALSE, g.FALSE, 0)
self.pack_start(self.i_next, g.FALSE, g.FALSE, 0)
self.i_refresh = tool.EventImage(g.STOCK_REFRESH, lambda x,y: self.emit("refresh_all"), "refresh news")
self.pack_start(self.i_refresh, g.FALSE, g.FALSE, 10)
self.i_options = tool.EventImage(g.STOCK_PREFERENCES, lambda x,y: self.emit("open_options"), "Preferences")
self.i_window = tool.EventImage(g.STOCK_INDEX, lambda x,y: self.emit("open_overview_window"), "Overview")
self.i_help = tool.EventImage(g.STOCK_HELP, lambda x,y: self.emit("help"), "Help")
self.__i_info = tool.EventImage(g.STOCK_DIALOG_INFO, lambda x,y: self.emit("info"), None)
self.i_quit = tool.EventImage(g.STOCK_QUIT, lambda x,y: self.emit("quit"), "Exit NewsTicker")
self.pack_end(self.i_quit, g.FALSE, g.FALSE, )
self.pack_end(self.i_help, g.FALSE, g.FALSE, 0)
self.pack_end(self.__i_info, g.FALSE, g.FALSE, 0)
self.pack_end(self.i_options, g.FALSE, g.FALSE, 5)
self.pack_end(self.i_window, g.FALSE, g.FALSE, 5)
self.refresh_colors()
self.show()
self.__Options.connect("refresh_ov_colors", self.refresh_colors)
def refresh_colors(self, dummy = None):
if self.__overview: bg_color = self.__Options.ov_bg_stat.value
else: bg_color = self.__Options.tt_a_bg_stat.value
self.i_prev.modify_bg(g.STATE_NORMAL,self.i_prev.get_colormap().alloc_color(bg_color))
self.__i_icon.modify_bg(g.STATE_NORMAL,self.__i_icon.get_colormap().alloc_color(bg_color))
self.i_next.modify_bg(g.STATE_NORMAL,self.i_next.get_colormap().alloc_color(bg_color))
self.i_refresh.modify_bg(g.STATE_NORMAL,self.i_refresh.get_colormap().alloc_color(bg_color))
self.i_options.modify_bg(g.STATE_NORMAL,self.i_options.get_colormap().alloc_color(bg_color))
self.i_help.modify_bg(g.STATE_NORMAL,self.i_help.get_colormap().alloc_color(bg_color))
self.__i_info.modify_bg(g.STATE_NORMAL,self.__i_info.get_colormap().alloc_color(bg_color))
self.i_quit.modify_bg(g.STATE_NORMAL,self.i_quit.get_colormap().alloc_color(bg_color))
self.modify_bg(g.STATE_NORMAL,self.get_colormap().alloc_color(bg_color))
def reinit(self, feed, stat):
self.__i_info.set_tip(stat)
if feed:
self.set_icon(feed.get_iconcache())
if feed.title: title = tool.unxml(feed.title).encode("utf-8")
else: title = ""
if feed.desc: desc = tool.unxml(feed.desc).encode("utf-8")
else: desc = ""
if title <> "": tip = title
else: tip = ""
if desc <> "":
if tip <> "": tip += "\n"
tip += desc
if tip == "": tip = "No Information about feed available,\nyou have to refresh this feed."
self.set_tip(tip)
else:
self.set_icon(None)
def set_icon(self, Filename):
if Filename == None: self.__i_icon.hide()
else: self.__i_icon.show(); self.__i_icon.get_from_file(Filename)
def set_tip(self, Tip):
self.__i_icon.set_tip(Tip)
def set_stat(self, stat):
self.__i_info.set_tip(stat)
gobject.signal_new("next_feed", NavLine, gobject.SIGNAL_RUN_LAST,gobject.TYPE_NONE, ())
gobject.signal_new("prev_feed", NavLine, gobject.SIGNAL_RUN_LAST,gobject.TYPE_NONE, ())
gobject.signal_new("open_feed_page", NavLine, gobject.SIGNAL_RUN_LAST,gobject.TYPE_NONE, ())
gobject.signal_new("refresh_all", NavLine, gobject.SIGNAL_RUN_LAST,gobject.TYPE_NONE, ())
gobject.signal_new("open_options", NavLine, gobject.SIGNAL_RUN_LAST,gobject.TYPE_NONE, ())
gobject.signal_new("open_overview_window", NavLine, gobject.SIGNAL_RUN_LAST,gobject.TYPE_NONE, ())
gobject.signal_new("help", NavLine, gobject.SIGNAL_RUN_LAST,gobject.TYPE_NONE, ())
gobject.signal_new("info", NavLine, gobject.SIGNAL_RUN_LAST,gobject.TYPE_NONE, ())
gobject.signal_new("quit", NavLine, gobject.SIGNAL_RUN_LAST,gobject.TYPE_NONE, ())
class ov_message(g.EventBox):
def __init__(self, Options, feed, msg, count, overview = None):
self.__Options = Options
self.__feed = feed
self.__overview = overview ## to recognize the different color used by window
self.__msg = msg
self.__count = count
g.EventBox.__init__(self)
self.text = tool.unxml(self.__msg.title).encode("utf-8")
self.time_val = ""; self.stat = ""
page_time = msg.fetchtime
self.time_val = time.strftime("%a %H:%M", time.localtime(page_time))
if msg.time <> 0: page_time = msg.time; self.time_val += time.strftime(" [%a %H:%M]", time.localtime(page_time))
self.stat = "[" + str(msg.showcount) + "x]"
self.__tooltip = g.Tooltips()
self.__tooltip.enable()
tiptext = ""
if self.__Options.show_age.int_value == 1: tiptext += self.time_val
if tiptext <> "": tiptext += " "
if self.__Options.show_stat.int_value == 1: tiptext += self.stat
if tiptext <> "": tiptext = self.text + "(" + tiptext + ")"
else: tiptext = self.text
desc = tool.unxml(msg.desc.encode("utf-8"))
from message import EMPTY_DESC
if desc <> EMPTY_DESC:
tiptext += "\n---------------------\n" + desc
self.__tooltip.set_tip(self, tiptext)
if not(self.__overview): self.__label=g.Label(self.text)
else: self.__label=g.Label(); self.refresh_msg_text()
self.__label.set_size_request(-1,-1)
self.__label.set_alignment(0,0)
self.__label.set_padding(3,0)
self.__label.show()
self.add(self.__label)
self.show()
self.set_events(g.gdk.ENTER_NOTIFY_MASK | g.gdk.LEAVE_NOTIFY_MASK)
self.connect("enter-notify-event", self.enter_widget)
self.connect("leave-notify-event", self.leave_widget)
self.connect("button_press_event",self.callback_event)
self.source = self.__Options.sources.get_by_ticker(self.__feed.get_ticker())
self.refresh_colors()
#print "message-Quelle " + str(self.source)
self.source.connect("change_active", self.refresh_colors)
self.source.connect("change_shownews", self.refresh_colors)
self.source.connect("change_news_age_by_date", self.refresh_colors)
self.source.connect("change_provides_date_info", self.refresh_colors)
self.__Options.connect("refresh_ov_colors", self.refresh_colors)
self.__Options.connect("refresh_aging_opts", self.refresh_colors)
if self.__overview: self.__Options.connect("refresh_ov_msgs", self.refresh_msg_text)
def refresh_msg_text(self, dummy=None):
text_new = ""
if self.__Options.show_age.int_value == 1: text_new += self.time_val
if text_new <> "": text_new += " "
if self.__Options.show_stat.int_value == 1: text_new += self.stat
if text_new <> "": text_new += " "
text_new += self.text
self.__label.set_text(text_new)
def refresh_colors(self, dummy = None):
#print "refresh_color ov_message " + str(self.source)
if self.__feed.get_active() == 1:
#print "active"
if self.__overview: bg_color = self.__Options.ov_bg.value
else: bg_color = self.__Options.tt_a_bg.value
else:
#print "not active"
if self.__overview: bg_color = self.__Options.ov_bg_inactive.value
else: bg_color = self.__Options.tt_a_bg_inactive.value
if self.__overview: fg_color = self.__Options.ov_color_old_msg.value
else: fg_color = self.__Options.tt_a_color_old_msg.value
if self.__feed.msg_is_new(self.__msg):
if self.__overview: fg_color = self.__Options.ov_color_new_msg.value
else: fg_color = self.__Options.tt_a_color_new_msg.value
if self.__count > self.__feed.get_shownews():
if self.__overview: fg_color = self.__Options.ov_color_not_shown_msg.value
else: fg_color = self.__Options.tt_a_color_not_shown_msg.value
self.__label.modify_fg(g.STATE_NORMAL,self.__label.get_colormap().alloc_color(fg_color))
self.modify_bg(g.STATE_NORMAL,self.get_colormap().alloc_color(bg_color))
def enter_widget(self, widget, event):
widget.set_state (g.STATE_PRELIGHT)
def leave_widget(self, widget, event):
widget.set_state (g.STATE_NORMAL)
def callback_event(self, widget, event):
widget.set_state (g.STATE_SELECTED)
if event.button == 1: tasks.Task(self.open_page())
### change this
###if event.button == 2: self.main.show_list.show_next_msg_in_ticker()
###if event.button == 3: self.__parent.open_menu(widget, event, None, self.__msg)
def open_desc_window(self):
yield None
desc_window = Desc_Window(self.__msg, self.__label)
def open_page(self):
yield None
if self.__overview: fg_color = self.__Options.ov_color_old_msg.value
else: fg_color = self.__Options.tt_a_color_old_msg.value
self.modify_fg(g.STATE_NORMAL,self.get_colormap().alloc_color(fg_color))
self.__msg.read = 1
yield None
if self.__Options.br_options.value <> "":
os.spawnlp(os.P_NOWAIT,self.__Options.browser.value,\
self.__Options.browser.value,self.__Options.br_options.value,self.__msg.link)
else: os.spawnlp(os.P_NOWAIT,self.__Options.browser.value,self.__Options.browser.value,self.__msg.link)
class ov_feed(g.EventBox):
def __init__(self, Options, overview = None):
self.__Options = Options
self.__feed = None
self.__overview = overview ## to recognize the different color used by window
self.sig_active = None
########################
g.EventBox.__init__(self)
self.vbox = None
self.__Options.connect("refresh_ov_colors", self.refresh_colors)
self.label1 = None
self.label2 = None
def refresh_colors(self, dummy = None):
#print "refresh_color ov_feed"
if self.__feed.get_active() == 1:
if self.__overview: bg_color = self.__Options.ov_bg.value
else: bg_color = self.__Options.tt_a_bg.value
else:
if self.__overview: bg_color = self.__Options.ov_bg_inactive.value
else: bg_color = self.__Options.tt_a_bg_inactive.value
self.modify_bg(g.STATE_NORMAL,self.get_colormap().alloc_color(bg_color))
if self.__overview: fg_color = self.__Options.ov_color_old_msg.value
else: fg_color = self.__Options.tt_a_color_old_msg.value
if self.label1:
self.label1.modify_fg(g.STATE_NORMAL,self.label1.get_colormap().alloc_color(fg_color))
if self.label2:
self.label2.modify_fg(g.STATE_NORMAL,self.label2.get_colormap().alloc_color(fg_color))
def reinit(self, fd):
if self.vbox: self.remove(self.vbox); del self.vbox; self.vbox = None
if self.sig_active and self.__Options.sources.get_by_ticker(self.__feed.ticker):
self.__Options.sources.get_by_ticker(self.__feed.ticker).disconnect(self.sig_active)
self.sig_active = None
count = 1
#fd = None for testing
if fd:
self.vbox = g.VBox()
self.add(self.vbox)
self.__feed = fd
#print str(self.__feed)
self.sig_active = self.__Options.sources.get_by_ticker(self.__feed.ticker).connect("change_active", self.refresh_colors)
if len(self.__feed.msg) <> 0:
for i in self.__feed.msg:
self.vbox.pack_start(ov_message(self.__Options, self.__feed, i, count, self.__overview), g.FALSE, g.FALSE, 0)
count += 1
self.label1 = None
self.label2 = None
else:
self.label1=g.Label("no messages available")
self.label1.set_size_request(-1,-1)
self.label1.set_alignment(0,0)
self.label1.set_padding(3,0)
self.label1.show()
self.label2=g.Label("maybe you have to\nactivate ticker or\nrefresh the news")
self.label2.set_size_request(-1,-1)
self.label2.set_alignment(0,0)
self.label2.set_padding(3,0)
self.label2.show()
self.vbox.pack_start(self.label1, g.FALSE, g.FALSE, 0)
self.vbox.add(self.label2)
self.refresh_colors()
self.show_all()
class overview(gobject.GObject):
def __init__(self, Options, show_list):
self.__Options = Options
self.__show_list = show_list
######################
gobject.GObject.__init__(self)
self.win = None
self.feed_wins = {}
def destroy(self, dummy = None):
self.win = None
import gc
gc.collect()
def change_size(self, dummy, event):
width, height = self.win.get_size()
if width <> self.__Options.ov_hor_size.int_value or height <> self.__Options.ov_ver_size.int_value:
self.emit("size_changed_ov", width, height)
def refresh_size(self, dummy=None):
#self.set_size_request(self.__Options.ov_hor_size.int_value,self.__Options.ov_ver_size.int_value)
self.win.resize(self.__Options.ov_hor_size.int_value,self.__Options.ov_ver_size.int_value)
def refresh_colors(self, dummy=None):
self.viewport.modify_bg(g.STATE_NORMAL,self.viewport.get_colormap().alloc_color(self.__Options.ov_bg_stat.value))
self.win.modify_bg(g.STATE_NORMAL,self.win.get_colormap().alloc_color(self.__Options.ov_bg.value))
def switch_feed_active(self, dummy, feed):
self.emit("switch_active_slave", feed)
#self.reinit()
def refresh_feed(self, dummy, feed):
self.emit("refresh_feed_slave", feed)
#self.reinit()
def reinit(self, dummy, feed):
if not(self.win): return
stat, overview = self.feed_wins[feed]
stat.reinit(feed)
overview.reinit(feed)
"""
self.viewport.remove(self.vbox_in)
del self.vbox_in
self.vbox_in = g.VBox()
self.viewport.add(self.vbox_in)
self.show_now()
"""
def recreate_window(self, dummy = None):
if self.win: self.win.present(); return
self.win = g.Window()
self.win.connect("destroy", self.destroy)
self.vbox = g.VBox()
self.swin=g.ScrolledWindow()
self.swin.set_shadow_type(g.SHADOW_NONE)
self.swin.set_policy(g.POLICY_AUTOMATIC, g.POLICY_AUTOMATIC)
self.win.add(self.vbox)
self.vbox_in = g.VBox()
self.viewport = g.Viewport()
self.viewport.add(self.vbox_in)
self.viewport.set_shadow_type(g.SHADOW_NONE)
self.swin.add(self.viewport)
self.vbox.add(self.swin)
self.win.set_size_request(50,40)
self.refresh_size()
self.refresh_colors()
self.__Options.connect("refresh_ov_colors", self.refresh_colors)
self.__Options.connect("refresh_ov_size", self.refresh_size)
self.win.set_events(g.gdk.CONFIGURE)
self.win.connect('configure-event',self.change_size)
self.feed_wins = {}
self.show_now()
def show_now(self):
for feed in self.__show_list.feeds:
#source = self.__Options.sources.get_by_ticker(feed.get_ticker())
#source.connect("source_killed", self.kill_feed, feed)
sep = g.HSeparator()
stat = StatusLine(self.__Options, True)
stat.reinit(feed)
stat.connect("switch_active", self.switch_feed_active)
stat.connect("refresh_feed", self.refresh_feed)
overview = ov_feed(self.__Options, True)
overview.reinit(feed)
self.vbox_in.pack_start(sep, g.FALSE, g.FALSE, 0)
self.vbox_in.pack_start(stat, g.FALSE, g.FALSE, 0)
self.vbox_in.pack_start(overview, g.FALSE, g.FALSE, 0)
self.feed_wins[feed] = (stat, overview)
#self.__overview.stat.connect("switch_active", self.__Options.sources_switch_feed_active)
#self.__overview.stat.connect("refresh_feed", self.__show_list.refresh_feed)
#self.set_events(g.gdk.ENTER_NOTIFY_MASK | g.gdk.LEAVE_NOTIFY_MASK)
#self.connect("enter-notify-event", self.enter_widget)
#self.connect("leave-notify-event", self.leave_widget)
#self.connect("button-press-event", self.button_pressed)
#self.Menu = None
#self.nav.connect("next_feed", self.next_feed)
#self.nav.connect("prev_feed", self.prev_feed)
#self.nav.connect("open_feed_page", self.open_feed)
#self.sig_kill_feed = None
#self.set_decorated(g.FALSE)
self.win.show_all()
gobject.signal_new("switch_active_slave", overview, gobject.SIGNAL_RUN_LAST,gobject.TYPE_NONE, (gobject.TYPE_PYOBJECT,))
gobject.signal_new("refresh_feed_slave", overview, gobject.SIGNAL_RUN_LAST,gobject.TYPE_NONE, (gobject.TYPE_PYOBJECT,))
gobject.signal_new("size_changed_ov", overview, gobject.SIGNAL_RUN_LAST,gobject.TYPE_NONE, (gobject.TYPE_PYOBJECT,gobject.TYPE_PYOBJECT,))
class ov_aktfeed(g.Window):
def __init__(self, Options, show_list):
self.__Options = Options
self.__show_list = show_list
self.__initialized = False ### window is created (after getting some news)
self.__active = False ### Mouse is or was over window
self.__tip = False ### shown as tip
self.__menu = False ### shown as menu
self.__feed = None
self.__source = None
######################
g.Window.__init__(self)
self.new_frame=g.Frame()
self.ebox = g.EventBox() # without thisone the enter and leave-widget events dont work
vbox = g.VBox()
self.swin=g.ScrolledWindow()
self.swin.set_shadow_type(g.SHADOW_NONE)
self.viewport = g.Viewport()
self.viewport.set_shadow_type(g.SHADOW_NONE)
self.viewport.set_border_width(2)
self.swin.add(self.viewport)
self.__overview = ov_feed(self.__Options)
self.viewport.add(self.__overview)
self.stat = StatusLine(self.__Options)
self.nav = NavLine(self.__Options)
vbox.pack_start(self.stat, g.FALSE, g.FALSE, 0)
vbox.pack_end(self.nav, g.FALSE, g.FALSE, 0)
vbox.add(self.swin)
self.new_frame.add(vbox)
self.ebox.add(self.new_frame)
self.add(self.ebox)
#self.modify_bg(g.STATE_NORMAL,self.get_colormap().alloc_color('black'))
self.set_size_request(self.__Options.tt_a_hor_size.int_value,self.__Options.tt_a_ver_size.int_value)
self.set_events(g.gdk.CONFIGURE | g.gdk.ENTER_NOTIFY_MASK | g.gdk.LEAVE_NOTIFY_MASK)
self.connect("enter-notify-event", self.enter_widget)
self.connect("leave-notify-event", self.leave_widget)
#self.connect("button-press-event", self.button_pressed)
self.Menu = None
self.nav.connect("next_feed", self.next_feed)
self.nav.connect("prev_feed", self.prev_feed)
self.nav.connect("open_feed_page", self.open_feed)
self.sig_kill_feed = None
self.set_decorated(g.FALSE)
self.set_scrollbars()
self.set_size_request(50,40)
self.refresh_size()
self.refresh_colors()
self.__Options.connect("refresh_ov_colors", self.refresh_colors)
self.__Options.connect("refresh_tt_a_size", self.refresh_size)
self.connect('configure-event',self.change_size)
def change_size(self, dummy, event):
width, height = self.get_size()
if width <> self.__Options.tt_a_hor_size.int_value or height <> self.__Options.tt_a_ver_size.int_value:
self.emit("size_changed_tt_a", width, height)
def refresh_size(self, dummy=None):
self.resize(self.__Options.tt_a_hor_size.int_value, self.__Options.tt_a_ver_size.int_value)
def refresh_colors(self, dummy=None):
self.new_frame.modify_bg(g.STATE_NORMAL,self.new_frame.get_colormap().alloc_color('black'))
self.ebox.modify_bg(g.STATE_NORMAL,self.ebox.get_colormap().alloc_color(self.__Options.tt_a_bg_stat.value))
### create window for the first time after news found in cache, set initialized true
def create_window(self, widget = None, dummy = None):
if self.sig_kill_feed: self.__source.disconnect(self.sig_kill_feed)
self.__feed = self.__show_list.akt_feed()
if self.__feed == None: self.__feed = self.__show_list.ov_next_feed(None)
if self.__feed == None: return ### init later
self.__source = self.__Options.sources.get_by_ticker(self.__feed.get_ticker())
self.sig_kill_feed = self.__source.connect("source_killed", self.create_window)
self.__overview.reinit(self.__feed)
self.stat.reinit(self.__feed)
self.nav.reinit(self.__feed, self.__show_list.stat())
self.__initialized = True
def set_scrollbars(self, dummy=None):
if self.__Options.tt_a_hor_scrollbar.int_value == 1: hor_bar = g.POLICY_AUTOMATIC
else: hor_bar = g.POLICY_NEVER
if self.__Options.tt_a_ver_scrollbar.int_value == 1: ver_bar = g.POLICY_AUTOMATIC
else: ver_bar = g.POLICY_NEVER
self.swin.set_policy(hor_bar, ver_bar)
def refresh_stat(self):
self.nav.set_stat(self.__show_list.stat())
def open_feed(self, widget):
if self.__feed:
if self.__Options.br_options.value <> "":
os.spawnlp(os.P_NOWAIT,self.__Options.browser.value,\
self.__Options.browser.value,self.__Options.br_options.value,self.__feed.link)
else: os.spawnlp(os.P_NOWAIT,self.__Options.browser.value,self.__Options.browser.value,self.__feed.link)
def next_feed(self, widget):
self.__feed = self.__show_list.ov_next_feed(self.__feed); self.refresh()
def prev_feed(self, widget):
self.__feed = self.__show_list.ov_prev_feed(self.__feed); self.refresh()
def refresh_if_actual(self, dummy, feed):
if not(self.__feed): return
if self.__feed.ticker <> feed.ticker: return
self.refresh()
def akt_feed(self, showlist, feed):
#print "akt_feed" +str(showlist) + str(feed)
#yield None
if self.__active: return
if feed.title == None: return
self.__feed = feed
self.refresh()
### init window contents but dont show them
def refresh(self):
#print "ov_aktive refresh " + str(self.__feed)
self.__overview.reinit(self.__feed)
self.stat.reinit(self.__feed)
self.nav.reinit(self.__feed, self.__show_list.stat())
def button_pressed(self, widget, event):
print "button pressed"
def enter_widget(self, widget, event):
#print "enter wdget"
self.__active = True
#widget.set_state (g.STATE_PRELIGHT)
def leave_widget(self, widget, event):
#print "leave widget"
if not(self.__active):
#print "keine Ahnung wann das passiert"
return
else:
if not(self.Menu): self.hide_later(None)
#widget.set_state (g.STATE_NORMAL)
def get_position(self, tip):
self.realize()
if tip: x, y = g.gdk.get_default_root_window().get_position()
return x, y
def show_now_as_tip(self, x, y, w, h):
if self.__Options.tt_a.int_value == 1 \
and self.__Options.tt_a_as_menu.int_value == 0 and not(self.__menu):
scr_w = g.gdk.screen_width()
scr_h = g.gdk.screen_height()
width, height = self.get_size()
# try over main window
if y - height >= 0: y = y - height ### try over window
elif y + 2 * h + height <= scr_h: y = y + 2 * h ### try under window
else: y = int((scr_h - height)/2) ### try in the middle
if x < 0 : x = 0
if x + width > scr_w: x = scr_w - width
if self.show_now(x, y): self.__tip = True
def show_now_as_menu(self, widget, event):
if self.__Options.tt_a.int_value == 1 \
and self.__Options.tt_a_as_menu.int_value == 1 and not(self.__tip):
x, y, mods = g.gdk.get_default_root_window().get_pointer()
scr_w = g.gdk.screen_width()
scr_h = g.gdk.screen_height()
width, height = self.get_size()
# try over main window
if y + 8 - height >= 0: y = y + 8 - height
elif y - 8 + height <= scr_h: y = y - 8
else: y = int((scr_h - height)/2) ### try in the middle
x -= 8
if x < 0 : x = 0
if x + width > scr_w: x = scr_w - width
if self.show_now(x, y): self.__menu = True
def show_now(self, x, y):
if not(self.__initialized): self.create_window()
if self.__initialized:
self.move(x, y)
self.show_all()
return True
else: return False
def hide_later(self, widget):
#print "hide now"
if self.__Options.tt_a.int_value == 1:
self.__active = False
tasks.Task(self.wait_and_hide())
def wait_and_hide(self):
yield tasks.TimeoutBlocker(0.3);
if not(self.__active) and self.__initialized:
#print "hide window"
self.hide()
self.__tip = False
self.__menu = False
self.__feed = self.__show_list.akt_feed()
self.refresh()
gobject.signal_new("size_changed_tt_a", ov_aktfeed, gobject.SIGNAL_RUN_LAST,gobject.TYPE_NONE, (gobject.TYPE_PYOBJECT,gobject.TYPE_PYOBJECT,))
Ticker_0.4.5pre17/Options.xml 0100644 0000766 0000000 00000020270 10025363577 014560 0 ustar rene root
Set Aging of News
Set Aging of News
set the Color of the News-Text
set the Background-Color
Location of the background image
horizontal Window Size -- -1 for dynamic
vertical Window Size -- -1 for dynamic Fenstergroesse
set the Color of the News-Text
set the Color of the News-Text
set the Color of the News-Text
set the background-color of active feeds
set the background-color of inactive feeds
set the background-color of the window
horizontal Window Size -- -1 for dynamic
vertical Window Size -- -1 for dynamic Fenstergroesse
active_tooltip.png
set the Color of the News-Text
set the Color of the News-Text
set the Color of the News-Text
set the background-color of active feeds
set the background-color of inactive feeds
set the background-color of the tooltip
horizontal Window Size -- -1 for dynamic
vertical Window Size -- -1 for dynamic Fenstergroesse
image_tip.pnglabel_tip_1.png
Time to wait bevor changing the Message
Time to wait bevor fetching news again
Show with Text and Icon of the siteShow spezial Icon but normal NewsProgram to start in left click (bsp. Opera)Options for the Program (bsp. -newpage)Where is a file to cache newsWhere is a directory to cache icons
Ticker_0.4.5pre17/AppRun 0120777 0000766 0000766 00000000000 10025334465 015223 2start.py ustar rene rene Ticker_0.4.5pre17/AppIcon.xpm 0100644 0000766 0000000 00000014007 10024415153 014446 0 ustar rene root /* XPM */
static char * AppIcon_xpm[] = {
"32 32 245 2",
" c None",
". c #767676",
"+ c #7F7F7F",
"@ c #929292",
"# c #B1B1B1",
"$ c #BCBCBC",
"% c #CFCFCF",
"& c #DEDEDE",
"* c #CDCDCD",
"= c #5A5A5A",
"- c #909090",
"; c #ADADAD",
"> c #6E6E6E",
", c #979797",
"' c #BDBDBD",
") c #D4D4D4",
"! c #E2E2E2",
"~ c #F4F4F4",
"{ c #FEFEFE",
"] c #FFFFFF",
"^ c #FCFCFC",
"/ c #7A7A7A",
"( c #C8C8C8",
"_ c #FAFAFA",
": c #BFBFBF",
"< c #7C7C7C",
"[ c #BEBEBE",
"} c #AEAEAE",
"| c #8A8A8A",
"1 c #E1E1E1",
"2 c #EAEAEA",
"3 c #F6F6F6",
"4 c #F1F1F1",
"5 c #EBEBEB",
"6 c #ECECEC",
"7 c #E3E3E3",
"8 c #E0E0E0",
"9 c #D0D0D0",
"0 c #ACACAC",
"a c #C4C4C4",
"b c #A9A9A9",
"c c #808080",
"d c #9D9D9D",
"e c #D5D5D5",
"f c #DDDDDD",
"g c #ABABAB",
"h c #8C8C8C",
"i c #CBCBCB",
"j c #8E8E8E",
"k c #949494",
"l c #DFDFDF",
"m c #F5F5F5",
"n c #F8F8F8",
"o c #D8D8D8",
"p c #B7B7B7",
"q c #A5A5A5",
"r c #969696",
"s c #C0C0C0",
"t c #696969",
"u c #A2A2A2",
"v c #D2D2D2",
"w c #939393",
"x c #898989",
"y c #848484",
"z c #BABABA",
"A c #888888",
"B c #868686",
"C c #C7C7C7",
"D c #B5B5B5",
"E c #828282",
"F c #B3B3B3",
"G c #858585",
"H c #717171",
"I c #343434",
"J c #A1A1A1",
"K c #BBBBBB",
"L c #707070",
"M c #4D4D4D",
"N c #9C9C9C",
"O c #AFAFAF",
"P c #555555",
"Q c #878787",
"R c #535353",
"S c #D9D9D9",
"T c #9E9E9E",
"U c #C6C6C6",
"V c #959595",
"W c #7E7E7E",
"X c #DBDBDB",
"Y c #525252",
"Z c #585858",
"` c #282828",
" . c #B2B2B2",
".. c #C5C5C5",
"+. c #B4B4B4",
"@. c #454545",
"#. c #3F3F3F",
"$. c #212121",
"%. c #919191",
"&. c #B0B0B0",
"*. c #8F8F8F",
"=. c #0B0B0B",
"-. c #6C6C6C",
";. c #A4A4A4",
">. c #C2C2C2",
",. c #4E4E4E",
"'. c #333333",
"). c #E5E5E5",
"!. c #5D5D5D",
"~. c #E6E6E6",
"{. c #5F5F5F",
"]. c #252525",
"^. c #9B9B9B",
"/. c #E8E8E8",
"(. c #818181",
"_. c #0A0A0A",
":. c #9F9F9F",
"<. c #2C2C2C",
"[. c #515151",
"}. c #DADADA",
"|. c #1F1F1F",
"1. c #A8A8A8",
"2. c #272727",
"3. c #CCCCCC",
"4. c #989898",
"5. c #565656",
"6. c #C3C3C3",
"7. c #C9C9C9",
"8. c #3E3E3E",
"9. c #D3D3D3",
"0. c #363636",
"a. c #727272",
"b. c #676767",
"c. c #D6D6D6",
"d. c #9A9A9A",
"e. c #CACACA",
"f. c #4B4B4B",
"g. c #F0F0F0",
"h. c #686868",
"i. c #E9E9E9",
"j. c #8D8D8D",
"k. c #B6B6B6",
"l. c #D1D1D1",
"m. c #F2F2F2",
"n. c #F3F3F3",
"o. c #FDFDFD",
"p. c #EFEFEF",
"q. c #838383",
"r. c #EEEEEE",
"s. c #575757",
"t. c #FBFBFB",
"u. c #F9F9F9",
"v. c #E4E4E4",
"w. c #DCDCDC",
"x. c #D7D7D7",
"y. c #E7E7E7",
"z. c #545454",
"A. c #F7F7F7",
"B. c #C1C1C1",
"C. c #4F4F4F",
"D. c #474747",
"E. c #B9B9B9",
"F. c #EDEDED",
"G. c #7B7B7B",
"H. c #A7A7A7",
"I. c #A0A0A0",
"J. c #393939",
"K. c #AAAAAA",
"L. c #999999",
"M. c #2F2F2F",
"N. c #CECECE",
"O. c #C3C4C4",
"P. c #C5C4C4",
"Q. c #C6C5C5",
"R. c #C4C3C3",
"S. c #BAB9B9",
"T. c #B1B0B0",
"U. c #5B5B5B",
"V. c #B5B4B4",
"W. c #999898",
"X. c #9B9A9A",
"Y. c #9E9D9D",
"Z. c #969595",
"`. c #949393",
" + c #908F8F",
".+ c #8F8E8E",
"++ c #7D7D7D",
"@+ c #868585",
"#+ c #878585",
"$+ c #878686",
"%+ c #888787",
"&+ c #858484",
"*+ c #848282",
"=+ c #828181",
"-+ c #7D7C7C",
";+ c #7A7979",
">+ c #A6A6A6",
",+ c #737373",
"'+ c #757474",
")+ c #767575",
"!+ c #787777",
"~+ c #777676",
"{+ c #747373",
"]+ c #737272",
"^+ c #717070",
"/+ c #6D6D6D",
"(+ c #6F6F6F",
"_+ c #313131",
":+ c #706F6F",
"<+ c #666565",
"[+ c #696868",
"}+ c #6B6A6A",
"|+ c #6C6A6A",
"1+ c #6A6A6A",
"2+ c #6A6868",
"3+ c #696767",
"4+ c #686666",
"5+ c #797979",
"6+ c #6B6969",
"7+ c #656363",
"8+ c #646363",
"9+ c #646262",
"0+ c #636262",
"a+ c #636161",
"b+ c #626161",
"c+ c #605E5E",
"d+ c #747474",
"e+ c #2B2B2B",
"f+ c #3A3A3A",
"g+ c #424141",
"h+ c #434343",
"i+ c #4A4A4A",
"j+ c #505050",
"k+ c #525151",
"l+ c #545353",
"m+ c #565555",
"n+ c #595959",
"o+ c #5A5959",
"p+ c #5B5A5A",
"q+ c #6F6E6E",
"r+ c #0D0D0D",
"s+ c #0F0F0F",
"t+ c #121212",
"u+ c #151515",
"v+ c #181818",
" ",
" . + @ # $ % & * = - ; ",
" > , ' ) ! ~ { ] ] ] ] ] ] ^ ; / ( _ _ : < [ } ",
" | 1 2 3 _ { ] ] ] ] { { 4 5 6 7 8 9 0 a b c d e f g h i j ",
" k l m 5 n o ) p q r s < [ t u v w x , y z A B C 8 D E F G ",
" H [ s I g J K L M N O P Q B R S T R - U C V W # X $ E # x ",
" Y # f Z ` ...+.@.: 5 : #.0 $.%.&.*.=.-.9 ;.< , ) >.E } %. ",
" T f +.,.'.0 ).'.!.~.] Z {.P ].^./.(._.+ p (.B * C y g :.<. ",
" h % s : #.M /.[.. }.] z |.1.2.E ) 3.4.5.[ A (.6.7.Q 1.O 8. ",
" > [ 9 [ 9.0.3.a.b.* +.] Z ..T *.c.L d.(...h c $ e.x u +.f. ",
" .3.Q g.+.g q h.j 0 ] e ! g.9.i.U g 7.6.| c [ 3.j.N k.R ",
" d l.S g.{ m.n n.3 ^ { ] o.^ 3 p.2 ! X ' G q...3.*., k.P ",
" h C m ^ ] ] ] ] ] ] ] ] { _ m r.~.& S D (.h ( i @ w D s. ",
" H z 6 t.{ ] ] ] ] ] ] ] o.u.n.6 v.w.x.g W d.e.7.w *.F s. ",
" !.# v.u.o.] ] ] ] ] ] ] ^ 3 4 i.1 X 9.J W b 3.C k j.# s. ",
" !.[ ! 3 _ o.] ] ] ] ] { u.~ r.y.l o * r c D 3.6.k | O z. ",
" L v ).n.A._ o.] ] ] { _ 3 4 5 7 X c...h Q $ 7.B.V A 0 C. ",
" w X v.g.n.3 u.t.^ t._ 3 4 6 ~.l x.9.$ G w : ..' k Q b D. ",
" 0 l 1 6 p.m.m 3 A.A.m 4 6 /.1 }.v 9 .+ T >.B.E.@ G q #. ",
" ..& l ~.i.F.p.g.4 4 p.5 y.! w.e * i 1.G.H.6.$ D %.y I.J. ",
" {.c.S X 1 v.y.i.2 2 2 y.).8 X c.9 7.U T < K.: p # j E L.M. ",
" Q w.v x.X l 1 ! v.v.7 1 & S e 9 7.6.B., + 0 E. .0 h E %. ",
" g f N.) x.S X f & & & X o 9.% i a : ' @ c g +.} 1.x (.| ",
" U v z s >.O.P.Q.U U Q.R.B.' S.D T.} E.k c b O K.q q.E + ",
" U.) V.W.X.N Y.Y.T T T Y.N d.4.Z.`. +.+} N ++u K.q :.< G -. ",
" t ; +@+#+$+%+%+%+%+%+%+B &+*+=+c -+;+Y.1.G.r >+u L.,+x R ",
" - '+)+!+!+!+!+!+!+!+!+~+)+'+{+]+^+/+G g y A J :.h (+Q _+ ",
" W :+<+[+}+}+}+}+|+|+|+|+1+2+[+3+4+<+}+T d.G.V d.5+,+H ",
" :+6+7+7+8+7+7+7+7+8+8+9+9+0+a+b+b+c+d+^.y W x 1+d+e+ ",
" f+#.#.g+h+D.i+M j+k+l+m+s.Z n+n+o+p+q+c a.U.M ` ",
" r+s+t+u+v+ ",
" "};
Ticker_0.4.5pre17/AppInfo.xml 0100644 0000766 0000000 00000000516 10024415153 014445 0 ustar rene root
News-Tickershow rss/rdf feeds0.4.5pre11.03.04 (11-Mar-2004)Rene EjuryGNU General Public Licensemail: rene_ejury at gmx dot net
Ticker_0.4.5pre17/rox/ 0040755 0000766 0000000 00000000000 10026157441 013205 5 ustar rene root Ticker_0.4.5pre17/rox/AppInfo.py 0100644 0000766 0000000 00000020532 10024415153 015105 0 ustar rene root """Parse the AppInfo files.
Written by Christopher Arndt and Stephen Watson."""
import sys
from xml.dom import Node, minidom, XML_NAMESPACE
def _getlangs(langs):
if langs is None:
langs = ['en', 'C', '']
try:
import rox #.i18n
langs = rox.i18n.langs + langs
except:
pass
elif type(langs) is type(''):
langs = [langs]
return langs
def _data(node):
"""Return all the text directly inside this DOM Node."""
return ''.join([text.nodeValue for text in node.childNodes
if text.nodeType == Node.TEXT_NODE])
class AppInfo:
"""Parsed AppInfo.xml file. Current only deals with the ,
and elements"""
def __init__(self, source):
"""Read the file and parse the element."""
self._doc = minidom.parse(source)
self._parseAbout()
self._parseSummary()
self._parseMenu()
def _parseAbout(self):
"""Collect 'About' info in a dictionary by language."""
self.about = {}
for ab in self._doc.documentElement.getElementsByTagName('About'):
lang = ab.getAttributeNS(XML_NAMESPACE, 'lang')
self.about[lang] = {}
for node in ab.childNodes:
if node.nodeType != Node.ELEMENT_NODE:
continue
name = node.localName or None
label = node.getAttribute('label') or name
self.about[lang][name] = label, _data(node)
def _parseSummary(self):
"""Collect 'Summary' info in a dictionary by language."""
self.summary = {}
for sum in self._doc.documentElement.getElementsByTagName('Summary'):
lang=sum.getAttributeNS(XML_NAMESPACE, 'lang')
self.summary[lang] = _data(sum)
def _parseMenu(self):
# XXX do parsing - data structure?
self.menu = []
for node in self._doc.getElementsByTagName('AppMenu'):
self._parseAppMenu(self.menu, node)
def _parseAppMenu(self, menus, node):
"""Recursivly parse the s"""
for item in node.getElementsByTagName('Item'):
opt=item.getAttribute('option')
labels={}
for label in item.getElementsByTagName('Label'):
lang=label.getAttributeNS(XML_NAMESPACE, 'lang')
labels[lang]=_data(label)
sub_menus=[]
for sub in item.getElementsByTagName('AppMenu'):
self._parseAppMenu(sub_menus, sub)
menus.append({'option': opt, 'label':
labels, 'sub-menus': sub_menus})
def getAbout(self, elname, langs=None):
"""Return an entry from the section.
elname is the name of the element to return text from
langs is a list of acceptable languages, or None to use
rox.i18n.langs
"""
langs = _getlangs(langs)
for lang in langs:
if self.about.has_key(lang):
if self.about[lang].has_key(elname):
return self.about[lang][elname]
else:
return None
def getAuthors(self, langs=None):
"""Return the contents of the element in the
section (also tries if needed."""
auth=self.getAbout('Authors', langs)
if auth is None:
auth=self.getAbout('Author', langs)
if auth is None:
return ''
return auth[1]
def setAbout(self, elname, value, lang):
"""Set the value of an element in the section.
If no element 'elname' is present in the section with the
matching 'lang' attribute, append a new one. If no such section
exists yet, create it first.
value must be a unicode string.
"""
if not self.about.has_key(lang):
ab = self._doc.createElement('About')
ab.setAttributeNS(XML_NAMESPACE, 'xml:lang', lang)
self._doc.documentElement.appendChild(ab)
for ab in self._doc.documentElement.getElementsByTagName('About'):
if ab.getAttributeNS(XML_NAMESPACE, 'lang') == lang:
for node in ab.childNodes:
if node.nodeType == Node.ELEMENT_NODE and \
node.localName == elname:
ab.removeChild(node)
el = self._doc.createElement(elname)
text = self._doc.createTextNode(value)
el.appendChild(text)
ab.appendChild(el)
self._parseAbout()
def getSummary(self, langs=None):
"""Return the content of the element.
langs is a list of acceptable languages, or None to use
rox.i18n.langs
"""
langs = _getlangs(langs)
for lang in langs:
if self.summary.has_key(lang):
return self.summary[lang]
else:
return None
def setSummary(self, value, lang):
"""Set content of the Summary element with matching 'lang' attribute.
If no such element is present, append a new one to the DOM object.
value must be a unicode string.
"""
if self.summary.has_key(lang):
for sum in self._doc.documentElement.getElementsByTagName(
'Summary'):
if sum.getAttributeNS(XML_NAMESPACE, 'lang') == lang:
sum.parentNode.removeChild(sum)
sum = self._doc.createElement('Summary')
sum.setAttributeNS(XML_NAMESPACE, 'xml:lang', lang)
text = self._doc.createTextNode(value)
sum.appendChild(text)
self._doc.documentElement.appendChild(sum)
self._parseSummary()
def findElements(self, elname, ns=None):
"""Return all instances of the named element with an optional name
space. They are returned as DOM objects."""
if ns is None:
return self._doc.getElementsByTagName(elname)
return self._doc.getElementsByTagNameNS(ns, elname)
def _getMenu(self, item, langs):
ritem={'option': item['option']}
labels=item['label']
for lang in langs:
#print labels, lang, labels.has_key(lang)
if labels.has_key(lang):
ritem['label']=labels[lang]
break
else:
try:
ritem['label']=labels['']
except:
ritem['label']=''
subs=[]
for s in item['sub-menus']:
subs.append(self._getMenu(s, langs))
ritem['sub-menus']=subs
return ritem
def getAppMenu(self, langs=None):
"""Return list of all menu entries. Each item in the list is a
dictionary with these keys:
'option': the option to pass to the app for each item
'label': the label of the item in an appropriate language
'sub-menus': list of sub menu items"""
langs = _getlangs(langs)
menus=[]
for item in self.menu:
menus.append(self._getMenu(item, langs))
return menus
def _getTypeList(self, element):
types=[]
for node in self._doc.getElementsByTagName(element):
for t in node.getElementsByTagNameNS(None, 'MimeType'):
types.append(t.getAttribute('type'))
return types
def getCanRun(self):
"""Return list of named MIME types that this application declares
it can handle."""
return self._getTypeList('CanRun')
def getCanThumbnail(self):
"""Return list of named MIME types that this application declares
it can generate thumbnails for."""
return self._getTypeList('CanThumbnail')
def __str__(self):
return self._doc.toprettyxml('', '', encoding='utf-8')
def writeToFile(self, fname):
fp = open(fname, 'wb')
fp.write(str(self))
fp.close()
# Some test code
if __name__=='__main__':
print _getlangs(None)
ai=AppInfo(sys.argv[1])
#print ai
print 'Summary: %s' % ai.getSummary()
print ai.getAbout('Authors')
print 'Authors: %s' % ai.getAuthors()
#print ai.findElements('AppMenu')
print ai.menu
for menu in ai.getAppMenu():
print '%s (%s) -> %d sub' % (menu['label'], menu['option'],
len(menu['sub-menus']))
#print ai.findElements('CanRun')
print ai.getCanRun()
print ai.getCanThumbnail()
Ticker_0.4.5pre17/rox/InfoWin.py 0100644 0000766 0000000 00000006322 10024415153 015123 0 ustar rene root """Provide a standard window for displaying application information."""
import os
import rox
from rox import g
import webbrowser
class InfoWin(g.Dialog):
"""Window to show app info"""
def __init__(self, program, purpose, version, author, website):
g.Dialog.__init__(self)
self.website=website
def close(iw, event=None, data=None):
iw.hide()
self.connect("delete_event", close)
hbox=g.HBox()
self.vbox.pack_start(hbox)
hbox.show()
try:
path=os.path.join(rox.app_dir, '.DirIcon')
pixbuf=g.gdk.pixbuf_new_from_file(path)
icon=g.Image()
icon.set_from_pixbuf(pixbuf)
hbox.pack_start(icon)
icon.show()
except:
#rox.report_exception()
pass
table=g.Table(5, 2)
hbox.pack_start(table)
label=g.Label("Program")
table.attach(label, 0, 1, 0, 1)
frame=g.Frame()
frame.set_shadow_type(g.SHADOW_IN)
table.attach(frame, 1, 2, 0, 1)
label=g.Label(program or '')
frame.add(label)
label=g.Label("Purpose")
table.attach(label, 0, 1, 1, 2)
frame=g.Frame()
frame.set_shadow_type(g.SHADOW_IN)
table.attach(frame, 1, 2, 1, 2)
label=g.Label(purpose or '')
frame.add(label)
label=g.Label("Version")
table.attach(label, 0, 1, 2, 3)
frame=g.Frame()
frame.set_shadow_type(g.SHADOW_IN)
table.attach(frame, 1, 2, 2, 3)
label=g.Label(version or '')
frame.add(label)
label=g.Label("Authors")
table.attach(label, 0, 1, 3, 4)
frame=g.Frame()
frame.set_shadow_type(g.SHADOW_IN)
table.attach(frame, 1, 2, 3, 4)
label=g.Label(author or '')
frame.add(label)
label=g.Label("Web site")
table.attach(label, 0, 1, 5, 6)
if website:
button=g.Button(website)
table.attach(button, 1, 2, 5, 6)
def goto_website(widget, iw):
webbrowser.open(iw.website)
button.connect("clicked", goto_website, self)
else:
frame=g.Frame()
frame.set_shadow_type(g.SHADOW_IN)
table.attach(frame, 1, 2, 5, 6)
hbox=self.action_area
button=g.Button(stock=g.STOCK_CLOSE)
hbox.pack_start(button)
def dismiss(widget, iw):
iw.hide()
button.connect("clicked", dismiss, self)
button.show()
self.vbox.show_all()
import rox.AppInfo
def infowin(pname, info=None):
"""Open info window for this program. info is a source of the
AppInfo.xml file, if None then $APP_DIR/AppInfo.xml is loaded instead"""
if info is None:
info=os.path.join(rox.app_dir, 'AppInfo.xml')
try:
app_info=rox.AppInfo.AppInfo(info)
except:
rox.report_exception()
return
try:
iw=InfoWin(pname, app_info.getAbout('Purpose')[1],
app_info.getAbout('Version')[1],
app_info.getAuthors(),
app_info.getAbout('Homepage')[1])
iw.show()
return iw
except:
rox.report_exception()
Ticker_0.4.5pre17/rox/Menu.py 0100644 0000766 0000000 00000007245 10024415153 014463 0 ustar rene root """The Menu widget provides an easy way to create menus that allow the user to
define keyboard shortcuts, and saves the shortcuts automatically. You only define
each Menu once, and attach it to windows as required.
Example:
from rox.Menu import Menu, set_save_name
set_save_name('Edit')
menu = Menu('main', [
('/File', '', ''),
('/File/Save', 'save', ''),
('/File/Open Parent', 'up', ''),
('/File/Close', 'close', ''),
('/File/', '', ''),
('/File/New', 'new', ''),
('/Edit', '', ''),
('/Edit/Undo', 'undo', ''),
('/Edit/Redo', 'redo', ''),
('/Edit/', '', ''),
('/Edit/Search...', 'search', ''),
('/Edit/Goto line...', 'goto', ''),
('/Edit/', '', ''),
('/Edit/Process...', 'process', ''),
('/Options', 'show_options', ''),
('/Help', 'help', '', 'F1', g.STOCK_HELP),
])
"""
import rox
from rox import g
import choices
_save_name = None
def set_save_name(prog, leaf = 'menus'):
"""Set the directory/leafname (see choices) used to save the menu keys.
Call this before creating any menus."""
global _save_name
_save_name = (prog, leaf)
class Menu:
def __init__(self, name, items):
"""names should be unique (eg, 'popup', 'main', etc).
items is a list of menu items:
[(name, callback_name, type, key), ...].
'name' is the item's path.
'callback_name' is the NAME of a method to call.
'type' is as for g.ItemFactory.
'key' is only used if no bindings are in Choices."""
if not _save_name:
raise Exception('Call rox.Menu.set_save_name() first!')
ag = g.AccelGroup()
self.accel_group = ag
factory = g.ItemFactory(g.Menu, '<%s>' % name, ag)
program, save_leaf = _save_name
path = choices.load(program, save_leaf)
out = []
self.fns = []
for item in items:
stock = None
key = None
if len(item) == 3:
(label, fn, type) = item
elif len(item) == 4:
(label, fn, type, key) = item
else:
(label, fn, type, key, stock) = item
if fn:
self.fns.append(fn)
cb = self._activate
else:
cb = None
if stock:
out.append((label, key, cb, len(self.fns) - 1, type, stock))
else:
out.append((label, key, cb, len(self.fns) - 1, type))
factory.create_items(out)
self.factory = factory
if path:
g.accel_map_load(path)
self.caller = None # Caller of currently open menu
self.menu = factory.get_widget('<%s>' % name)
def keys_changed(*unused):
program, name = _save_name
path = choices.save(program, name)
if path:
try:
g.accel_map_save(path)
except AttributeError:
print "Error saving keybindings to", path
ag.connect('accel_changed', keys_changed)
def attach(self, window, object):
"""Keypresses on this window will be treated as menu shortcuts
for this object, calling 'object.' when used."""
def kev(w, k):
self.caller = object
return 0
window.connect('key-press-event', kev)
window.add_accel_group(self.accel_group)
def _position(self, menu):
x, y, mods = g.gdk.get_default_root_window().get_pointer()
width, height = menu.size_request()
return (x - width * 3 / 4, y - 16, True)
def popup(self, caller, event, position_fn = None):
"""Display the menu. Call 'caller.' when an item is chosen.
For applets, position_fn should be my_applet.position_menu)."""
self.caller = caller
if event:
self.menu.popup(None, None, position_fn or self._position, event.button, event.time)
else:
self.menu.popup(None, None, position_fn or self._position, 0, 0)
def _activate(self, action, widget):
if self.caller:
try:
getattr(self.caller, self.fns[action])()
except:
rox.report_exception()
else:
raise Exception("No caller for menu!")
Ticker_0.4.5pre17/rox/OptionsBox.py 0100644 0000766 0000000 00000040603 10024415153 015656 0 ustar rene root """The OptionsBox widget is used to edit an OptionGroup.
For simple applications, rox.edit_options() provides an
easy way to edit the options.
You can sub-class OptionsBox to provide new types of
option widget.
"""
from rox import g, options, _
import rox
from xml.dom import Node, minidom
import gobject
REVERT = 1
def data(node):
"""Return all the text directly inside this DOM Node."""
return ''.join([text.nodeValue for text in node.childNodes
if text.nodeType == Node.TEXT_NODE])
class OptionsBox(g.Dialog):
"""OptionsBox can be sub-classed to provide your own widgets, by
creating extra build_* functions. Each build funtion takes a DOM
Element from the /Options.xml file and returns a list of
GtkWidgets to add to the box. The function should be named after
the element ( -> def build_foo()).
When creating the widget, self.handlers[option] should be set to
a pair of functions (get, set) called to get and set the value
shown in the widget.
When the widget is modified, call self.check_widget(option) to
update the stored values.
"""
def __init__(self, options_group, options_xml, translation = None):
"""options_xml is an XML file, usually /Options.xml,
which defines the layout of the OptionsBox.
It contains an root element containing (nested)
elements. Each contains a number of widgets,
some of which correspond to options. The build_* functions are
used to create them.
Example:
When saving an untitled file, use this name as the default.
...
"""
assert isinstance(options_group, options.OptionGroup)
if translation is None:
import __main__
if hasattr(__main__.__builtins__, '_'):
translation = __main__.__builtins__._
else:
translation = lambda x: x
self._ = translation
g.Dialog.__init__(self)
self.tips = g.Tooltips()
self.set_has_separator(False)
self.options = options_group
self.set_title(('%s options') % options_group.program)
self.set_position(g.WIN_POS_CENTER)
button = rox.ButtonMixed(g.STOCK_UNDO, _('_Revert'))
self.add_action_widget(button, REVERT)
self.tips.set_tip(button, _('Restore all options to how they were '
'when the window was opened'))
self.add_button(g.STOCK_OK, g.RESPONSE_OK)
doc = minidom.parse(options_xml)
assert doc.documentElement.localName == 'options'
self.handlers = {} # Option -> (get, set)
self.revert = {} # Option -> old value
self.build_window_frame()
# Add each section
n = 0
for section in doc.documentElement.childNodes:
if section.nodeType != Node.ELEMENT_NODE:
continue
if section.localName != 'section':
print "Unknown section", section
continue
self.build_section(section, None)
n += 1
if n > 1:
self.tree_view.expand_all()
else:
self.sections_swin.hide()
self.updating = 0
def destroyed(widget):
rox.toplevel_unref()
if self.changed():
try:
self.options.save()
except:
rox.report_exception()
self.connect('destroy', destroyed)
def got_response(widget, response):
if response == g.RESPONSE_OK:
self.destroy()
elif response == REVERT:
for o in self.options:
o._set(self.revert[o])
self.update_widgets()
self.options.notify()
self.update_revert()
self.connect('response', got_response)
def open(self):
"""Show the window, updating all the widgets at the same
time. Use this instead of show()."""
rox.toplevel_ref()
for option in self.options:
self.revert[option] = option.value
self.update_widgets()
self.update_revert()
self.show()
def update_revert(self):
"Shade/unshade the Revert button. Internal."
self.set_response_sensitive(REVERT, self.changed())
def changed(self):
"""Check whether any options have different values (ie, whether Revert
will do anything)."""
for option in self.options:
if option.value != self.revert[option]:
return True
return False
def update_widgets(self):
"Make widgets show current values. Internal."
assert not self.updating
self.updating = 1
try:
for option in self.options:
try:
handler = self.handlers[option][1]
except KeyError:
print "No widget for option '%s'!" % option
else:
handler()
finally:
self.updating = 0
def build_window_frame(self):
"Create the main structure of the window."
hbox = g.HBox(False, 4)
self.vbox.pack_start(hbox, True, True, 0)
# scrolled window for the tree view
sw = g.ScrolledWindow()
sw.set_shadow_type(g.SHADOW_IN)
sw.set_policy(g.POLICY_NEVER, g.POLICY_AUTOMATIC)
hbox.pack_start(sw, False, True, 0)
self.sections_swin = sw # Used to hide it...
# tree view
model = g.TreeStore(gobject.TYPE_STRING, gobject.TYPE_INT)
tv = g.TreeView(model)
sel = tv.get_selection()
sel.set_mode(g.SELECTION_BROWSE)
tv.set_headers_visible(False)
self.sections = model
self.tree_view = tv
tv.unset_flags(g.CAN_FOCUS) # Stop irritating highlight
# Add a column to display column 0 of the store...
cell = g.CellRendererText()
column = g.TreeViewColumn('Section', cell, text = 0)
tv.append_column(column)
sw.add(tv)
# main options area
frame = g.Frame()
frame.set_shadow_type(g.SHADOW_IN)
hbox.pack_start(frame, True, True, 0)
notebook = g.Notebook()
notebook.set_show_tabs(False)
notebook.set_show_border(False)
frame.add(notebook)
self.notebook = notebook
# Flip pages
# (sel = sel; pygtk bug?)
def change_page(tv, sel = sel, notebook = notebook):
selected = sel.get_selected()
if not selected:
return
model, iter = selected
page = model.get_value(iter, 1)
notebook.set_current_page(page)
sel.connect('changed', change_page)
self.vbox.show_all()
def check_widget(self, option):
"A widgets call this when the user changes its value."
if self.updating:
return
assert isinstance(option, options.Option)
new = self.handlers[option][0]()
if new == option.value:
return
option._set(new)
self.options.notify()
self.update_revert()
def build_section(self, section, parent):
"""Create a new page for the notebook and a new entry in the
sections tree, and build all the widgets inside the page."""
page = g.VBox(False, 4)
page.set_border_width(4)
self.notebook.append_page(page, g.Label('unused'))
iter = self.sections.append(parent)
self.sections.set(iter, 0, section.getAttribute('title'),
1, self.notebook.page_num(page))
for node in section.childNodes:
if node.nodeType != Node.ELEMENT_NODE:
continue
name = node.localName
if name == 'section':
self.build_section(node, iter)
else:
self.build_widget(node, page)
page.show_all()
def build_widget(self, node, box):
"""Dispatches the job of dealing with a DOM Node to the
appropriate build_* function."""
label = node.getAttribute('label')
name = node.getAttribute('name')
if label:
label = self._(label)
option = None
if name:
try:
option = self.options.options[name]
except KeyError:
raise Exception("Unknown option '%s'" % name)
try:
name = node.localName.replace('-', '_')
fn = getattr(self, 'build_' + name)
except AttributeError:
print "Unknown widget type '%s'" % node.localName
else:
if option:
widgets = fn(node, label, option)
else:
widgets = fn(node, label)
for w in widgets:
box.pack_start(w, False, True, 0)
def may_add_tip(self, widget, node):
"""If 'node' contains any text, use that as the tip for 'widget'."""
if node.childNodes:
data = ''.join([n.nodeValue for n in node.childNodes]).strip()
else:
data = None
if data:
self.tips.set_tip(widget, self._(data))
# Each type of widget has a method called 'build_NAME' where name is
# the XML element name. This method is called as method(node, label,
# option) if it corresponds to an Option, or method(node, label)
# otherwise. It should return a list of widgets to add to the window
# and, if it's for an Option, set self.handlers[option] = (get, set).
def build_label(self, node, label):
""""""
return [g.Label(data(node))]
def build_spacer(self, node, label):
""""""
eb = g.EventBox()
eb.set_size_request(8, 8)
return [eb]
def build_hbox(self, node, label):
"""... to layout child widgets horizontally."""
return self.do_box(node, label, g.HBox(False, 4))
def build_vbox(self, node, label):
"""... to layout child widgets vertically."""
return self.do_box(node, label, g.VBox(False, 0))
def do_box(self, node, label, widget):
"Helper function for building hbox, vbox and frame widgets."
if label:
widget.pack_start(g.Label(label), False, True, 4)
for child in node.childNodes:
if child.nodeType == Node.ELEMENT_NODE:
self.build_widget(child, widget)
return [widget]
def build_frame(self, node, label):
"""... to group options under a heading."""
frame = g.Frame(label)
frame.set_shadow_type(g.SHADOW_NONE)
# Make the label bold...
# (bug in pygtk => use set_markup)
label_widget = frame.get_label_widget()
label_widget.set_markup('' + label + '')
#attr = pango.AttrWeight(pango.WEIGHT_BOLD)
#attr.start_index = 0
#attr.end_index = -1
#list = pango.AttrList()
#list.insert(attr)
#label_widget.set_attributes(list)
vbox = g.VBox(False, 4)
vbox.set_border_width(12)
frame.add(vbox)
self.do_box(node, None, vbox)
return [frame]
def build_entry(self, node, label, option):
"Tooltip"
box = g.HBox(False, 4)
entry = g.Entry()
if label:
label_wid = g.Label(label)
label_wid.set_alignment(1.0, 0.5)
box.pack_start(label_wid, False, True, 0)
box.pack_start(entry, True, True, 0)
else:
box = None
self.may_add_tip(entry, node)
entry.connect('changed', lambda e: self.check_widget(option))
def get():
return entry.get_chars(0, -1)
def set():
entry.set_text(option.value)
self.handlers[option] = (get, set)
return [box or entry]
def build_font(self, node, label, option):
"Tooltip"
button = FontButton(self, option, label)
self.may_add_tip(button, node)
hbox = g.HBox(False, 4)
hbox.pack_start(g.Label(label), False, True, 0)
hbox.pack_start(button, False, True, 0)
self.handlers[option] = (button.get, button.set)
return [hbox]
def build_colour(self, node, label, option):
"Tooltip"
button = ColourButton(self, option, label)
self.may_add_tip(button, node)
hbox = g.HBox(False, 4)
hbox.pack_start(g.Label(label), False, True, 0)
hbox.pack_start(button, False, True, 0)
self.handlers[option] = (button.get, button.set)
return [hbox]
def build_numentry(self, node, label, option):
"""Tooltip.
Lets the user choose a number from min to max."""
minv = int(node.getAttribute('min'))
maxv = int(node.getAttribute('max'))
step = node.getAttribute('step')
if step:
step = int(step)
else:
step = 1
unit = self._(node.getAttribute('unit'))
hbox = g.HBox(False, 4)
if label:
widget = g.Label(label)
widget.set_alignment(1.0, 0.5)
hbox.pack_start(widget, False, True, 0)
spin = g.SpinButton(g.Adjustment(minv, minv, maxv, step))
spin.set_width_chars(max(len(str(minv)), len(str(maxv))))
hbox.pack_start(spin, False, True, 0)
self.may_add_tip(spin, node)
if unit:
hbox.pack_start(g.Label(unit), False, True, 0)
self.handlers[option] = (
lambda: str(spin.get_value()),
lambda: spin.set_value(option.int_value))
spin.connect('value-changed', lambda w: self.check_widget(option))
return [hbox]
def build_menu(self, node, label, option):
"""Build an OptionMenu widget, only one item of which may be selected.
"""
values = []
option_menu = g.OptionMenu()
menu = g.Menu()
option_menu.set_menu(menu)
if label:
box = g.HBox(False, 4)
label_wid = g.Label(label)
label_wid.set_alignment(1.0, 0.5)
box.pack_start(label_wid, False, True, 0)
box.pack_start(option_menu, True, True, 0)
else:
box = None
#self.may_add_tip(option_menu, node)
for item in node.getElementsByTagName('item'):
value = item.getAttribute('value')
assert value
label_item = item.getAttribute('label') or value
menu.append(g.MenuItem(label_item))
values.append(value)
option_menu.connect('changed', lambda e: self.check_widget(option))
def get():
return values[option_menu.get_history()]
def set():
try:
option_menu.set_history(values.index(option.value))
except ValueError:
print "Value '%s' not in combo list" % option.value
self.handlers[option] = (get, set)
return [box or option_menu]
def build_radio_group(self, node, label, option):
"""Build a list of radio buttons, only one of which may be selected.
TooltipTooltip"""
radios = []
values = []
button = None
for radio in node.getElementsByTagName('radio'):
label = self._(radio.getAttribute('label'))
button = g.RadioButton(button, label)
self.may_add_tip(button, radio)
radios.append(button)
values.append(radio.getAttribute('value'))
button.connect('toggled', lambda b: self.check_widget(option))
def set():
try:
i = values.index(option.value)
except:
print "Value '%s' not in radio group!" % option.value
i = 0
radios[i].set_active(True)
def get():
for r, v in zip(radios, values):
if r.get_active():
return v
raise Exception('Nothing selected!')
self.handlers[option] = (get, set)
return radios
def build_toggle(self, node, label, option):
"Tooltip"
toggle = g.CheckButton(label)
self.may_add_tip(toggle, node)
self.handlers[option] = (
lambda: str(toggle.get_active()),
lambda: toggle.set_active(option.int_value))
toggle.connect('toggled', lambda w: self.check_widget(option))
return [toggle]
class FontButton(g.Button):
def __init__(self, option_box, option, title):
g.Button.__init__(self)
self.option_box = option_box
self.option = option
self.title = title
self.label = g.Label('')
self.add(self.label)
self.dialog = None
self.connect('clicked', self.clicked)
def set(self):
self.label.set_text(self.option.value)
if self.dialog:
self.dialog.destroy()
def get(self):
return self.label.get()
def clicked(self, button):
if self.dialog:
self.dialog.destroy()
def closed(dialog):
self.dialog = None
def response(dialog, resp):
if resp != g.RESPONSE_OK:
dialog.destroy()
return
self.label.set_text(dialog.get_font_name())
dialog.destroy()
self.option_box.check_widget(self.option)
self.dialog = g.FontSelectionDialog(self.title)
self.dialog.set_position(g.WIN_POS_MOUSE)
self.dialog.connect('destroy', closed)
self.dialog.connect('response', response)
self.dialog.set_font_name(self.get())
self.dialog.show()
class ColourButton(g.Button):
def __init__(self, option_box, option, title):
g.Button.__init__(self)
self.option_box = option_box
self.option = option
self.title = title
self.set_size_request(64, 12)
self.dialog = None
self.connect('clicked', self.clicked)
def set(self, c = None):
if c is None:
c = g.gdk.color_parse(self.option.value)
self.modify_bg(g.STATE_NORMAL, c)
self.modify_bg(g.STATE_PRELIGHT, c)
self.modify_bg(g.STATE_ACTIVE, c)
def get(self):
c = self.get_style().bg[g.STATE_NORMAL]
return '#%04x%04x%04x' % (c.red, c.green, c.blue)
def clicked(self, button):
if self.dialog:
self.dialog.destroy()
def closed(dialog):
self.dialog = None
def response(dialog, resp):
if resp != g.RESPONSE_OK:
dialog.destroy()
return
self.set(dialog.colorsel.get_current_color())
dialog.destroy()
self.option_box.check_widget(self.option)
self.dialog = g.ColorSelectionDialog(self.title)
self.dialog.set_position(g.WIN_POS_MOUSE)
self.dialog.connect('destroy', closed)
self.dialog.connect('response', response)
c = self.get_style().bg[g.STATE_NORMAL]
self.dialog.colorsel.set_current_color(c)
self.dialog.show()
Ticker_0.4.5pre17/rox/__init__.py 0100644 0000766 0000000 00000026413 10024415153 015314 0 ustar rene root """To use ROX-Lib2 you need to copy the findrox.py script into your application
directory and import that before anything else. This module will locate
ROX-Lib2 and add ROX-Lib2/python to sys.path. If ROX-Lib2 is not found, it
will display a suitable error and quit.
Since the name of the gtk2 module can vary, it is best to import it from rox,
where it is named 'g'.
The AppRun script of a simple application might look like this:
#!/usr/bin/env python
import findrox
import rox
window = rox.Window()
window.set_title('My window')
window.show()
rox.mainloop()
This program creates and displays a window. The rox.Window widget keeps
track of how many toplevel windows are open. rox.mainloop() will return
when the last one is closed.
'rox.app_dir' is set to the absolute pathname of your application (extracted
from sys.argv).
The builtin names True and False are defined to 1 and 0, if your version of
python is old enough not to include them already.
"""
import sys, os, codecs
to_utf8 = codecs.getencoder('utf-8')
## patched
roxlib_version = (1, 9, 12)
_path = os.path.realpath(sys.argv[0])
app_dir = os.path.dirname(_path)
if _path.endswith('/AppRun') or _path.endswith('/AppletRun'):
sys.argv[0] = os.path.dirname(_path)
# In python2.3 there is a bool type. Later versions of 2.2 use ints, but
# early versions don't support them at all, so create them here.
try:
True
except:
import __builtin__
__builtin__.False = 0
__builtin__.True = 1
try:
iter
except:
sys.stderr.write('Sorry, you need to have python 2.2, and it \n'
'must be the default version. You may be able to \n'
'change the first line of your program\'s AppRun \n'
'file to end \'python2.2\' as a workaround.\n')
raise SystemExit(1)
import i18n
_roxlib_dir = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
_ = i18n.translation(os.path.join(_roxlib_dir, 'Messages'))
_old_sys_path = sys.path[:]
try:
zhost = 'zero-install.sourceforge.net'
zpath = '/uri/0install/' + zhost
if not os.getenv('ROXLIB_DISABLE_ZEROINSTALL') and os.path.exists(zpath):
zpath = os.path.join(zpath, 'libs/pygtk-2/platform/latest')
if not os.path.exists(zpath):
os.system('0refresh ' + zhost)
if os.path.exists(zpath):
sys.path.insert(0, zpath +
'/lib/python%d.%d/site-packages' % sys.version_info[:2])
import pygtk; pygtk.require('2.0')
import gtk._gtk # If this fails, don't leave a half-inited gtk
import gtk; g = gtk # Don't syntax error for python1.5
assert g.Window # Ensure not 1.2 bindings
except:
try:
# Try again without Zero Install
sys.path = _old_sys_path
if 'gtk' in sys.modules:
del sys.modules['gtk']
try:
# Try to support 1.99.12, at least to show an error
import pygtk; pygtk.require('2.0')
except:
print "Warning: very old pygtk!"
import gtk; g = gtk # Don't syntax error for python1.5
assert g.Window # Ensure not 1.2 bindings
except:
sys.stderr.write(_('The pygtk2 package (1.99.13 or later) must be '
'installed to use this program:\n'
'http://rox.sourceforge.net/rox_lib.php3\n'))
raise
# Put argv back the way it was, now that Gtk has initialised
sys.argv[0] = _path
TRUE = True
FALSE = False
def alert(message):
"Display message in an error box. Return when the user closes the box."
toplevel_ref()
box = g.MessageDialog(None, 0, g.MESSAGE_ERROR, g.BUTTONS_OK, message)
box.set_position(g.WIN_POS_CENTER)
box.set_title(_('Error'))
box.run()
box.destroy()
toplevel_unref()
def bug(message = "A bug has been detected in this program. Please report "
"the problem to the authors."):
"Display an error message and offer a debugging prompt."
try:
raise Exception(message)
except:
type, value, tb = sys.exc_info()
import debug
debug.show_exception(type, value, tb, auto_details = True)
def croak(message):
"""Display message in an error box, then quit the program, returning
with a non-zero exit status."""
alert(message)
sys.exit(1)
def info(message):
"Display informational message. Returns when the user closes the box."
toplevel_ref()
box = g.MessageDialog(None, 0, g.MESSAGE_INFO, g.BUTTONS_OK, message)
box.set_position(g.WIN_POS_CENTER)
box.set_title(_('Information'))
box.run()
box.destroy()
toplevel_unref()
def confirm(message, stock_icon, action = None):
"""Display a / dialog. Result is true if the user
chooses the action, false otherwise. If action is given then that
is used as the text instead of the default for the stock item. Eg:
if rox.confirm('Really delete everything?', g.STOCK_DELETE): delete()
"""
toplevel_ref()
box = g.MessageDialog(None, 0, g.MESSAGE_QUESTION,
g.BUTTONS_CANCEL, message)
if action:
button = ButtonMixed(stock_icon, action)
else:
button = g.Button(stock = stock_icon)
button.set_flags(g.CAN_DEFAULT)
button.show()
box.add_action_widget(button, g.RESPONSE_OK)
box.set_position(g.WIN_POS_CENTER)
box.set_title(_('Confirm:'))
box.set_default_response(g.RESPONSE_OK)
resp = box.run()
box.destroy()
toplevel_unref()
return resp == g.RESPONSE_OK
def report_exception():
"""Display the current python exception in an error box, returning
when the user closes the box. This is useful in the 'except' clause
of a 'try' block. Uses rox.debug.show_exception()."""
type, value, tb = sys.exc_info()
import debug
debug.show_exception(type, value, tb)
_icon_path = os.path.join(app_dir, '.DirIcon')
_window_icon = None
if os.path.exists(_icon_path):
try:
g.window_set_default_icon_list(g.gdk.pixbuf_new_from_file(_icon_path))
except:
# Older pygtk
_window_icon = g.gdk.pixbuf_new_from_file(_icon_path)
del _icon_path
class Window(g.Window):
"""This works in exactly the same way as a GtkWindow, except that
it calls the toplevel_(un)ref functions for you automatically,
and sets the window icon to /.DirIcon if it exists."""
def __init__(*args, **kwargs):
apply(g.Window.__init__, args, kwargs)
toplevel_ref()
args[0].connect('destroy', toplevel_unref)
if _window_icon:
args[0].set_icon(_window_icon)
class Dialog(g.Dialog):
"""This works in exactly the same way as a GtkDialog, except that
it calls the toplevel_(un)ref functions for you automatically."""
def __init__(*args, **kwargs):
apply(g.Dialog.__init__, args, kwargs)
toplevel_ref()
args[0].connect('destroy', toplevel_unref)
class ButtonMixed(g.Button):
"""A button with a standard stock icon, but any label. This is useful
when you want to express a concept similar to one of the stock ones."""
def __init__(self, stock, message):
"""Specify the icon and text for the new button. The text
may specify the mnemonic for the widget by putting a _ before
the letter, eg:
button = ButtonMixed(g.STOCK_DELETE, '_Delete message')."""
g.Button.__init__(self)
label = g.Label('')
label.set_text_with_mnemonic(message)
label.set_mnemonic_widget(self)
image = g.image_new_from_stock(stock, g.ICON_SIZE_BUTTON)
box = g.HBox(FALSE, 2)
align = g.Alignment(0.5, 0.5, 0.0, 0.0)
box.pack_start(image, FALSE, FALSE, 0)
box.pack_end(label, FALSE, FALSE, 0)
self.add(align)
align.add(box)
align.show_all()
_toplevel_windows = 0
_in_mainloops = 0
def mainloop():
"""This is a wrapper around the gtk2.mainloop function. It only runs
the loop if there are top level references, and exits when
rox.toplevel_unref() reduces the count to zero."""
global _toplevel_windows, _in_mainloops
_in_mainloops = _in_mainloops + 1 # Python1.5 syntax
try:
while _toplevel_windows:
g.mainloop()
finally:
_in_mainloops = _in_mainloops - 1
def toplevel_ref():
"""Increment the toplevel ref count. rox.mainloop() won't exit until
toplevel_unref() is called the same number of times."""
global _toplevel_windows
_toplevel_windows = _toplevel_windows + 1
def toplevel_unref(*unused):
"""Decrement the toplevel ref count. If this is called while in
rox.mainloop() and the count has reached zero, then rox.mainloop()
will exit. Ignores any arguments passed in, so you can use it
easily as a callback function."""
global _toplevel_windows
assert _toplevel_windows > 0
_toplevel_windows = _toplevel_windows - 1
if _toplevel_windows == 0 and _in_mainloops:
g.mainquit()
_host_name = None
def our_host_name():
"""Try to return the canonical name for this computer. This is used
in the drag-and-drop protocol to work out whether a drop is coming from
a remote machine (and therefore has to be fetched differently)."""
from socket import getfqdn
global _host_name
if _host_name:
return _host_name
try:
_host_name = getfqdn()
except:
_host_name = 'localhost'
alert("ROX-Lib socket.getfqdn() failed!")
return _host_name
def escape(uri):
"Convert each space to %20, etc"
import re
return re.sub('[^-_./a-zA-Z0-9]',
lambda match: '%%%02x' % ord(match.group(0)),
to_utf8(uri)[0])
def unescape(uri):
"Convert each %20 to a space, etc"
if '%' not in uri: return uri
import re
return re.sub('%[0-9a-fA-F][0-9a-fA-F]',
lambda match: chr(int(match.group(0)[1:], 16)),
uri)
def get_local_path(uri):
"""Convert 'uri' to a local path and return, if possible. If 'uri'
is a resource on a remote machine, return None. URI is in the escaped form
(%20 for space)."""
if not uri:
return None
if uri[0] == '/':
if uri[1:2] != '/':
return unescape(uri) # A normal Unix pathname
i = uri.find('/', 2)
if i == -1:
return None # //something
if i == 2:
return unescape(uri[2:]) # ///path
remote_host = uri[2:i]
if remote_host == our_host_name():
return unescape(uri[i:]) # //localhost/path
# //otherhost/path
elif uri[:5].lower() == 'file:':
if uri[5:6] == '/':
return get_local_path(uri[5:])
elif uri[:2] == './' or uri[:3] == '../':
return unescape(uri)
return None
app_options = None
def setup_app_options(program, leaf = 'Options.xml'):
"""Most applications only have one set of options. This function can be
used to set up the default group. 'program' is the name of the
directory to use in and 'leaf' is the name of the file used
to store the group. You can refer to the group using rox.app_options.
See rox.options.OptionGroup."""
global app_options
assert not app_options
from options import OptionGroup
app_options = OptionGroup(program, leaf)
_options_box = None
def edit_options(options_file = None):
"""Edit the app_options (set using setup_app_options()) using the GUI
specified in 'options_file' (default /Options.xml).
If this function is called again while the box is still open, the
old box will be redisplayed to the user."""
assert app_options
global _options_box
if _options_box:
_options_box.present()
return
if not options_file:
options_file = os.path.join(app_dir, 'Options.xml')
import OptionsBox
_options_box = OptionsBox.OptionsBox(app_options, options_file)
def closed(widget):
global _options_box
assert _options_box == widget
_options_box = None
_options_box.connect('destroy', closed)
_options_box.open()
try:
import xml
except:
alert(_("You do not have the Python 'xml' module installed, which "
"ROX-Lib2 requires. You need to install python-xmlbase "
"(this is a small package; the full PyXML package is not "
"required)."))
if g.pygtk_version[:2] == (1, 99) and g.pygtk_version[2] < 12:
# 1.99.12 is really too old too, but RH8.0 uses it so we'll have
# to work around any problems...
sys.stderr.write('Your version of pygtk (%d.%d.%d) is too old. '
'Things might not work correctly.' % g.pygtk_version)
Ticker_0.4.5pre17/rox/applet.py 0100644 0000766 0000000 00000003714 10024415153 015041 0 ustar rene root """To create a panel applet for ROX-Filer, you should add a file called
AppletRun to your application. This is run when your applet it dragged onto
a panel. It works like the usual AppRun, except that it is passed the XID of
the GtkSocket widget that ROX-Filer creates for you on the panel.
A sample AppletRun might look like this:
#!/usr/bin/env python
import findrox
import rox
import sys
from rox import applet, g
plug = applet.Applet(sys.argv[1])
label = g.Label('Hello\\nWorld!')
plug.add(label)
plug.show_all()
rox.mainloop()
"""
import rox
from rox import g
_root_window = g.gdk.get_default_root_window()
class Applet(g.Plug):
"""When your AppletRun file is used, create an Applet widget with
the argument passed to AppletRun. Show the widget to make it appear
in the panel. toplevel_* functions are called automatically."""
def __init__(self, xid):
"""xid is the sys.argv[1] passed to AppletRun."""
xid = long(xid)
g.Plug.__init__(self, xid)
self.socket = g.gdk.window_foreign_new(xid)
rox.toplevel_ref()
self.connect('destroy', rox.toplevel_unref)
def position_menu(self, menu):
"""Use this as the third argument to Menu.popup()."""
x, y, mods = _root_window.get_pointer()
pos = self.socket.property_get('_ROX_PANEL_MENU_POS',
'STRING', g.FALSE)
if pos: pos = pos[2]
if pos:
side, margin = pos.split(',')
margin = int(margin)
else:
side, margin = None, 2
width, height = g.gdk.screen_width(), g.gdk.screen_height()
req = menu.size_request()
if side == 'Top':
y = margin
x -= 8 + req[0] / 4
elif side == 'Bottom':
y = height - margin - req[1]
x -= 8 + req[0] / 4
elif side == 'Left':
x = margin
y -= 16
elif side == 'Right':
x = width - margin - req[0]
y -= 16
else:
x -= req[0] / 2
y -= 32
def limit(v, min, max):
if v < min: return min
if v > max: return max
return v
x = limit(x, 4, width - 4 - req[0])
y = limit(y, 4, height - 4 - req[1])
return (x, y, True)
Ticker_0.4.5pre17/rox/basedir.py 0100644 0000766 0000000 00000005343 10024415153 015165 0 ustar rene root """The freedesktop.org Base Directory specification provides a way for
applications to locate shared data and configuration:
http://www.freedesktop.org/standards/
This module can be used to load and save from and to these directories.
Typical usage:
from rox import basedir
for dir in basedir.load_config_paths('MyProg/Options'):
print "Load settings from", dir
dir = basedir.save_config_path('MyProg')
print >>file(os.path.join(dir, 'Options'), 'w'), "foo=2"
Note: see the rox.Options module for a higher-level API for managing options.
"""
from __future__ import generators
import os
_home = os.environ.get('HOME', '/')
xdg_data_home = os.environ.get('XDG_DATA_HOME',
os.path.join(_home, '.local', 'share'))
xdg_data_dirs = [xdg_data_home] + \
os.environ.get('XDG_DATA_DIRS', '/usr/local/share:/usr/share').split(':')
xdg_config_home = os.environ.get('XDG_CONFIG_HOME',
os.path.join(_home, '.config'))
xdg_config_dirs = [xdg_config_home] + \
os.environ.get('XDG_CONFIG_DIRS', '/etc/xdg').split(':')
xdg_data_dirs = filter(lambda x: x, xdg_data_dirs)
xdg_config_dirs = filter(lambda x: x, xdg_config_dirs)
#print "Config load", xdg_config_dirs
#print "Config save", xdg_config_home
#print "Data load", xdg_data_dirs
#print "Data save", xdg_data_home
def save_config_path(resource):
"""Ensure $XDG_CONFIG_HOME// exists, and return its path.
'resource' should normally be the name of your application. Use this
when SAVING configuration settings. Use the xdg_config_dirs variable
for loading."""
assert not resource.startswith('/')
path = os.path.join(xdg_config_home, resource)
if not os.path.isdir(path):
os.makedirs(path, 0700)
return path
def save_data_path(resource):
"""Ensure $XDG_DATA_HOME// exists, and return its path.
'resource' is the name of some shared resource. Use this when updating
a shared (between programs) database. Use the xdg_data_dirs variable
for loading."""
assert not resource.startswith('/')
path = os.path.join(xdg_data_home, resource)
if not os.path.isdir(path):
os.makedirs(path)
return path
def load_config_paths(resource):
"""Returns an iterator which gives each directory named 'resource' in the
configuration search path. Information provided by earlier directories should
take precedence over later ones (ie, the user's config dir comes first)."""
for dir in xdg_config_dirs:
path = os.path.join(dir, resource)
if os.path.exists(path): yield path
def load_data_paths(resource):
"""Returns an iterator which gives each directory named 'resource' in the
shared data search path. Information provided by earlier directories should
take precedence over later ones."""
for dir in xdg_data_dirs:
path = os.path.join(dir, resource)
if os.path.exists(path): yield path
Ticker_0.4.5pre17/rox/choices.py 0100644 0000766 0000000 00000002536 10024415153 015172 0 ustar rene root """This module implements the Choices system for user preferences.
The environment variable CHOICESPATH gives a list of directories to search
for choices. Changed choices are saved back to the first directory in the
list."""
import os
from os.path import exists
try:
path = os.environ['CHOICESPATH']
paths = path.split(':')
except KeyError:
paths = [ os.environ['HOME'] + '/Choices',
'/usr/local/share/Choices',
'/usr/share/Choices' ]
def load(dir, leaf):
"""When you want to load user choices, use this function. 'dir' is
the subdirectory within Choices where the choices are saved (usually
this will be the name of your program). 'leaf' is the file within it.
If serveral files are present, the most important one is returned. If
no files are there, returns None.
Eg ('Edit', 'Options') - > '/usr/local/share/Choices/Edit/Options'"""
for path in paths:
if path:
full = path + '/' + dir + '/' + leaf
if exists(full):
return full
return None
def save(dir, leaf, create = 1):
"""Returns a path to save to, or None if saving is disabled.
If 'create' is FALSE then no directories are created. 'dir' and
'leaf' are as for load()."""
p = paths[0]
if not p:
return None
if create and not os.path.exists(p):
os.mkdir(p, 0x1ff)
p = p + '/' + dir
if create and not os.path.exists(p):
os.mkdir(p, 0x1ff)
return p + '/' + leaf
Ticker_0.4.5pre17/rox/debug.py 0100644 0000766 0000000 00000013464 10024415153 014645 0 ustar rene root """This module provides features to help with debugging ROX applications."""
import sys, os
import traceback
import gobject
import linecache
from rox import g, ButtonMixed, toplevel_ref, toplevel_unref, _
from rox import info, alert
from saving import StringSaver
savebox = None
def show_exception(type, value, tb, auto_details = False):
"""Display this exception in an error box. The user has the options
of ignoring the error, quitting the application and examining the
exception in more detail. See also rox.report_exception()."""
QUIT = 1
DETAILS = 2
SAVE = 3
brief = ''.join(traceback.format_exception_only(type, value))
toplevel_ref()
box = g.MessageDialog(None, 0, g.MESSAGE_ERROR, g.BUTTONS_NONE, brief)
if not auto_details:
button = ButtonMixed(g.STOCK_ZOOM_IN, _('_Details'))
button.set_flags(g.CAN_DEFAULT)
button.show()
box.add_action_widget(button, DETAILS)
box.add_button(g.STOCK_OK, g.RESPONSE_OK)
box.set_default_response(g.RESPONSE_OK)
box.set_position(g.WIN_POS_CENTER)
box.set_title(_('Error'))
reply = []
def response(box, resp):
reply.append(resp)
g.mainquit()
box.connect('response', response)
box.show()
bug_report = 'Traceback (most recent call last):\n' + \
''.join(traceback.format_stack(tb.tb_frame.f_back) +
traceback.format_tb(tb) +
traceback.format_exception_only(type, value))
while 1:
if auto_details:
resp = DETAILS
auto_details = False
else:
g.mainloop()
resp = reply.pop()
if resp == g.RESPONSE_OK or resp == g.RESPONSE_DELETE_EVENT:
break
if resp == SAVE:
global savebox
if savebox:
savebox.destroy()
def destroy(box):
savebox = None
savebox = StringSaver(bug_report, 'BugReport')
savebox.connect('destroy', destroy)
savebox.show()
continue
if resp == QUIT:
sys.exit(1)
assert resp == DETAILS
box.set_response_sensitive(DETAILS, False)
box.set_has_separator(False)
button = ButtonMixed(g.STOCK_SAVE, _('_Bug Report'))
button.set_flags(g.CAN_DEFAULT)
button.show()
box.add_action_widget(button, SAVE)
box.action_area.set_child_secondary(button, True)
button = ButtonMixed(g.STOCK_QUIT, _('Forced Quit'))
button.set_flags(g.CAN_DEFAULT)
button.show()
box.add_action_widget(button, QUIT)
box.action_area.set_child_secondary(button, True)
ee = ExceptionExplorer(tb)
box.vbox.pack_start(ee)
ee.show()
box.destroy()
toplevel_unref()
class ExceptionExplorer(g.Frame):
FILE = 0
LINE = 1
FUNC = 2
CODE = 3
def __init__(self, tb):
g.Frame.__init__(self, _('Stack trace (innermost last)'))
vbox = g.VBox(False, 0)
self.add(vbox)
inner = g.Frame()
inner.set_shadow_type(g.SHADOW_IN)
vbox.pack_start(inner, False, True, 0)
self.savebox = None
self.tb = tb
self.model = g.ListStore(gobject.TYPE_STRING, gobject.TYPE_INT,
gobject.TYPE_STRING, gobject.TYPE_STRING)
tree = g.TreeView(self.model)
inner.add(tree)
cell = g.CellRendererText()
column = g.TreeViewColumn('File', cell, text = ExceptionExplorer.FILE)
cell.set_property('xalign', 1)
tree.append_column(column)
cell = g.CellRendererText()
column = g.TreeViewColumn('Line', cell, text = ExceptionExplorer.LINE)
tree.append_column(column)
column = g.TreeViewColumn('Func', cell, text = ExceptionExplorer.FUNC)
tree.append_column(column)
column = g.TreeViewColumn('Code', cell, text = ExceptionExplorer.CODE)
tree.append_column(column)
inner.set_border_width(5)
frames = []
while tb is not None:
frames.insert(0, (tb.tb_frame, traceback.tb_lineno(tb)))
tb = tb.tb_next
f = self.tb.tb_frame
if f:
f = f.f_back # Skip the reporting frame
while f is not None:
frames.append((f, f.f_lineno))
f = f.f_back
frames.reverse()
new = None
for f, lineno in frames:
co = f.f_code
filename = co.co_filename
name = co.co_name
line = linecache.getline(filename, lineno).strip()
filename = os.path.basename(filename)
new = self.model.append()
self.model.set(new, ExceptionExplorer.FILE, filename,
ExceptionExplorer.LINE, lineno,
ExceptionExplorer.FUNC, name,
ExceptionExplorer.CODE, line)
def selected_frame():
selected = sel.get_selected()
assert selected
model, iter = selected
frame, = model.get_path(iter)
return frames[frame][0]
vars = g.ListStore(str, str)
sel = tree.get_selection()
sel.set_mode(g.SELECTION_BROWSE)
def select_frame(tree):
vars.clear()
for n, v in selected_frame().f_locals.iteritems():
value = `v`
if len(value) > 500:
value = value[:500] + ' ...'
new = vars.append()
vars.set(new, 0, str(n), 1, value)
sel.connect('changed', select_frame)
# Area to show the local variables
tree = g.TreeView(vars)
vbox.pack_start(g.Label(_('Local variables in selected frame:')),
False, True, 0)
cell = g.CellRendererText()
column = g.TreeViewColumn('Name', cell, text = 0)
cell.set_property('xalign', 1)
tree.append_column(column)
cell = g.CellRendererText()
column = g.TreeViewColumn('Value', cell, text = 1)
tree.append_column(column)
inner = g.ScrolledWindow()
inner.set_size_request(-1, 200)
inner.set_policy(g.POLICY_AUTOMATIC, g.POLICY_ALWAYS)
inner.set_shadow_type(g.SHADOW_IN)
inner.add(tree)
inner.set_border_width(5)
vbox.pack_start(inner, True, True, 0)
if new:
sel.select_iter(new)
hbox = g.HBox(False, 4)
hbox.set_border_width(5)
vbox.pack_start(hbox, False, True, 0)
hbox.pack_start(g.Label('>>>'), False, True, 0)
expr = g.Entry()
hbox.pack_start(expr, True, True, 0)
def activate(entry):
expr = entry.get_text()
frame = selected_frame()
try:
info(`eval(expr, frame.f_locals, frame.f_globals)`)
except:
type, value = sys.exc_info()[:2]
brief = ''.join(traceback.format_exception_only(type, value))
alert(brief)
entry.grab_focus()
expr.connect('activate', activate)
vbox.show_all()
Ticker_0.4.5pre17/rox/filer.py 0100644 0000766 0000000 00000003022 10024415153 014645 0 ustar rene root """An easy way to get ROX-Filer to do things."""
# Note: do a double-fork in case it's an old version of the filer
# and doesn't automatically background itself.
def _spawn(argv):
"""Run a new process and forget about it."""
from os import fork, _exit, execvp, waitpid
child = fork()
if child == 0:
# We are the child
child = fork()
if child == 0:
# Grandchild
try:
execvp(argv[0], argv)
except:
pass
print "Warning: exec('%s') failed!" % argv[0]
_exit(1)
elif child == -1:
print "Error: fork() failed!"
_exit(1)
elif child == -1:
print "Error: fork() failed!"
waitpid(child, 0)
def spawn_rox(args):
"""Run rox (either from PATH or through Zero Install) with the
given arguments."""
import os.path
for dir in os.environ.get('PATH', '').split(':'):
path = os.path.join(dir, 'rox')
if os.path.isfile(path):
_spawn(('rox',) + args)
return
if os.path.exists('/uri/0install/rox.sourceforge.net'):
_spawn(('/bin/0run', 'rox.sourceforge.net/rox 2002-01-01') + args)
else:
print "Didn't find rox in PATH, and Zero Install not present. Trying 'rox' anyway..."
_spawn(('rox',) + args)
def open_dir(dir):
"Open 'dir' in a new filer window."
spawn_rox(('-d', dir))
def examine(file):
"""'file' may have changed (maybe you just created it, for example). Update
any filer views of it."""
spawn_rox(('-x', file))
def show_file(file):
"""Open a directory and draw the user's attention to this file. Useful for
'Up' toolbar buttons that show where a file is saved."""
spawn_rox(('-s', file))
Ticker_0.4.5pre17/rox/fileutils.py 0100644 0000766 0000000 00000005061 10024415153 015551 0 ustar rene root """Utilities to perform various operations on paths, with support for
opening the ROX filer to examine locations if things go wrong.
Typical usage:
import rox.fileutils
rox.fileutils.makedirs('/path/for/new/directory')
"""
import os
from rox import _
def report_patherror(message, path):
"""Display a // dialog.
This will raise an OSError exception if the user selects Cancel, or
will return successfully if the user chooses to retry."""
from rox import g, filer, toplevel_ref, toplevel_unref, ButtonMixed
toplevel_ref()
box = g.MessageDialog(None, 0, g.MESSAGE_QUESTION,
g.BUTTONS_CANCEL, message)
button = ButtonMixed(g.STOCK_REDO, _('Retry'))
button.set_flags(g.CAN_DEFAULT)
button.show()
box.add_action_widget(button, g.RESPONSE_OK)
button = ButtonMixed(g.STOCK_JUMP_TO, _('Examine'))
button.set_flags(g.CAN_DEFAULT)
button.show()
box.add_action_widget(button, g.RESPONSE_APPLY)
box.set_position(g.WIN_POS_CENTER)
box.set_title(_('Error:'))
box.set_default_response(g.RESPONSE_APPLY)
while 1:
resp = box.run()
if resp != g.RESPONSE_APPLY: break
filerpath = os.path.normpath(path)
filer.show_file(filerpath)
box.destroy()
toplevel_unref()
if resp != g.RESPONSE_OK:
raise OSError, message
def _makedirs_recursive(path, mode):
"""Recursive part of makedirs. Calls itself to ensure head
of path exists, and then makes a new directory at path. Returns
an Exception if it can't make a directory at path."""
if os.path.isdir(path): return
head, tail = os.path.split(path)
if not tail:
head, tail = os.path.split(head)
if head and tail:
_makedirs_recursive(head, mode)
while True:
if os.path.exists(path):
report_patherror( \
_("Could not create directory `%s' because a file already exists at that path.\n") % path, path)
continue
try:
os.mkdir(path, mode)
return
except OSError, msg:
report_patherror(("%s.\n" + _("Could not create directory `%s'.\n")) \
% (msg[1], path), path)
def makedirs(path, mode=0777):
"""Make a directory at the specified path, creating intermediate
directories if necessary. No error if 'path' is already a directory.
On error, a dialog which allows the user to open the filer to fix
things and then retry will be opened.
Returns successfully if all directories get created (or already exist),
Raises an OSError if there is a problem, in which case the application
should not open a dialog box to inform the user, since one will already
have been displayed.
"""
# Get rid of any ..'s in the path
path = os.path.normpath(path)
_makedirs_recursive(path, mode)
Ticker_0.4.5pre17/rox/i18n.py 0100644 0000766 0000000 00000006310 10024415154 014327 0 ustar rene root """If you want your program to be translated into multiple languages you need
to do the following:
- Pass all strings that should be translated through the '_' function, eg:
print _('Hello World!')
- Create a Messages subdirectory in your application.
- Run 'pygettext *.py' to extract all the marked strings.
- Copy messages.pot as Messages/.po and edit (see ROX-Lib2's README).
- Use msgfmt to convert the .po files to .gmo files.
- In your application, use the rox.i18n.translation() function to set the _ function:
__builtins__._ = rox.i18n.translation(os.path.join(rox.app_dir, 'Messages'))
(for libraries, just do '_ ='; don't mess up the builtins)
Note that the marked strings must be fixed. If you're using formats, mark up the
format, eg:
print _('You have %d lives remaining') % lives
You might like to look at the scripts in ROX-Lib2's Messages directory for
more help.
"""
import os
def _expand_lang(locale):
from locale import normalize
locale = normalize(locale)
COMPONENT_CODESET = 1 << 0
COMPONENT_TERRITORY = 1 << 1
COMPONENT_MODIFIER = 1 << 2
# split up the locale into its base components
mask = 0
pos = locale.find('@')
if pos >= 0:
modifier = locale[pos:]
locale = locale[:pos]
mask |= COMPONENT_MODIFIER
else:
modifier = ''
pos = locale.find('.')
if pos >= 0:
codeset = locale[pos:]
locale = locale[:pos]
mask |= COMPONENT_CODESET
else:
codeset = ''
pos = locale.find('_')
if pos >= 0:
territory = locale[pos:]
locale = locale[:pos]
mask |= COMPONENT_TERRITORY
else:
territory = ''
language = locale
ret = []
for i in range(mask+1):
if not (i & ~mask): # if all components for this combo exist ...
val = language
if i & COMPONENT_TERRITORY: val += territory
if i & COMPONENT_CODESET: val += codeset
if i & COMPONENT_MODIFIER: val += modifier
ret.append(val)
ret.reverse()
return ret
def expand_languages(languages = None):
# Get some reasonable defaults for arguments that were not supplied
if languages is None:
languages = []
for envar in ('LANGUAGE', 'LC_ALL', 'LC_MESSAGES', 'LANG'):
val = os.environ.get(envar)
if val:
languages = val.split(':')
break
if 'C' not in languages:
languages.append('C')
# now normalize and expand the languages
nelangs = []
for lang in languages:
for nelang in _expand_lang(lang):
if nelang not in nelangs:
nelangs.append(nelang)
return nelangs
# Locate a .mo file using the ROX strategy
def find(messages_dir, languages = None):
"""Look in messages_dir for a .gmo file for the user's preferred language
(or override this with the 'languages' argument). Returns the filename, or
None if there was no translation."""
# select a language
for lang in expand_languages(languages):
if lang == 'C':
break
mofile = os.path.join(messages_dir, '%s.gmo' % lang)
if os.path.exists(mofile):
return mofile
return None
def translation(messages_dir, languages = None):
"""Load the translation for the user's language and return a function
which translates a string into its unicode equivalent."""
mofile = find(messages_dir, languages)
if not mofile:
return lambda x: x
import gettext
return gettext.GNUTranslations(file(mofile)).ugettext
langs = expand_languages()
Ticker_0.4.5pre17/rox/icon_theme.py 0100644 0000766 0000000 00000004716 10024415154 015672 0 ustar rene root """This is an internal module. Do not use it. GTK 2.4 will contain functions
that replace those defined here."""
import os
import basedir
import rox
theme_dirs = [os.path.join(os.environ.get('HOME', '/'), '.icons')] + \
list(basedir.load_data_paths('icons'))
class Index:
def __init__(self, dir):
self.dir = dir
sections = file(os.path.join(dir, "index.theme")).read().split('\n[')
self.sections = {}
for s in sections:
lines = s.split('\n')
sname = lines[0].strip('[] \t')
section = self.sections[sname] = {}
for line in lines[1:]:
if not line.strip(): continue
if line.startswith('#'): continue
key, value = map(str.strip, line.split('=', 1))
section[key] = value
self.subdirs = [SubDir(self, d) for
d in self.get('Icon Theme', 'Directories').split(';')]
def get(self, section, key):
"None if not found"
return self.sections.get(section, {}).get(key, None)
class SubDir:
def __init__(self, index, subdir):
type = index.get(subdir, 'Type')
self.name = subdir
self.size = int(index.get(subdir, 'Size'))
if type == "Fixed":
self.min_size = self.max_size = self.size
elif type == "Threshold":
threshold = int(index.get(subdir, 'Threshold'))
self.min_size = self.size - threshold
self.max_size = self.size + threshold
elif type == "Scaled":
self.min_size = int(index.get(subdir, 'MinSize'))
self.max_size = int(index.get(subdir, 'MaxSize'))
else:
self.min_size = self.max_size = 100000
class IconTheme:
def __init__(self, name):
self.name = name
self.indexes = []
for dir in theme_dirs:
theme_dir = os.path.join(dir, name)
index_file = os.path.join(theme_dir, 'index.theme')
if os.path.exists(os.path.join(index_file)):
try:
self.indexes.append(Index(theme_dir))
except:
rox.report_exception()
def lookup_icon(self, iconname, size):
icon = self._lookup_this_theme(iconname, size)
if icon: return icon
# XXX: inherits
def _lookup_this_theme(self, iconname, size):
dirs = []
for i in self.indexes:
for d in i.subdirs:
if size < d.min_size:
diff = d.min_size - size
elif size > d.max_size:
diff = size - d.max_size
else:
diff = 0
dirs.append((diff, os.path.join(i.dir, d.name)))
# Sort by closeness of size
dirs.sort()
for _, subdir in dirs:
for extension in ("png", "svg"):
filename = os.path.join(subdir,
iconname + '.' + extension)
if os.path.exists(filename):
return filename
rox_theme = IconTheme('ROX')
Ticker_0.4.5pre17/rox/loading.py 0100644 0000766 0000000 00000011563 10024415154 015173 0 ustar rene root """ROX applications should provide good drag-and-drop support. Use this module
to allow drops onto widgets in your application."""
import rox
from rox import g, alert, get_local_path, _
gdk = g.gdk
TARGET_URILIST = 0
TARGET_RAW = 1
def extract_uris(data):
"""Convert a text/uri-list to a python list of (still escaped) URIs"""
lines = data.split('\r\n')
out = []
for l in lines:
if l == chr(0):
continue # (gmc adds a '\0' line)
if l and l[0] != '#':
out.append(l)
return out
def provides(context, type): return type in map(str, context.targets)
class RemoteFiles(Exception):
"Internal use"
def __init__(self):
Exception.__init__(self, _('Cannot load files from a remote machine '
'(multiple files, or target application/octet-stream not provided)'))
class XDSLoader:
"""A mix-in class for widgets that can have files/data dropped on
them. If object is also a GtkWidget, xds_proxy_for(self) is called
automatically."""
def __init__(self, types):
"""Call this after initialising the widget.
Types is a list of MIME-types, or None to only accept files."""
targets = [('text/uri-list', 0, TARGET_URILIST)]
if types:
for type in types + ['application/octet-stream']:
targets.append((type, 0, TARGET_RAW))
self.targets = targets
if isinstance(self, g.Widget):
self.xds_proxy_for(self)
def xds_proxy_for(self, widget):
"Handle drops on this widget as if they were to 'self'."
# (Konqueror requires ACTION_MOVE)
widget.drag_dest_set(g.DEST_DEFAULT_MOTION | g.DEST_DEFAULT_HIGHLIGHT,
self.targets,
gdk.ACTION_COPY | gdk.ACTION_MOVE | gdk.ACTION_PRIVATE)
widget.connect('drag-data-received', self.xds_data_received)
widget.connect('drag-drop', self.xds_drag_drop)
def xds_drag_drop(self, widget, context, data, info, time):
"""Called when something is dropped on us. Decide which of the
offered targets to request and ask for it. xds_data_received will
be called when it finally arrives."""
target = widget.drag_dest_find_target(context, self.targets)
context.rox_leafname = None
if target is None:
# Error?
context.drop_finish(False, time)
else:
if provides(context, 'XdndDirectSave0'):
import saving
context.rox_leafname = saving._read_xds_property(context, False)
widget.drag_get_data(context, target, time)
return True
def xds_data_received(self, widget, context, x, y, selection, info, time):
"Called when we get some data. Internal."
if selection.data is None:
# Timeout?
context.drop_finish(False, time)
return
if info == TARGET_RAW:
try:
self.xds_load_from_selection(selection, context.rox_leafname)
except:
context.drop_finish(False, time)
raise
context.drop_finish(True, time)
return 1
if info != TARGET_URILIST:
return 0
uris = extract_uris(selection.data)
if not uris:
alert("Nothing to load!")
context.drop_finish(False, time)
return 1
try:
try:
self.xds_load_uris(uris)
except RemoteFiles:
if len(uris) != 1 or not provides(context, 'application/octet-stream'):
raise
widget.drag_get_data(context, 'application/octet-stream', time)
return 1 # Don't do drag_finish
except:
context.drop_finish(False, time)
rox.report_exception()
else:
context.drop_finish(True, time)
return 1
def xds_load_uris(self, uris):
"""Try to load each URI in the list. Override this if you can handle URIs
directly. The default method passes each local path to xds_load_from_file()
and displays an error for anything else.
The uris are escaped, so a space will appear as '%20'"""
paths = []
for uri in uris:
path = get_local_path(uri)
if path:
paths.append(path)
if len(paths) < len(uris):
raise RemoteFiles
for path in paths:
self.xds_load_from_file(path)
def xds_load_from_file(self, path):
"""Try to load this local file. Override this if you have a better way
to load files. The default method opens the file and calls xds_load_from_stream()."""
try:
self.xds_load_from_stream(path, None, open(path, 'rb'))
except:
rox.report_exception()
def xds_load_from_selection(self, selection, leafname = None):
"""Try to load this selection (data from another application). The default
puts the data in a cStringIO and calls xds_load_from_stream()."""
if selection.data is None:
g.gdk.beep() # Load aborted
return
from cStringIO import StringIO
type = str(selection.type)
self.xds_load_from_stream(leafname, type, StringIO(selection.data))
def xds_load_from_stream(self, name, type, stream):
"""Called when we get any data sent via drag-and-drop in any way (local
file or remote application transfer). You should override this and do
something with the data. 'name' may be None (if the data is unnamed),
a leafname, or a full path or URI. 'type' is the MIME type, or None if
unknown."""
alert('Got some data, but missing code to handle it!\n\n(name="%s";type="%s")'
% (name, type))
Ticker_0.4.5pre17/rox/mime.py 0100644 0000766 0000000 00000017361 10024415154 014507 0 ustar rene root """This module provides access to the shared MIME database.
types is a dictionary of all known MIME types, indexed by the type name, e.g.
types['application/x-python']
Applications can install information about MIME types by storing an
XML file as /packages/.xml and running the
update-mime-database command, which is provided by the freedesktop.org
shared mime database package.
See http://www.freedesktop.org/standards/shared-mime-info-spec/ for
information about the format of these files."""
import os
import stat
import fnmatch
import rox
import rox.choices
from rox import i18n, _, basedir
from xml.dom import Node, minidom, XML_NAMESPACE
FREE_NS = 'http://www.freedesktop.org/standards/shared-mime-info'
types = {} # Maps MIME names to type objects
# Icon sizes when requesting MIME type icon
ICON_SIZE_HUGE=96
ICON_SIZE_LARGE=52
ICON_SIZE_SMALL=18
ICON_SIZE_UNSCALED=None
def _get_node_data(node):
"""Get text of XML node"""
return ''.join([n.nodeValue for n in node.childNodes]).strip()
def lookup(media, subtype = None):
"Get the MIMEtype object for this type, creating a new one if needed."
if subtype is None and '/' in media:
media, subtype = media.split('/', 1)
if (media, subtype) not in types:
types[(media, subtype)] = MIMEtype(media, subtype)
return types[(media, subtype)]
class MIMEtype:
"""Type holding data about a MIME type"""
def __init__(self, media, subtype):
"Don't use this constructor directly; use mime.lookup() instead."
assert media and '/' not in media
assert subtype and '/' not in subtype
assert (media, subtype) not in types
self.media = media
self.subtype = subtype
self._comment = None
def _load(self):
"Loads comment for current language. Use get_comment() instead."
resource = os.path.join('mime', self.media, self.subtype + '.xml')
for path in basedir.load_data_paths(resource):
doc = minidom.parse(path)
if doc is None:
continue
for comment in doc.documentElement.getElementsByTagNameNS(FREE_NS, 'comment'):
lang = comment.getAttributeNS(XML_NAMESPACE, 'lang') or 'en'
goodness = 1 + (lang in i18n.langs)
if goodness > self._comment[0]:
self._comment = (goodness, _get_node_data(comment))
if goodness == 2: return
def get_comment(self):
"""Returns comment for current language, loading it if needed."""
# Should we ever reload?
if self._comment is None:
self._comment = (0, str(self))
self._load()
return self._comment[1]
def __str__(self):
return self.media + '/' + self.subtype
def __repr__(self):
return '[%s: %s]' % (self, self._comment or '(comment not loaded)')
def get_icon(self, size=None):
"""Return a GdkPixbuf with the icon for this type. If size
is None then the image is returned at its natural size,
otherwise the image is scaled to that width with the height
at the correct aspect ratio. The constants
ICON_SIZE_{HUGE,LARGE,SMALL} match the sizes used by the
filer."""
# I suppose it would make more sense to move the code
# from saving to here...
import saving
base=saving.image_for_type(self.media + '/' + self.subtype)
if not base or not size:
return base
h=int(base.get_width()*float(size)/base.get_height())
return base.scale_simple(size, h, rox.g.gdk.INTERP_BILINEAR)
# Some well-known types
text = lookup('text', 'plain')
inode_block = lookup('inode', 'blockdevice')
inode_char = lookup('inode', 'chardevice')
inode_dir = lookup('inode', 'directory')
inode_fifo = lookup('inode', 'fifo')
inode_socket = lookup('inode', 'socket')
inode_symlink = lookup('inode', 'symlink')
inode_door = lookup('inode', 'door')
app_exe = lookup('application', 'executable')
_cache_uptodate = False
def _cache_database():
global exts, globs, literals, _cache_database
_cache_uptodate = True
exts = {} # Maps extensions to types
globs = [] # List of (glob, type) pairs
literals = {} # Maps liternal names to types
def _import_glob_file(path):
"""Loads name matching information from a MIME directory."""
for line in file(path):
if line.startswith('#'): continue
line = line[:-1]
type, pattern = line.split(':', 1)
mtype = lookup(type)
if pattern.startswith('*.'):
rest = pattern[2:]
if not ('*' in rest or '[' in rest or '?' in rest):
exts[rest] = mtype
continue
if '*' in pattern or '[' in pattern or '?' in pattern:
globs.append((pattern, mtype))
else:
literals[pattern] = mtype
for path in basedir.load_data_paths(os.path.join('mime', 'globs')):
_import_glob_file(path)
# Sort globs by length
globs.sort(lambda a, b: cmp(len(b[0]), len(a[0])))
def get_type_by_name(path):
"""Returns type of file by its name, or None if not known"""
if not _cache_uptodate:
_cache_database()
leaf = os.path.basename(path)
if leaf in literals:
return literals[leaf]
lleaf = leaf.lower()
if lleaf in literals:
return literals[lleaf]
ext = leaf
while 1:
p = ext.find('.')
if p < 0: break
ext = ext[p + 1:]
if ext in exts:
return exts[ext]
ext = lleaf
while 1:
p = ext.find('.')
if p < 0: break
ext = ext[p+1:]
if ext in exts:
return exts[ext]
for (glob, type) in globs:
if fnmatch.fnmatch(leaf, glob):
return type
if fnmatch.fnmatch(lleaf, glob):
return type
return None
def get_type(path, follow=1, name_pri=100):
"""Returns type of file indicated by path.
path - pathname to check (need not exist)
follow - when reading file, follow symbolic links
name_pri - Priority to do name matches. 100=override magic"""
if not _cache_uptodate:
_cache_database()
# name_pri is not implemented
try:
if follow:
st = os.stat(path)
else:
st = os.lstat(path)
except:
t = get_type_by_name(path)
return t or text
if stat.S_ISREG(st.st_mode):
t = get_type_by_name(path)
if t is None:
if stat.S_IMODE(st.st_mode) & 0111:
return app_exe
else:
return text
return t
elif stat.S_ISDIR(st.st_mode): return inode_dir
elif stat.S_ISCHR(st.st_mode): return inode_char
elif stat.S_ISBLK(st.st_mode): return inode_block
elif stat.S_ISFIFO(st.st_mode): return inode_fifo
elif stat.S_ISLNK(st.st_mode): return inode_symlink
elif stat.S_ISSOCK(st.st_mode): return inode_socket
return inode_door
def install_mime_info(application, package_file = None):
"""Copy 'package_file' as ~/.local/share/mime/packages/.xml.
If package_file is None, install /.xml.
If already installed, does nothing. May overwrite an existing
file with the same name (if the contents are different)"""
application += '.xml'
if not package_file:
package_file = os.path.join(rox.app_dir, application)
new_data = file(package_file).read()
# See if the file is already installed
package_dir = os.path.join('mime', 'packages')
resource = os.path.join(package_dir, application)
for x in basedir.load_data_paths(resource):
try:
old_data = file(x).read()
except:
continue
if old_data == new_data:
return # Already installed
_cache_uptodate = False
# Not already installed; add a new copy
try:
# Create the directory structure...
new_file = os.path.join(basedir.save_data_path(package_dir), application)
# Write the file...
file(new_file, 'w').write(new_data)
# Update the database...
if os.spawnlp(os.P_WAIT, 'update-mime-database', 'update-mime-database', basedir.save_data_path('mime')):
os.unlink(new_file)
raise Exception(_("The 'update-mime-database' command returned an error code!\n" \
"Make sure you have the freedesktop.org shared MIME package:\n" \
"http://www.freedesktop.org/standards/shared-mime-info.html"))
except:
rox.report_exception()
def _test(name):
"""Print results for name. Test routine"""
t=get_type(name)
print name, t, t.get_comment()
if __name__=='__main__':
import sys
if len(sys.argv)<2:
_test('file.txt')
else:
for f in sys.argv[1:]:
_test(f)
print globs
Ticker_0.4.5pre17/rox/mime_handler.py 0100644 0000766 0000000 00000020431 10024415154 016174 0 ustar rene root """This module allows applications to set themselves as the default handler for
a particular MIME type. This is generally not a good thing to do, because it
annoys users if programs fight over the defaults."""
import os
import rox
import rox.choices
from rox import _, mime
_TNAME = 0
_COMMENT = 1
_CURRENT = 2
_INSTALL = 3
_ICON = 4
class InstallList(rox.Dialog):
"""Dialog to select installation of MIME type handlers"""
def __init__(self, application, itype, dir, types, info=None, check=True):
"""Create the install list dialog.
application - path to application to install
itype - string describing the type of action to install
dir - directory in Choices to store links in
types - list of MIME types
info - optional message to display below list
check - if true (the default), check for existing entries"""
rox.Dialog.__init__(self, title='Install %s' % itype,
buttons=(rox.g.STOCK_CANCEL, rox.g.RESPONSE_CLOSE,
rox.g.STOCK_OK, rox.g.RESPONSE_ACCEPT))
self.itype=itype
self.dir=dir
self.types=types
self.app=application
self.aname=os.path.basename(application)
self.check=check
vbox=self.vbox
swin = rox.g.ScrolledWindow()
swin.set_size_request(-1, 160)
swin.set_border_width(4)
swin.set_policy(rox.g.POLICY_NEVER, rox.g.POLICY_ALWAYS)
swin.set_shadow_type(rox.g.SHADOW_IN)
vbox.pack_start(swin, True, True, 0)
self.model = rox.g.ListStore(str, str, str, int, rox.g.gdk.Pixbuf)
view = rox.g.TreeView(self.model)
self.view = view
swin.add(view)
view.set_search_column(1)
cell = rox.g.CellRendererPixbuf()
column = rox.g.TreeViewColumn('', cell, pixbuf = _ICON)
view.append_column(column)
cell = rox.g.CellRendererText()
column = rox.g.TreeViewColumn('Type', cell, text = _TNAME)
view.append_column(column)
column.set_sort_column_id(_TNAME)
cell = rox.g.CellRendererText()
column = rox.g.TreeViewColumn('Name', cell, text = _COMMENT)
view.append_column(column)
column.set_sort_column_id(_COMMENT)
if check:
cell = rox.g.CellRendererText()
column = rox.g.TreeViewColumn('Current', cell, text = _CURRENT)
view.append_column(column)
column.set_sort_column_id(_CURRENT)
cell = rox.g.CellRendererToggle()
cell.set_property('activatable', True)
cell.connect('toggled', self.toggled, self.model)
column = rox.g.TreeViewColumn('Install?', cell, active = _INSTALL)
view.append_column(column)
column.set_sort_column_id(_INSTALL)
view.get_selection().set_mode(rox.g.SELECTION_NONE)
if info:
hbox=rox.g.HBox(spacing=4)
img=rox.g.image_new_from_stock(rox.g.STOCK_DIALOG_INFO,
rox.g.ICON_SIZE_DIALOG)
hbox.pack_start(img)
lbl=rox.g.Label(info)
lbl.set_line_wrap(True)
hbox.pack_start(lbl)
vbox.pack_start(hbox)
vbox.show_all()
self.load_types()
def toggled(self, cell, path, model):
"""Handle the CellRedererToggle stuff"""
if type(path) == str:
# Does this vary by pygtk version?
iter=model.iter_nth_child(None, int(path))
else:
iter=model.get_iter(path)
model.set_value(iter, _INSTALL, not cell.get_active())
def load_types(self):
"""Load list of types into window"""
self.model.clear()
for tname in self.types:
type=rox.mime.lookup(tname)
if self.check:
old=rox.choices.load(self.dir, '%s_%s' %
(type.media, type.subtype))
if old and os.path.islink(old):
old=os.readlink(old)
oname=os.path.basename(old)
elif old:
oname='script'
else:
oname=''
if old==self.app:
dinstall=False
else:
dinstall=True
else:
dinstall=True
oname=''
icon=type.get_icon(rox.mime.ICON_SIZE_SMALL)
iter=self.model.append()
self.model.set(iter, _TNAME, tname, _COMMENT, type.get_comment(),
_INSTALL, dinstall)
if self.check:
self.model.set(iter, _CURRENT, oname)
if icon:
self.model.set(iter, _ICON, icon)
def get_active(self):
"""Return list of selected types"""
iter=self.model.get_iter_first()
active=[]
while iter:
if self.model.get_value(iter, _INSTALL):
active.append(self.model.get_value(iter, _TNAME))
iter=self.model.iter_next(iter)
return active
def _install_type_handler(types, dir, desc, application=None, overwrite=True,
info=None):
if len(types)<1:
return
if not application:
application=rox.app_dir
if application[0]!='/':
application=os.path.abspath(application)
win=InstallList(application, desc, dir, types, info)
if win.run()!=rox.g.RESPONSE_ACCEPT:
win.destroy()
return
types=win.get_active()
for tname in types:
type = mime.lookup(tname)
sname=rox.choices.save(dir,
'%s_%s' % (type.media, type.subtype))
os.symlink(application, sname+'.tmp')
os.rename(sname+'.tmp', sname)
win.destroy()
run_action_msg=_("""Run actions can be changed by selecting a file of the appropriate type in the Filer and selecting the menu option 'Set Run Action...'""")
def install_run_action(types, application=None, overwrite=True):
"""Install application as the run action for 1 or more types.
application should be the full path to the AppDir.
If application is None then it is the running program which will
be installed. If overwrite is False then existing run actions will
not be changed. The user is asked to confirm the setting for each
type."""
_install_type_handler(types, "MIME-types", _("run action"),
application, overwrite, run_action_msg)
def install_thumbnailer(types, application=None, overwrite=True):
"""Install application as the thumbnail handler for 1 or more types.
application should be the full path to the AppDir.
If application is None then it is the running program which will
be installed. If overwrite is False then existing thumbnailerss will
not be changed. The user is asked to confirm the setting for each
type."""
_install_type_handler(types, "MIME-thumb", _("thumbnail handler"),
application, overwrite, _("""Thumbnail handlers provide support for creating thumbnail images of types of file. The filer can generate thumbnails for most types of image (JPEG, PNG, etc.) but relies on helper applications for the others."""))
def install_send_to_types(types, application=None):
"""Install application in the SendTo menu for 1 or more types.
application should be the full path to the AppDir.
If application is None then it is the running program which will
be installed. The user is asked to confirm the setting for each
type."""
if len(types)<1:
return
if not application:
application=rox.app_dir
if application[0]!='/':
application=os.path.abspath(application)
win=InstallList(application, _('type handler'), 'SendTo', types,
_("""The application can handle files of these types. Click on OK to add it to the SendTo menu for the type of file, and also the customized File menu."""),
check=False)
if win.run()!=rox.g.RESPONSE_ACCEPT:
win.destroy()
return
types=win.get_active()
for tname in types:
type=lookup(tname)
sname=rox.choices.save('SendTo/.%s_%s' % (type.media,
type.subtype),
win.aname)
os.symlink(application, sname+'.tmp')
os.rename(sname+'.tmp', sname)
win.destroy()
def install_from_appinfo(appdir = rox.app_dir):
"""Read the AppInfo file from the AppDir and perform the installations
indicated. The elements to use are and , each containing
a number of elements.
appdir - Path to application (defaults to current app)
"""
import rox.AppInfo
app_info_path = os.path.join(appdir, 'AppInfo.xml')
ainfo = rox.AppInfo.AppInfo(app_info_path)
can_run = ainfo.getCanRun()
can_thumbnail = ainfo.getCanThumbnail()
if can_run or can_thumbnail:
install_run_action(can_run, appdir)
install_thumbnailer(can_thumbnail, appdir)
install_send_to_types(ainfo.getCanRun(), appdir)
else:
raise Exception('Internal error: No actions found in %s. '
'Check your namespaces!' % app_info_path)
Ticker_0.4.5pre17/rox/options.py 0100644 0000766 0000000 00000011612 10024415154 015244 0 ustar rene root """
To use the Options system:
1. Create an OptionGroup:
options = OptionGroup('MyProg', 'Options')
You can also use the handy rox.setup_app_options() in most applications.
2. Create the options:
colour = Option('colour', 'red', options)
size = Option('size', 3, options)
3. Register any callbacks (notification of options changing):
def my_callback():
if colour.has_changed:
print "The colour is now", colour.value
options.add_notify(my_callback)
4. Notify any changes from defaults:
options.notify()
See OptionsBox for editing options. Do not change the value of options
yourself.
"""
from __future__ import generators
import choices
import rox
class Option:
"""An Option stores a single value. Every option is part of exactly one OptionGroup.
The read-only attributes value and int_value can be used to get the current setting
for the Option. int_value will be -1 if the value is not a valid integer.
The has_changed attribute is used during notify() calls to indicate whether this
Option's value has changed since the last notify (or option creation).
You may set has_changed = 1 right after creating an option if you want to force
notification the first time even if the default is used.
"""
def __init__(self, name, value, group = None):
"""Create a new option with this name and default value.
Add to 'group', or to rox.app_options if no group is given.
The value cannot be used until the first notify() call to
the group."""
if not group:
assert rox.app_options
group = rox.app_options
self.name = name
self.has_changed = 0 # ... since last notify/default
self.default_value = str(value)
self.group = group
self.value = None
self.int_value = None
self.group._register(self)
def _set(self, value):
if self.value != value:
self.value = str(value)
self.has_changed = 1
try:
if self.value == 'True':
self.int_value = 1
elif self.value == 'False':
self.int_value = 0
else:
self.int_value = int(float(self.value))
except:
self.int_value = -1
def _to_xml(self, parent):
doc = parent.ownerDocument
node = doc.createElement('Option')
node.setAttribute('name', self.name)
node.appendChild(doc.createTextNode(self.value))
parent.appendChild(node)
def __str__(self):
return "