Ticker_0.4.5pre17.4.04/ 0040755 0000766 0000766 00000000000 10040217021 012735 5 ustar rene rene Ticker_0.4.5pre17.4.04/AppletRun 0120777 0000766 0000766 00000000000 10037765320 016315 2start.py ustar rene rene Ticker_0.4.5pre17.4.04/findrox.py 0100644 0000766 0000766 00000005660 10037765321 015005 0 ustar rene rene # 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 not os.getenv('ROXLIB_DISABLE_ZEROINSTALL') and 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('0refresh rox.sourceforge.net'):
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'))
import rox
if major == 1 and minor == 9 and micro < 10:
return # Can't check version
if not hasattr(rox, 'roxlib_version'):
break
if (major, minor, micro) <= rox.roxlib_version:
return # OK
report_error("This program needs ROX-Lib2 (version %d.%d.%d) " % \
(major, minor, micro) + "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.4.04/overview.py 0100644 0000766 0000766 00000071054 10037765321 015202 0 ustar rene rene #!/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
from RETicker import minsize
self.__i_act = tool.EventImage(self.__Options, g.STOCK_NO, lambda x,y: self.emit("switch_active", self.__feed), minsize, "inactive (click to change)")
self.pack_start(self.__i_act, g.FALSE, g.FALSE, 1)
self.__i_ref = tool.EventImage(self.__Options, g.STOCK_REFRESH, lambda x,y: self.emit("refresh_feed", self.__feed), minsize, "refresh this source")
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.Cons = tool.Connections()
self.connect("destroy", self.disconnect_all)
self.Cons.connect(self.__Options, "refresh_ov_colors", self.refresh_colors)
def disconnect_all(self, dummy=None): print "destroy statusline"; self.Cons.disconnect_all()
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.__feed:
self.Cons.disconnect(self.__Options.sources.get_by_ticker(self.__feed.ticker), "change_active")
self.__feed = feed
self.Cons.connect(self.__Options.sources.get_by_ticker(self.__feed.ticker), "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(g.STOCK_YES); self.__i_act.set_tip("active (click to change)")
else:
self.__i_act.set(g.STOCK_NO); self.__i_act.set_tip("inactive (click to change)")
else: text = "no messages to show"; self.__i_act = tool.EventImage(self.__Options, g.STOCK_MISSING_IMAGE)
self.__label.set_text(text)
def reset_active(self, dummy):
if self.__feed:
if self.__feed.get_active() == 1:
self.__i_act.set(g.STOCK_YES); self.__i_act.set_tip("active (click to change)")
else:
self.__i_act.set(g.STOCK_NO); self.__i_act.set_tip("inactive (click to change)")
else: self.__i_act = tool.EventImage(self.__Options, g.STOCK_MISSING_IMAGE)
#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(self.__Options, g.STOCK_GO_BACK, lambda x,y: self.emit("prev_feed"), g.ICON_SIZE_SMALL_TOOLBAR, "previous feed")
self.i_next = tool.EventImage(self.__Options, g.STOCK_GO_FORWARD, lambda x,y: self.emit("next_feed"), g.ICON_SIZE_SMALL_TOOLBAR, "next feed")
self.__i_icon = tool.EventImage(self.__Options, g.STOCK_MISSING_IMAGE, lambda x,y: self.emit("open_feed_page"))
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(self.__Options, g.STOCK_REFRESH, lambda x,y: self.emit("refresh_all"), g.ICON_SIZE_SMALL_TOOLBAR, "refresh news")
self.pack_start(self.i_refresh, g.FALSE, g.FALSE, 10)
self.i_options = tool.EventImage(self.__Options, g.STOCK_PREFERENCES, lambda x,y: self.emit("open_options"), g.ICON_SIZE_SMALL_TOOLBAR, "Preferences")
self.i_window = tool.EventImage(self.__Options, g.STOCK_INDEX, lambda x,y: self.emit("open_overview_window"), g.ICON_SIZE_SMALL_TOOLBAR, "Overview")
self.i_help = tool.EventImage(self.__Options, g.STOCK_HELP, lambda x,y: self.emit("help"), g.ICON_SIZE_SMALL_TOOLBAR, "Help")
self.__i_info = tool.EventImage(self.__Options, g.STOCK_DIALOG_INFO, lambda x,y: self.emit("info"))
self.i_quit = tool.EventImage(self.__Options, g.STOCK_QUIT, lambda x,y: self.emit("quit"), g.ICON_SIZE_SMALL_TOOLBAR, "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.Cons = tool.Connections()
self.connect("destroy", self.disconnect_all)
self.Cons.connect(self.__Options, "refresh_ov_colors", self.refresh_colors)
def disconnect_all(self, dummy=None): self.Cons.disconnect_all()
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_ticker())
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, Ticker):
if Ticker == None: self.__i_icon.set(g.STOCK_MISSING_IMAGE)
else: self.__i_icon.set(Ticker)
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, tooltips, feed, msg, count, overview = None):
self.__Options = Options
self.__tooltips = tooltips
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]"
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.__tooltips.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.Cons = tool.Connections()
self.connect("destroy", self.disconnect_all)
self.Cons.connect(self.source, "change_active", self.refresh_colors)
self.Cons.connect(self.source, "change_shownews", self.refresh_colors)
self.Cons.connect(self.source, "change_news_age_by_date", self.refresh_colors)
self.Cons.connect(self.source, "change_provides_date_info", self.refresh_colors)
self.Cons.connect(self.__Options, "refresh_ov_colors", self.refresh_colors)
self.Cons.connect(self.__Options, "refresh_aging_opts", self.refresh_colors)
if self.__overview: self.Cons.connect(self.__Options, "refresh_ov_msgs", self.refresh_msg_text)
def disconnect_all(self, dummy=None): self.Cons.disconnect_all()
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, tooltips, overview = None):
print "****** ov_feed created"
self.__Options = Options
self.__tooltips = tooltips
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.label1 = None
self.label2 = None
self.list_of_msgs = []
self.Cons = tool.Connections()
self.Cons.connect(self.__Options, "refresh_ov_colors", self.refresh_colors)
self.connect("destroy", self.disconnect_all)
#self.disconnect()
def disconnect_all(self, dummy=None):
print "feed disconnect all"
self.Cons.disconnect_all()
for msg in self.list_of_msgs: msg.disconnect_all(); del msg
self.list_of_msgs = []
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.__feed:
self.Cons.disconnect(self.__Options.sources.get_by_ticker(self.__feed.ticker), "change_active")
for msg in self.list_of_msgs: msg.disconnect_all()
self.list_of_msgs = []
if self.vbox: self.remove(self.vbox); del self.vbox; self.vbox = 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.Cons.connect(self.__Options.sources.get_by_ticker(self.__feed.ticker), "change_active", self.refresh_colors)
if len(self.__feed.msg) <> 0:
for i in self.__feed.msg:
msg = ov_message(self.__Options, self.__tooltips, self.__feed, i, count, self.__overview)
self.list_of_msgs.append(msg)
self.vbox.pack_start(msg, g.FALSE, g.FALSE, 0)
count += 1
import sys; import gc; gc.collect();
print "added " + str(count-1) + " messages" + \
" --> refrences to Options: " + str(sys.getrefcount(self.__Options))
self.label1 = None
self.label2 = None
else:
if self.label1: del self.label1
if self.label2: del self.label2
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 = {}
self.Cons = tool.Connections()
def disconnect_all(self, dummy=None): self.Cons.disconnect_all()
def destroy(self, dummy = None):
print "overview destroyed"
self.win = None
### This is needed to really remove all references to overview and stats, i dont know why
self.feed_wins = {}
self.disconnect_all()
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):
import sys; import gc; gc.collect();
print "recreate window overview --> refrences to Options: " + str(sys.getrefcount(self.__Options))
if self.win: self.win.present(); return
self.win = g.Window()
self.win.connect("destroy", self.destroy)
self.__tooltips = g.Tooltips()
self.__tooltips.enable()
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.Cons.connect(self.__Options, "refresh_ov_colors", self.refresh_colors)
self.Cons.connect(self.__Options, "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, self.__tooltips, 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.__tooltips = g.Tooltips()
self.__tooltips.enable()
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.__tooltips)
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.Cons = tool.Connections()
self.Cons.connect(self.__Options, "refresh_ov_colors", self.refresh_colors)
self.Cons.connect(self.__Options, "refresh_tt_a_size", self.refresh_size)
self.connect('configure-event',self.change_size)
self.connect("destroy", self.disconnect_all)
def disconnect_all(self, dummy=None): self.Cons.disconnect_all()
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):
import sys; import gc; gc.collect();
print "create_window ov_akfeed --> refrences to Options: " + str(sys.getrefcount(self.__Options))
#self.Cons.disconnect(self.__source, "source_killed")
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.Cons.connect(self.__source, "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.refresh()
self.__initialized = True
print "create_window ov_akfeed done --> refrences to Options: " + str(sys.getrefcount(self.__Options))
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 not(feed) or 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)
import sys; import gc; gc.collect();
print "refresh ov_akfeed --> refrences to Options: " + str(sys.getrefcount(self.__Options))
self.Cons.disconnect(self.__source, "source_killed")
if self.__feed:
self.__source = self.__Options.sources.get_by_ticker(self.__feed.get_ticker())
if not(self.__source): return
self.Cons.connect(self.__source, "source_killed", self.create_window)
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.4.04/Options.xml 0100644 0000766 0000766 00000020643 10040213043 015114 0 ustar rene rene
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 NewsProxy Settings (you have to activate it)Program 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.4.04/AppRun 0120777 0000766 0000766 00000000000 10037765321 015611 2start.py ustar rene rene Ticker_0.4.5pre17.4.04/AppIcon.xpm 0100644 0000766 0000766 00000014007 10037765321 015034 0 ustar rene rene /* 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.4.04/AppInfo.xml 0100644 0000766 0000766 00000000516 10037765321 015033 0 ustar rene rene
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.4.04/Options.py 0100644 0000766 0000766 00000140616 10040213365 014756 0 ustar rene rene #!/usr/bin/env python
#########################################################
# RETicker v. 0.4.5pre
# a programm to display xml-formatted rss/rdf-feeds in
# a one line display
#########################################################
# please read Help.txt for contact information
#########################################################
# This file contains the classes storing and showing #
# the actual news #
#########################################################
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, ButtonMixed, options
from rox.options import Option
import sys
from xml.dom import minidom
import xml.sax
import urllib
import gc
import os
import re
import gobject
import tool
import icon
"""--------------------------------------------------------------------------------------------"""
"""--------------------------- a class which hold sone source ---------------------------------"""
"""--------------------------------------------------------------------------------------------"""
class source_(gobject.GObject):
def __init__(self, Options):
gobject.GObject.__init__(self)
self.__Options = Options
self.active = None
self.ticker = None
self.icon = None
self.iconcache = None
self.iconset = None ## stores the icon as a IconSet with different states
self.shownews = None
self.news_age_by_date = None
self.provides_date_info = None
def copy(self, source_):
print "update sources"
if self.active <> source_.active: self.active = source_.active; self.emit("change_active")
refresh_icon = (self.icon <> source_.icon or self.iconcache <> source_.iconcache)
if self.icon <> source_.icon: self.icon = source_.icon; self.emit("change_icon")
if self.iconcache <> source_.iconcache: self.iconcache = source_.iconcache; self.emit("change_iconcache")
if refresh_icon:
print "update icon in " + self.ticker
if self.iconset: self.iconset.reinit(self.get_iconcache(), self.get_icon())
if self.shownews <> source_.shownews: self.shownews = source_.shownews; self.emit("change_shownews")
if self.news_age_by_date <> source_.news_age_by_date: self.news_age_by_date = source_.news_age_by_date; self.emit("change_news_age_by_date")
if self.provides_date_info <> source_.provides_date_info: self.provides_date_info = source_.provides_date_info; self.emit("change_provides_date_info")
"""
def set(self, active, ticker, icon, iconcache, shownews,\
news_by_age_date, provides_date_info):
self.active = active
self.ticker = ticker
self.icon = icon
self.iconcache = iconcache
self.shownews = shownews
self.news_age_by_date = news_age_by_date
self.provides_date_info = provides_date_info
"""
def get_active(self): return self.active
def get_ticker(self):
if self.ticker.find("://") == -1: return "http://" + self.ticker
else: return self.ticker
def get_icon(self):
icon = self.icon
if icon == "":
pos = self.ticker[8:].find("/")
if pos <> -1: pos = pos + 8
if pos <> -1: icon = self.ticker[:pos] + "/favicon.ico"
else: icon = self.ticker + "/favicon.ico"
else:
if icon.find("://") == -1: icon = "http://" + icon
return icon
def get_iconcache(self):
iconcache = self.iconcache
if iconcache == "":
iconcache = tool.tmp_name(self.__Options.icon_cache_dir.value, self.get_icon())
return iconcache
def get_iconset(self):
if not(self.iconset): self.iconset = icon.IconBuffer(self.get_iconcache(), self.get_icon())
return self.iconset
def get_shownews(self): return self.shownews
def get_news_age_by_date(self): return self.news_age_by_date
def get_provides_date_info(self): return self.provides_date_info
def set_provides_date_info(self, value):
self.provides_date_info = value
def _to_xml(self, parent):
def createNode(doc, name, data):
node = doc.createElement(name)
node.appendChild(doc.createTextNode(data))
return node
doc = parent.ownerDocument
parent.appendChild(createNode(doc, 'active', str(self.active)))
parent.appendChild(createNode(doc, 'ticker', self.ticker))
parent.appendChild(createNode(doc, 'icon', self.icon))
parent.appendChild(createNode(doc, 'iconcache', self.iconcache))
parent.appendChild(createNode(doc, 'shownews', str(self.shownews)))
parent.appendChild(createNode(doc, 'news_age_by_date',\
str(self.news_age_by_date)))
parent.appendChild(createNode(doc, 'provides_date_info',\
str(self.provides_date_info)))
return doc
def _from_xml(self, xml_source):
self.active = tool.getintdata(xml_source, "active")
self.ticker = tool.getdata(xml_source, "ticker")
self.icon = tool.getdata(xml_source, "icon")
self.iconcache = tool.getdata(xml_source, "iconcache")
self.shownews = tool.getintdata(xml_source, "shownews")
self.news_age_by_date = tool.getintdata(xml_source, "news_age_by_date")
self.provides_date_info = tool.getintdata(xml_source, "provides_date_info")
gobject.signal_new("source_killed", source_, gobject.SIGNAL_RUN_LAST,gobject.TYPE_NONE, (gobject.TYPE_PYOBJECT,))
gobject.signal_new("change_active", source_, gobject.SIGNAL_RUN_LAST,gobject.TYPE_NONE, ())
gobject.signal_new("change_ticker", source_, gobject.SIGNAL_RUN_LAST,gobject.TYPE_NONE, ())
gobject.signal_new("change_icon", source_, gobject.SIGNAL_RUN_LAST,gobject.TYPE_NONE, ())
gobject.signal_new("change_iconcache", source_, gobject.SIGNAL_RUN_LAST,gobject.TYPE_NONE, ())
gobject.signal_new("change_shownews", source_, gobject.SIGNAL_RUN_LAST,gobject.TYPE_NONE, ())
gobject.signal_new("change_news_age_by_date", source_, gobject.SIGNAL_RUN_LAST,gobject.TYPE_NONE, ())
gobject.signal_new("change_provides_date_info", source_, gobject.SIGNAL_RUN_LAST,gobject.TYPE_NONE, ())
class sources_(gobject.GObject):
def __init__(self, Options):
gobject.GObject.__init__(self)
self.__Options = Options
self.sources = []
self.reinit_wait_cont = tool.WaitContainer(0.5, self.reinit_from_xml_)
#self.__xml_string = None
#self.__waiting = None
#self.valid = True
def stat_sources(self, sources):
source_count = len(sources)
act_count = 0
for i in sources:
if i.get_active() == 1: act_count += 1
return str(source_count) + "[all]/" + str(act_count) + "[active]"
def stat(self): return self.stat_sources(self.sources)
def switch_feed_active(self, feed):
print feed.ticker
print feed.get_active()
source = self.get_by_ticker(feed.ticker)
if source.active == 1: source.active = 0
else: source.active = 1
print "switch feed active: " + feed.ticker + " set to " + str(feed.get_active())
self.get_by_ticker(feed.ticker).emit("change_active")
def get_by_ticker(self, ticker):
if ticker.find("://") == -1: ticker = "http://" + ticker
for source in self.sources:
#print "get_by_ticker " + source.ticker + " vs. " + ticker
if source.get_ticker() == ticker: return source
return None
def get_active_by_ticker(self, ticker):
if self.get_by_ticker(ticker): return self.get_by_ticker(ticker).get_active()
else: return None
def get_ticker_by_ticker(self, ticker):
if self.get_by_ticker(ticker): return self.get_by_ticker(ticker).get_ticker()
return None
def get_icon_by_ticker(self, ticker):
if self.get_by_ticker(ticker): return self.get_by_ticker(ticker).get_icon()
return None
def get_iconcache_by_ticker(self, ticker):
if self.get_by_ticker(ticker): return self.get_by_ticker(ticker).get_iconcache()
return None
def get_iconset_by_ticker(self, ticker):
if self.get_by_ticker(ticker): return self.get_by_ticker(ticker).get_iconset()
return None
def get_shownews_by_ticker(self, ticker):
if self.get_by_ticker(ticker): return self.get_by_ticker(ticker).get_shownews()
return None
def get_news_age_by_date_by_ticker(self, ticker):
if self.get_by_ticker(ticker): return self.get_by_ticker(ticker).get_news_age_by_date()
return None
def get_provides_date_info_by_ticker(self, ticker):
if self.get_by_ticker(ticker): return self.get_by_ticker(ticker).get_provides_date_info()
return None
def export_xml(self):
from xml.dom.minidom import Document
doc = Document()
doc_root = doc.createElement('Options')
doc.appendChild(doc_root)
for i in self.sources:
root = doc.createElement('source')
doc_root.appendChild(root)
i._to_xml(root)
return doc.toxml()
def init_from_xml(self, xml_string):
#print "sources (" + self.stat() + ")"
for source in self.sources:
source.emit("source_killed", source.get_ticker())
self.sources = []
#print "sources (" + self.stat() + ")"
try:
doc=minidom.parseString(xml_string)
except xml.sax.SAXParseException:
print "something stupid happend: your internal config is corrupt"
return
xml_sources = doc.getElementsByTagName("source")
for xml_source in xml_sources:
#print "neue source"
new_source = source_(self.__Options)
new_source._from_xml(xml_source)
self.sources.append(new_source)
def reinit_from_xml(self, xml_string):
self.reinit_wait_cont.set_value(xml_string)
def reinit_from_xml_(self, xml_string):
tmp_sources = []
try:
doc=minidom.parseString(xml_string)
except xml.sax.SAXParseException:
print "something stupid happend: your internal config is corrupt"
return
xml_sources = doc.getElementsByTagName("source")
for xml_source in xml_sources:
new_source = source_(self.__Options)
new_source._from_xml(xml_source)
tmp_sources.append(new_source)
#print "old sources (" + self.stat() + ")"
#print "new sources (" + self.stat_sources(tmp_sources) + ")"
### now tmp_sources holds the new configuration, its time to copy this into old one
i = 0
#yield None
while (i < len(self.sources)):
#print i
found = False
for tmp_source in tmp_sources:
#print "check " + self.sources[i].get_ticker() + " against " + tmp_source.get_ticker()
if tmp_source.get_ticker() == self.sources[i].get_ticker():
found = True
self.sources[i].copy(tmp_source);
#print "**** " + tmp_source.get_ticker() + " found, going on"
break
if not(found):
print "kill feed cause not found in Sources: " + self.sources[i].get_ticker()
self.sources[i].emit("source_killed", self.sources[i].get_ticker())
self.sources.pop(i)
else: i += 1
### and now its time to add new sources
#yield None
for source in tmp_sources:
if self.get_by_ticker(source.get_ticker()): continue
print source.get_ticker() + " not found, added"
self.sources.append(source)
self.emit("source_added", self.sources[i])
#print "act sources (" + self.stat() + ")"
gobject.signal_new("source_added", sources_, gobject.SIGNAL_RUN_LAST,gobject.TYPE_NONE, (gobject.TYPE_PYOBJECT,))
class Options_(gobject.GObject):
def __init__(self, V, Version, user_conf, verbose):
gobject.GObject.__init__(self)
## store some init-variables for global access
self.Version = Version
self.v = verbose
if self.v: print "Verbose mode activated"
pos = V.find(".") + 1
pos += V[pos:].find(".")
self.program = "RETicker_" + V[:pos] + user_conf
rox.setup_app_options(self.program)
#global ticker_menu
#import ticker_menu
#ticker_menu.set_save(program)
# How to decide if 'news' are old
self.news_age = Option('news_age', '60') # in Min
self.news_showcount = Option('news_showcount', '0')
# Layout-Options for Ticker
self.text_color = Option('text_color', '#880000')
self.back_color = Option('back_color', '#DEDBD6')
self.transparent = Option('transparent', '0')
self.back_datei = Option('back_datei', '')
self.hor_size=Option('hor_size', '-1')
self.ver_size=Option('ver_size', '20')
# Layout-Optionen (Overview-Window)
self.show_age = Option('show_age', '1')
self.show_stat = Option('show_stat', '1')
self.ov_bg = Option('ov_bg', '#FFFFFF')
self.ov_bg_inactive = Option('ov_bg_inactive', '#888888')
self.ov_bg_stat = Option('ov_bg_stat', '#D70707')
self.ov_color_new_msg = Option('color_new_msg', '#880000')
self.ov_color_old_msg = Option('color_old_msg', '#000000')
self.ov_color_not_shown_msg = Option('color_not_shown_msg', '#666666')
self.ov_hor_size=Option('ov_hor_size', '400')
self.ov_ver_size=Option('ov_ver_size', '600')
# ActiveTooltip-Design
self.tt_a=Option('tt_a', '1')
self.tt_a_inactive_fd=Option('tt_a_inactive_fd', '0')
self.tt_a_fd_wo_news=Option('tt_a_fd_wo_news', '1')
self.tt_a_as_menu=Option('tt_a_as_menu', '0')
self.tt_a_bg = Option('tt_a_bg', '#eee2b4')
self.tt_a_bg_inactive = Option('tt_a_bg_inactive', '#cec294')
self.tt_a_bg_stat = Option('tt_a_bg_stat', '#eee2b4')
self.tt_a_color_new_msg = Option('tt_a_color_new_msg', '#880000')
self.tt_a_color_old_msg = Option('tt_a_color_old_msg', '#000000')
self.tt_a_color_not_shown_msg = Option('tt_a_color_not_shown_msg', '#666666')
self.tt_a_hor_size=Option('tt_a_hor_size', '200')
self.tt_a_ver_size=Option('tt_a_ver_size', '200')
self.tt_a_hor_scrollbar=Option('tt_a_hor_scrollbar', '0')
self.tt_a_ver_scrollbar=Option('tt_a_ver_scrollbar', '1')
# Tooltip-Design Label
self.tt_l=Option('tt_l', '1') # zeigt Label-ToolTip mit Description an
self.tt_l_frame=Option('tt_l_frame', '1')
self.tt_l_title=Option('tt_l_title', '1')
self.tt_l_link=Option('tt_l_link', '1')
self.tt_l_ver=Option('tt_l_ver', '1')
# Tooltip-Design Image
self.tt_i=Option('tt_i', '0') # zeigt Image-ToolTip mit Description an
self.tt_i_frame=Option('tt_i_frame', '1')
self.tt_i_title=Option('tt_i_title', '1')
self.tt_i_desc=Option('tt_i_desc', '1')
self.tt_i_src=Option('tt_i_src', '1')
self.tt_i_link=Option('tt_i_link', '1')
self.tt_i_ver=Option('tt_i_ver', '1')
# Fetch-Optionen
self.update_time = Option('update_time', '15') # in sec.
self.refresh_time= Option('refresh_time', '30') # in Min
self.check_verbose=Option('check_verbose', '1')
self.check_image=Option('check_image', '0')
# diverse Pfade und Browser
global use_proxy; use_proxy=Option('use_proxy', '0')
global proxy; proxy=Option('proxy', '')
self.browser= Option('browser', 'opera')
self.br_options= Option('br_options', '-newpage')
try:
path = os.environ['CHOICESPATH']
paths = path.split(':')
except KeyError:
paths = [ os.environ['HOME'] + '/Choices',
'/usr/local/share/Choices',
'/usr/share/Choices' ]
cache = paths[0] + '/' + self.program
if not(os.path.exists(cache)): os.mkdir(cache)
xml_cache_ = cache + "/xml_cache"
if not(os.path.exists(xml_cache_)): os.mkdir(xml_cache_)
xml_cache_ += "/News.xml"
self.xml_cache=Option('xml_cache', xml_cache_)
icon_cache = cache + "/icon_cache"
if not(os.path.exists(icon_cache)): os.mkdir(icon_cache)
self.icon_cache_dir=Option('icon_cache_dir', icon_cache)
# This stores iconsets of modified stock icons for faster accessibility
self.stock_iconsets = icon.Stock_IconSets()
# Sources - there are two versions, see section further down, variable sources
self.sources = sources_(self)
self.sources.init_from_xml("1" \
+ "http://slashdot.org/slashdot.rdf" \
+ "http://slashdot.org/favicon.ico" \
+ "5")
self.__sources = Option('sources', self.sources.export_xml())
rox.app_options.notify()
rox.app_options.add_notify(self.options_changed)
# store sources Information after getting Option Value
print "init sources (" + self.sources.stat() + ")"
self.sources.init_from_xml(self.__sources.value)
print "read saved sources (" + self.sources.stat() + ")"
self.OptionsBox = None
def sources_date_info_update(self, dummy, feed):
self.sources.date_info_update(feed)
self.__sources.value = self.sources.export_xml()
def sources_switch_feed_active(self, dummy, feed):
#print "switch feed active"
self.sources.switch_feed_active(feed)
self.__sources.value = self.sources.export_xml()
def mainwin_size_changed(self, w, h):
self.hor_size.value = str(w); self.hor_size.int_value = w
self.ver_size.value = str(h); self.ver_size.int_value = h
def act_tick_size_changed(self, dummy, w, h):
self.tt_a_hor_size.value = str(w); self.tt_a_hor_size.int_value = w
self.tt_a_ver_size.value = str(h); self.tt_a_ver_size.int_value = h
def overview_size_changed(self, dummy, w, h):
self.ov_hor_size.value = str(w); self.ov_hor_size.int_value = w
self.ov_ver_size.value = str(h); self.ov_ver_size.int_value = h
### this is called if any Option has changed **** HAS to BE adapted
### chaneg this
def options_changed(self):
if self.__sources.has_changed:
#print "sources have changed"
### wait some seconds to be sure that
self.sources.reinit_from_xml(self.__sources.value)
if self.update_time.has_changed: self.emit("refresh_update_time")
if self.refresh_time.has_changed: self.emit("refresh_refresh_time")
if self.hor_size.has_changed or self.ver_size.has_changed: self.emit("refresh_win_size")
if self.ov_hor_size.has_changed or self.ov_ver_size.has_changed: self.emit("refresh_ov_size")
if self.tt_a_hor_size.has_changed or self.tt_a_ver_size.has_changed: self.emit("refresh_tt_a_size")
if self.text_color.has_changed or self.back_color.has_changed: self.emit("refresh_label_color")
if self.transparent.has_changed or self.back_datei.has_changed: self.emit("refresh_transparency")
if self.back_color.has_changed and self.transparent.int_value <> 1: self.emit("refresh_background")
if self.tt_a_bg.has_changed or self.tt_a_bg_inactive.has_changed \
or self.tt_a_bg_stat.has_changed or self.tt_a_color_new_msg.has_changed \
or self.tt_a_color_old_msg.has_changed or self.tt_a_color_not_shown_msg.has_changed:
self.emit("refresh_ov_colors")
if self.ov_bg.has_changed or self.ov_bg_inactive.has_changed \
or self.ov_bg_stat.has_changed or self.ov_color_new_msg.has_changed \
or self.ov_color_old_msg.has_changed or self.ov_color_not_shown_msg.has_changed:
self.emit("refresh_ov_colors")
if self.show_age.has_changed or self.show_stat.has_changed:
self.emit("refresh_ov_msgs")
if self.tt_a_hor_scrollbar.has_changed or self.tt_a_ver_scrollbar.has_changed:
self.emit("refresh_scrollbars")
if self.news_age.has_changed or self.news_showcount.has_changed:
self.emit("refresh_aging_opts")
def show_options(self, dummy): tasks.Task(self.edit_options())
def edit_options(self):
yield None
if self.OptionsBox: self.OptionsBox.present(); return
options_file = os.path.join(rox.app_dir, 'Options.xml')
self.OptionsBox = OptionsBox(self, rox.app_options, options_file)
def closed(widget): self.OptionsBox = None; Cons.disconnect_all()
Cons = tool.Connections(); Cons.connect(self.OptionsBox, 'destroy', closed)
self.OptionsBox.open()
gobject.signal_new("refresh_update_time", Options_, gobject.SIGNAL_RUN_LAST,gobject.TYPE_NONE, ())
gobject.signal_new("refresh_refresh_time", Options_, gobject.SIGNAL_RUN_LAST,gobject.TYPE_NONE, ())
gobject.signal_new("refresh_win_size", Options_, gobject.SIGNAL_RUN_LAST,gobject.TYPE_NONE, ())
gobject.signal_new("refresh_tt_a_size", Options_, gobject.SIGNAL_RUN_LAST,gobject.TYPE_NONE, ())
gobject.signal_new("refresh_ov_size", Options_, gobject.SIGNAL_RUN_LAST,gobject.TYPE_NONE, ())
gobject.signal_new("refresh_label_color", Options_, gobject.SIGNAL_RUN_LAST,gobject.TYPE_NONE, ())
gobject.signal_new("refresh_transparency", Options_, gobject.SIGNAL_RUN_LAST,gobject.TYPE_NONE, ())
gobject.signal_new("refresh_background", Options_, gobject.SIGNAL_RUN_LAST,gobject.TYPE_NONE, ())
gobject.signal_new("refresh_ov_colors", Options_, gobject.SIGNAL_RUN_LAST,gobject.TYPE_NONE, ())
gobject.signal_new("refresh_ov_msgs", Options_, gobject.SIGNAL_RUN_LAST,gobject.TYPE_NONE, ())
gobject.signal_new("refresh_scrollbars", Options_, gobject.SIGNAL_RUN_LAST,gobject.TYPE_NONE, ())
gobject.signal_new("refresh_aging_opts", Options_, gobject.SIGNAL_RUN_LAST,gobject.TYPE_NONE, ())
import rox.OptionsBox
from rox.OptionsBox import data
class OptionsBox(rox.OptionsBox.OptionsBox):
def __init__(self, Options, options_group, options_xml, translation = None):
self.__Options = Options
rox.OptionsBox.OptionsBox.__init__(self, options_group, options_xml, translation = None)
#self.connect("destroy", self.ende)
#def ende(self, dummy):
#print "destroy OptionsBox mod"
def build_image(self, node, image):
"""Text"""
image = g.Image()
Filename = rox.app_dir + "/" + data(node)
if os.path.exists(Filename):
image.set_from_file(Filename)
else:
image.set_from_stock(g.STOCK_MISSING_IMAGE,g.ICON_SIZE_SMALL_TOOLBAR)
return [image]
def build_toggle_atip(self, node, label, option):
"Tooltip"
toggle = g.CheckButton(label)
self.may_add_tip(toggle, node)
def get():
self.activetip.refresh(option, toggle.get_active())
return str(toggle.get_active())
def set():
toggle.set_active(option.int_value)
self.activetip.refresh(option, toggle.get_active())
self.handlers[option] = (get, set)
toggle.connect('toggled', lambda w: self.check_widget(option))
return [toggle]
def build_toggle_itip(self, node, label, option):
"Tooltip"
toggle = g.CheckButton(label)
self.may_add_tip(toggle, node)
def get():
self.imagetip.refresh(option, toggle.get_active())
return str(toggle.get_active())
def set():
toggle.set_active(option.int_value)
self.imagetip.refresh(option, toggle.get_active())
self.handlers[option] = (get, set)
toggle.connect('toggled', lambda w: self.check_widget(option))
return [toggle]
def build_toggle_ltip(self, node, label, option):
"Tooltip"
toggle = g.CheckButton(label)
self.may_add_tip(toggle, node)
def get():
self.labeltip.refresh(option, toggle.get_active())
return str(toggle.get_active())
def set():
toggle.set_active(option.int_value)
self.labeltip.refresh(option, toggle.get_active())
self.handlers[option] = (get, set)
toggle.connect('toggled', lambda w: self.check_widget(option))
return [toggle]
def build_labeltip(self, node, image):
"""Text"""
self.labeltip = LabelTip()
return [self.labeltip]
def build_imagetip(self, node, image):
"""Text"""
self.imagetip = ImageTip()
return [self.imagetip]
def build_activetip(self, node, image):
"""Text"""
self.activetip = ActiveTip()
return [self.activetip]
def build_tickerconf(self, node, label, option):
"""alle tags als xml"""
PrefTab = TickPrefs_Container(self.__Options)
#PrefTab = sources.Dialog
self.may_add_tip(PrefTab, node)
PrefTab.connect('changed_Conti', lambda t,w: self.check_widget(option))
def get():
return PrefTab.get_value()
def set():
tasks.Task(PrefTab.load_config(option.value))
self.handlers[option] = (get, set)
return [PrefTab]
def build_help(self, node, label):
"""gib ein Infofenster aus"""
HelpTab = Help_Book()
return [HelpTab]
def build_fileentry(self, node, label, option):
"Tooltip"
def open_file(widget, event):
def set_file(widget):
sel.hide()
entry.set_text(sel.get_filename())
def exit(widget):
sel.hide()
if event.button == 1:
sel = g.FileSelection()
sel.set_filename(entry.get_text())
sel.connect("destroy", exit)
sel.ok_button.connect("clicked", set_file)
sel.cancel_button.connect("clicked", exit)
sel.show()
box = g.HBox(False, 4)
entry = g.Entry()
button1 = tool.EventImage(self.__Options, g.STOCK_OPEN, open_file, g.ICON_SIZE_SMALL_TOOLBAR, "choose file")
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)
box.pack_start(button1, True, True, 0)
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]
class LabelTip(g.VBox):
def __init__(self):
g.VBox.__init__(self)
self.show()
self.images = []
self.images.append(Tip_Image(self, "label_tip_1.png", "always"))
self.images.append(Tip_Image(self, "label_tip_2.png", "tt_l_frame"))
self.images.append(Tip_Image(self, "label_tip_3.png", "tt_l_title"))
self.images.append(Tip_Image(self, "label_tip_4.png", "tt_l_frame"))
self.images.append(Tip_Image(self, "label_tip_5.png", "tt_l_desc"))
self.images.append(Tip_Image(self, "label_tip_6.png", "tt_l_frame"))
self.images.append(Tip_Image(self, "label_tip_7.png", "tt_l_link"))
self.images.append(Tip_Image(self, "label_tip_8.png", "tt_l_ver"))
self.images.append(Tip_Image(self, "label_tip_9.png", "always"))
def refresh(self, option, state):
for img in self.images:
if option.name == "tt_l": img.saturate(state)
else: img.check(option, state)
class ImageTip(g.VBox):
def __init__(self):
g.VBox.__init__(self)
self.show()
self.images = []
self.images.append(Tip_Image(self, "image_tip_1.png", "always"))
self.images.append(Tip_Image(self, "image_tip_2.png", "tt_i_frame"))
self.images.append(Tip_Image(self, "image_tip_3.png", "tt_i_title"))
self.images.append(Tip_Image(self, "image_tip_4.png", "tt_i_frame"))
self.images.append(Tip_Image(self, "image_tip_5.png", "tt_i_desc"))
self.images.append(Tip_Image(self, "image_tip_6.png", "tt_i_frame"))
self.images.append(Tip_Image(self, "image_tip_7.png", "tt_i_src"))
self.images.append(Tip_Image(self, "image_tip_8.png", "tt_i_link"))
self.images.append(Tip_Image(self, "image_tip_9.png", "tt_i_ver"))
self.images.append(Tip_Image(self, "image_tip_10.png", "always"))
def refresh(self, option, state):
for img in self.images:
if option.name == "tt_i": img.saturate(state)
else: img.check(option, state)
class ActiveTip(g.VBox):
def __init__(self):
g.VBox.__init__(self)
self.show()
self.image = Tip_Image(self, "active_tooltip.png", "always")
def refresh(self, option, state):
if option.name == "tt_a": self.image.saturate(state)
else: self.image.check(option, state)
class Tip_Image(g.Image):
def __init__(self, vbox, file, name):
g.Image.__init__(self)
self.pxbuf = g.gdk.pixbuf_new_from_file(rox.app_dir + "/images/" + file)
self.sat_pxbuf = g.gdk.pixbuf_new_from_file(rox.app_dir + "/images/" + file)
self.sat_pxbuf.saturate_and_pixelate(self.sat_pxbuf, 0.01, True)
self.set_from_pixbuf(self.pxbuf)
self.option = name
self.show()
vbox.add(self)
def check(self, option, state):
if option.name == self.option:
if state == 1: self.show()
else: self.hide()
def saturate(self, value):
if value == 1: self.set_from_pixbuf(self.pxbuf)
else: self.set_from_pixbuf(self.sat_pxbuf)
class ConfigPage(g.VBox):
def __init__(self, Options):
g.VBox.__init__(self,g.FALSE,3)
self.set_border_width(3)
self.__Options = Options
self.icon_image_tab = tool.EventImage(self.__Options)
self.tooltip = g.Tooltips(); self.tooltip.enable()
######## ticker adress
hbox_tick_frame = g.HBox()
from RETicker import minsize
self.button2 = tool.EventImage(self.__Options, g.STOCK_NO, self.switch_active, minsize, "click to activate")
self.tick_frame_label = g.Label(" News Source (click button to activate)")
hbox_tick_frame.pack_start(self.button2, g.FALSE, g.FALSE, 0)
hbox_tick_frame.pack_start(self.tick_frame_label, g.FALSE, g.FALSE, 0)
vbox_tick = g.VBox()
vbox_tick.set_border_width(3)
hbox_tick = g.HBox()
label2 = g.Label("source http-adress")
hbox_tick.pack_start(label2, g.FALSE, g.FALSE, 0)
self.e_ticker = g.Entry()
#self.e_ticker.set_size_request(248,22)
vbox_tick.pack_start(hbox_tick, g.FALSE, g.FALSE, 0)
vbox_tick.pack_start(self.e_ticker, g.FALSE, g.FALSE, 0)
#hbox_tick.pack_start(vbox_tick, g.FALSE, g.FALSE, 0)
frame_tick = g.Frame()
frame_tick.set_label_widget(hbox_tick_frame)
frame_tick.set_shadow_type(g.SHADOW_OUT)
frame_tick.set_border_width(3)
frame_tick.add(vbox_tick)
#hbox_main.pack_start(frame_icon, g.FALSE, g.FALSE, 0)
self.pack_start(frame_tick, g.FALSE, g.FALSE, 0)
######### new horizontal Box
hbox_main = g.HBox()
vbox_icon_all = g.VBox(g.FALSE, 0)
vbox_icon_all.set_border_width(3)
######### icon html-adress
hbox_icon = g.HBox()
label3 = g.Label("http-address")
self.button3 = tool.EventImage(self.__Options, g.STOCK_CONVERT, self.fetch_icon, g.ICON_SIZE_SMALL_TOOLBAR, "fetch icon to local adress")
hbox_icon.pack_start(label3, g.FALSE, g.FALSE, 3)
hbox_icon.pack_end(self.button3, g.FALSE, g.FALSE, 3)
vbox_icon_all.pack_start(hbox_icon, g.FALSE, g.FALSE, 0)
self.e_icon = g.Entry()
vbox_icon_all.pack_start(self.e_icon, g.FALSE, g.FALSE, 0)
frame_icon = g.Frame("Icon Configuration")
frame_icon.set_shadow_type(g.SHADOW_ETCHED_OUT)
frame_icon.set_border_width(3)
frame_icon.add(vbox_icon_all)
hbox_main.pack_start(frame_icon, g.FALSE, g.FALSE, 0)
######### Spacer
space_label= g.Label()
vbox_icon_all.pack_start(space_label, g.FALSE, g.FALSE, 0)
######### local icon
hbox_iconcache = g.HBox()
label4 = g.Label("local adress (preferred)")
self.button1 = tool.EventImage(self.__Options, g.STOCK_OPEN, self.open_cache_file, g.ICON_SIZE_SMALL_TOOLBAR, "choose file")
hbox_iconcache.pack_start(label4, g.FALSE, g.FALSE, 0)
hbox_iconcache.pack_end(self.button1, g.FALSE, g.FALSE, 0)
vbox_icon_all.pack_start(hbox_iconcache, g.FALSE, g.FALSE, 0)
self.e_iconcache = g.Entry()
self.tooltip.set_tip(self.e_iconcache, "Here should be a local path to your image," \
+ " if thisone is found there will be no http-connection established")
vbox_icon_all.pack_start(self.e_iconcache, g.FALSE, g.FALSE, 0)
self.label5 = g.Label("[ icon in cachdir - see path conf ]")
vbox_icon_all.pack_start(self.label5, g.FALSE, g.FALSE, 0)
######### right tab
vbox_right_all = g.VBox()
######### Number of News
hbox_news_num = g.HBox(g.FALSE, 3)
hbox_news_num.set_border_width(3)
news_label = g.Label("max. Number\nof News to show")
#label1.set_line_wrap(True)
self.s_shownews = g.SpinButton(g.Adjustment(5, 1, 300, 1, 10, 10))
hbox_news_num.pack_start(news_label, g.FALSE, g.FALSE, 0)
hbox_news_num.pack_end(self.s_shownews, g.FALSE, g.FALSE, 0)
frame_news = g.Frame("Ticker Configuration")
frame_news.set_shadow_type(g.SHADOW_ETCHED_OUT)
frame_news.set_border_width(3)
frame_news.add(hbox_news_num)
vbox_right_all.pack_start(frame_news, g.FALSE, g.FALSE, 0)
######### date-infos
hbox_date = g.HBox(g.FALSE, 3)
hbox_date.set_border_width(3)
date_label = g.Label("max news-age\nin minutes\n(0 to ignore)")
self.s_news_age_by_date = g.SpinButton(g.Adjustment(5, 0, 10000, 1, 10, 10))
hbox_date.pack_start(date_label, g.FALSE, g.FALSE, 0)
hbox_date.pack_end(self.s_news_age_by_date, g.FALSE, g.FALSE, 0)
self.frame_date = g.Frame("[ticker provides date info]")
self.frame_date.get_label_widget().modify_fg(g.STATE_NORMAL, g.gdk.color_parse('#008000'))
self.frame_date.set_shadow_type(g.SHADOW_ETCHED_OUT)
self.frame_date.set_border_width(3)
self.frame_date.add(hbox_date)
vbox_right_all.pack_start(self.frame_date, g.FALSE, g.FALSE, 0)
hbox_main.pack_start(vbox_right_all, g.FALSE, g.FALSE, 0)
self.pack_start(hbox_main, g.FALSE, g.FALSE, 0)
self.show_all()
########
#vsep = g.VSeparator()
#vsep.show()
#vsep.set_size_request(-1,95)
#self.put (vsep, 180, 43)
#self.add(hsep)
self.active = 1
self.ticker = ""
self.icon = ""
self.def_icon = "" # default icon position
self.iconcache = ""
self.def_iconcache = "" # default icon position in cache
self.news_age_by_date = 0
self.provides_date_info = None
self.shownews = 5
self.sig_ticker = None
self.sig_icon = None
self.sig_iconcache = None
self.sig_news_age_by_date = None
self.sig_shownews = None
self.sig_active = None
self.block_sig_ticker = 0
self.block_sig_icon = 0
self.WaitContainer_ticker = tool.WaitContainer(0, self.check_ticker_)
self.WaitContainer_icon = tool.WaitContainer(0, self.check_icon_)
self.WaitContainer_iconcache = tool.WaitContainer(0, self.check_iconcache_)
self.WaitContainer_shownews = tool.WaitContainer(0, self.check_shownews_)
self.WaitContainer_news_age_by_date = tool.WaitContainer(0, self.check_news_age_by_date_)
#######
self.Cons = tool.Connections()
self.connect("destroy", self.disconnect_all)
def refresh_tab_image(self, dummy=None, source = None):
print "refresh tab-image"
self.icon_image_tab.set(self.ticker)
def disconnect_all(self, dummy=None): self.Cons.disconnect_all()
def check_date_age(self):
if self.provides_date_info: self.frame_date.show()
else: self.frame_date.hide()
def open_cache_file(self, widget, event):
def set_cache_file(widget):
sel.hide()
self.set_iconcache(sel.get_filename())
def exit(widget):
sel.hide()
if event.button == 1:
sel = g.FileSelection()
if self.iconcache <> "":
sel.set_filename(self.long_dir(self.iconcache))
else: sel.set_filename(self.long_dir(self.def_iconcache))
sel.connect("destroy", exit)
sel.ok_button.connect("clicked", set_cache_file)
sel.cancel_button.connect("clicked", exit)
sel.show()
def activate_Signals(self):
if self.__Options.v: print "activate Page-Item SIGNALs"
if not(self.sig_ticker): self.sig_ticker = self.e_ticker.connect('changed',self.check_ticker)
if not(self.sig_icon): self.sig_icon = self.e_icon.connect('changed',self.check_icon)
if not(self.sig_iconcache): self.sig_iconcache = self.e_iconcache.connect('changed',self.check_iconcache)
if not(self.sig_shownews): self.sig_shownews = self.s_shownews.connect('value-changed',self.check_shownews)
if not(self.sig_news_age_by_date): self.sig_news_age_by_date = self.s_news_age_by_date.connect('value-changed',self.check_news_age_by_date)
def deactivate_Signals(self):
if self.__Options.v: print "deactivate Page-Item SIGNALs"
if self.sig_ticker:
self.e_ticker.disconnect(self.sig_ticker); self.sig_ticker = None
if self.sig_icon:
self.e_icon.disconnect(self.sig_icon); self.sig_icon = None
if self.sig_iconcache:
self.e_iconcache.disconnect(self.sig_iconcache); self.sig_iconcache = None
if self.sig_shownews:
self.s_shownews.disconnect(self.sig_shownews); self.sig_shownews = None
if self.sig_news_age_by_date:
self.s_news_age_by_date.disconnect(self.sig_news_age_by_date); self.sig_news_age_by_date = None
def fetch_icon(self, widget, event):
self.emit("refresh_icon_Page", self.ticker)
#~ url = self.icon
#~ if url == "": url = self.def_icon
#~ #print url
#~ file = self.iconcache
#~ if file == "": file = self.def_iconcache
#~ ### change this
#~ self.icon_image_tab.set(self.ticker) ## refresh if ticker is refreshed
#~ #self.icon_image_tab.get_from_uri_(self.http(url),file, self.ticker)
def check_shownews(self,value): self.WaitContainer_shownews.set_value(self.s_shownews.get_value())
def check_shownews_(self,value):
self.shownews = int(self.s_shownews.get_value())
if self.__Options.v: print "changed shownews"
self.emit('changed_Page',self)
def check_news_age_by_date(self,value): self.WaitContainer_news_age_by_date.set_value(self.s_news_age_by_date.get_value())
def check_news_age_by_date_(self,value):
self.news_age_by_date = int(self.s_news_age_by_date.get_value())
if self.__Options.v: print "changed news_age_by_date"
self.emit('changed_Page',self)
def switch_active(self, widget, event):
if self.__Options.v: print "switch active"
if self.active == 1: self.active = 0
else: self.active = 1
self.check_active()
def check_active(self):
if self.active == 1:
self.button2.set(g.STOCK_YES)
self.button2.set_tip("click to deactivate")
self.tick_frame_label.set_text(" News Source (click button to deactivate)")
else:
self.button2.set(g.STOCK_NO)
self.button2.set_tip("click to activate")
self.tick_frame_label.set_text(" News Source (click button to activate)")
self.icon_image_tab.set_active(self.active)
if self.__Options.v: print "changed active"
self.emit('changed_Page',self)
def short_dir(self,value):
if value.find(self.__Options.icon_cache_dir.value) == 0:
return "[...]"+value[len(self.__Options.icon_cache_dir.value):]
return value
def long_dir(self,value):
if value.find("[...]") == 0:
return self.__Options.icon_cache_dir.value + value[5:]
return value
def set_ticker(self, wert):
self.e_ticker.set_text(wert)
self.check_ticker(None)
def check_ticker(self,value): self.WaitContainer_ticker.set_value(self.e_ticker.get_text())
def check_ticker_(self,value):
self.deactivate_Signals()
self.block_sig_ticker = 1
self.ticker = self.e_ticker.get_text()
if self.ticker.find("http://") == 0:
pos = self.ticker[8:].find("/")
if pos <> -1: pos = pos + 8
else: pos = self.ticker.find("/")
if pos <> -1: self.def_icon = self.ticker[:pos] + "/favicon.ico"
else: self.def_icon = self.ticker + "/favicon.ico"
if self.icon == "":
self.e_icon.set_text(self.def_icon)
self.e_icon.modify_text(g.STATE_NORMAL,self.e_icon.get_colormap().alloc_color('grey'))
self.check_icon(None)
if self.__Options.v: print "changed ticker"
self.Cons.disconnect_all()
source = self.__Options.sources.get_by_ticker(self.ticker)
if source: self.Cons.connect(source, \
"change_iconcache", self.refresh_tab_image)
self.Cons.connect(self.__Options.sources, "source_added", self.refresh_tab_image)
#self.Cons.connect(self.__Options.sources.get_by_ticker(self.ticker), \
# "change_icon", self.refresh_tab_image)
self.block_sig_ticker = 0
self.activate_Signals()
self.emit('changed_Page',self)
def set_icon(self, wert):
self.e_icon.set_text(wert)
self.check_icon(None)
def check_icon(self,value): self.WaitContainer_icon.set_value(self.e_icon.get_text())
def check_icon_(self,value):
if not(self.block_sig_ticker): self.deactivate_Signals()
self.block_sig_icon = 1
tmp_icon = self.e_icon.get_text()
if tmp_icon <> self.def_icon:
self.icon = tmp_icon
self.def_iconcache = tool.tmp_name(self.__Options.icon_cache_dir.value, tmp_icon)
self.e_icon.modify_text(g.STATE_NORMAL,self.e_icon.get_colormap().alloc_color('black'))
else:
self.icon = ""
self.def_iconcache = tool.tmp_name(self.__Options.icon_cache_dir.value, self.def_icon)
self.e_icon.modify_text(g.STATE_NORMAL,self.e_icon.get_colormap().alloc_color('grey'))
if self.iconcache == "":
self.e_iconcache.set_text(self.short_dir(self.def_iconcache))
self.label5.show()
self.e_iconcache.modify_text(g.STATE_NORMAL,self.e_iconcache.get_colormap().alloc_color('grey'))
self.check_iconcache(None)
if self.__Options.v: print "changed icon"
if not(self.block_sig_ticker):
self.block_sig_icon = 0
self.activate_Signals()
self.emit('changed_Page',self)
else: self.block_sig_icon = 0
def set_iconcache(self, wert):
self.e_iconcache.set_text(wert)
self.check_iconcache(None)
def check_iconcache(self,value): self.WaitContainer_iconcache.set_value(self.e_iconcache.get_text())
def check_iconcache_(self,value):
#print "check_iconcache_ fired"
if not(self.block_sig_ticker) and not(self.block_sig_icon): self.deactivate_Signals()
tmp_iconcache = self.short_dir(self.e_iconcache.get_text())
self.e_iconcache.set_text(tmp_iconcache)
if tmp_iconcache.find("[...]") == 0: self.label5.show()
else: self.label5.hide()
if tmp_iconcache <> self.short_dir(self.def_iconcache):
self.iconcache = tmp_iconcache
self.e_iconcache.modify_text(g.STATE_NORMAL,self.e_iconcache.get_colormap().alloc_color('black'))
#self.icon_image_tab.get_from_file_(self.long_dir(self.iconcache), self.ticker)
else:
self.iconcache = ""
self.e_iconcache.set_text(tmp_iconcache)
self.e_iconcache.modify_text(g.STATE_NORMAL,self.e_iconcache.get_colormap().alloc_color('grey'))
#self.icon_image_tab.get_from_file_(self.def_iconcache, self.ticker)
if self.__Options.v: print "changed iconcache"
if not(self.block_sig_ticker) and not(self.block_sig_icon):
self.activate_Signals()
self.emit('changed_Page',self)
def http(self, value):
if value.find("://") == -1: return "http://" + value
return value
def set(self,value):
self.deactivate_Signals()
self.unset_WaitContainer_times()
if self.__Options.v: print "PAGE set"
self.active = tool.getintdata(value, "active")
self.check_active()
tmp_ticker = tool.getdata(value, "ticker")
self.set_ticker(tmp_ticker)
tmp_icon = tool.getdata(value, "icon")
if tmp_icon <> "": self.set_icon(tmp_icon)
tmp_iconcache = tool.getdata(value, "iconcache")
if tmp_iconcache <> "": self.set_iconcache(tmp_iconcache)
self.shownews = tool.getintdata(value, "shownews")
self.s_shownews.set_value(self.shownews)
self.news_age_by_date = tool.getintdata(value, "news_age_by_date")
self.s_news_age_by_date.set_value(self.news_age_by_date)
self.provides_date_info = tool.getintdata(value, "provides_date_info")
self.check_date_age()
self.refresh_tab_image()
self.set_WaitContainer_times()
self.activate_Signals()
def unset_WaitContainer_times(self):
self.WaitContainer_ticker.set_time(0)
self.WaitContainer_icon.set_time(0)
self.WaitContainer_iconcache.set_time(0)
self.WaitContainer_shownews.set_time(0)
self.WaitContainer_news_age_by_date.set_time(0)
def set_WaitContainer_times(self):
self.WaitContainer_ticker.set_time(0.5)
self.WaitContainer_icon.set_time(0.5)
self.WaitContainer_iconcache.set_time(0.5)
self.WaitContainer_shownews.set_time(0.5)
self.WaitContainer_news_age_by_date.set_time(0.5)
def _to_xml(self, parent):
if self.ticker == '': return
doc = parent.ownerDocument
root = doc.createElement('source')
parent.appendChild(root)
doc = root.ownerDocument
node = doc.createElement('active')
node.appendChild(doc.createTextNode(str(self.active)))
root.appendChild(node)
node = doc.createElement('ticker')
node.appendChild(doc.createTextNode(self.ticker))
root.appendChild(node)
node = doc.createElement('icon')
node.appendChild(doc.createTextNode(self.icon))
root.appendChild(node)
node = doc.createElement('iconcache')
if self.iconcache <> "":
node.appendChild(doc.createTextNode(self.long_dir(self.iconcache)))
else:
node.appendChild(doc.createTextNode(""))
root.appendChild(node)
node = doc.createElement('shownews')
node.appendChild(doc.createTextNode(str(self.shownews)))
root.appendChild(node)
node = doc.createElement('news_age_by_date')
node.appendChild(doc.createTextNode(str(self.news_age_by_date)))
root.appendChild(node)
node = doc.createElement('provides_date_info')
node.appendChild(doc.createTextNode(str(self.provides_date_info)))
root.appendChild(node)
gobject.signal_new("changed_Page", ConfigPage, gobject.SIGNAL_RUN_LAST,gobject.TYPE_NONE, (gobject.TYPE_PYOBJECT,))
gobject.signal_new("refresh_feed_Page", ConfigPage, gobject.SIGNAL_RUN_LAST,gobject.TYPE_NONE, (gobject.TYPE_PYOBJECT,))
gobject.signal_new("refresh_icon_Page", ConfigPage, gobject.SIGNAL_RUN_LAST,gobject.TYPE_NONE, (gobject.TYPE_PYOBJECT,))
class Help_Book(g.Notebook):
def __init__(self):
g.Notebook.__init__(self)
self.set_scrollable(True)
a = os.listdir(os.path.join( rox.app_dir, "Help/"))
for name in a:
filename = os.path.join(rox.app_dir, "Help/", name)
if not(os.path.isfile(filename)): continue
if not(name[:5] == "Help_"): continue
new_help = Help_Container(open(filename))
self.add(new_help)
self.set_tab_label_text(new_help, name[name.find('_')+1:name.find('.')])
self.show_all()
class Help_Container(g.Frame):
def __init__(self, file):
g.Frame.__init__(self)
swin=g.ScrolledWindow()
swin.set_policy(g.POLICY_AUTOMATIC,g.POLICY_AUTOMATIC)
swin.show()
self.add(swin)
textbuf = g.TextBuffer(None)
text = unicode(file.read(), 'iso-8859-1')
file.close()
ebox = g.EventBox()
ebox.show()
ebox.modify_bg(g.STATE_NORMAL,ebox.get_colormap().alloc_color('white'))
vbox = g.VBox()
vbox.show()
hbox = g.HBox()
hbox.show()
label = g.Label()
label.set_markup(text)
label.set_line_wrap(True)
label.set_size_request(280,-1)
label.show()
hbox.pack_start(label,g.FALSE,g.FALSE,15)
#vbox.pack_start(label,g.FALSE,g.FALSE,10)
vbox.pack_start(hbox,g.FALSE,g.FALSE,0)
ebox.add(vbox)
swin.add_with_viewport(ebox)
self.set_size_request(345,300)
self.show()
class TickPrefs_Container(g.VBox):
def __init__(self, Options):
self.__Options = Options
self.pageCount = 0
g.VBox.__init__(self, g.FALSE, 3)
hbox = g.HBox(g.FALSE, 0)
button2 = rox.ButtonMixed(g.STOCK_NEW, "New Source")
button2.connect('clicked', self.add_Page)
self.button4 = rox.ButtonMixed(g.STOCK_DELETE, "Kill Source")
self.button4.connect('clicked', self.kill_Page)
self.refresh = tool.EventImage(self.__Options, g.STOCK_REFRESH)
hbox.pack_start(button2, g.FALSE, g.FALSE, 0)
hbox.pack_start(self.button4, g.FALSE, g.FALSE, 3)
hbox.pack_end(self.refresh, g.FALSE, g.FALSE, 0)
self.pack_start(hbox, g.FALSE, g.FALSE, 3)
self.notebook = g.Notebook()
self.notebook.set_scrollable(True)
self.pack_start(self.notebook, g.FALSE, g.FALSE, 0)
self.show_all()
self.Cons = tool.Connections()
self.connect("destroy", self.disconnect_all)
def disconnect_all(self, dummy=None): self.Cons.disconnect_all()
def kill_Page(self, value):
killpage = self.notebook.get_nth_page(self.notebook.get_current_page())
change = (killpage.ticker <> "" or killpage.icon <> "")
self.Cons.disconnect(killpage, 'changed_Page')
self.Cons.disconnect(killpage, 'refresh_icon_Page')
self.Cons.disconnect(killpage, 'refresh_feed_Page')
self.notebook.remove_page(self.notebook.get_current_page())
self.pageCount -= 1
if self.pageCount == 0: self.button4.hide()
if change: self.emit('changed_Conti',self)
def changed_Page(self, value, value2):
if self.__Options.v: print "SIGNAL: changed Page " + str(self.notebook.get_current_page())
self.emit('changed_Conti',self)
def refresh_icon_Page(self, dummy, ticker): self.emit('refresh_icon_Conti', ticker)
def refresh_feed_Page(self, dummy, ticker): self.emit('refresh_feed_Conti', ticker)
def add_Page(self,value):
newpage = ConfigPage(self.__Options)
newpage.show()
self.notebook.append_page(newpage, newpage.icon_image_tab)
self.pageCount += 1
self.button4.show()
newpage.check_active()
newpage.check_date_age()
newpage.activate_Signals()
newpage.set_WaitContainer_times()
self.Cons.connect(newpage, 'changed_Page', self.changed_Page)
self.Cons.connect(newpage, 'refresh_icon_Page', self.refresh_icon_Page)
self.Cons.connect(newpage, 'refresh_feed_Page', self.refresh_feed_Page)
self.notebook.set_current_page(self.notebook.page_num(newpage))
newpage.e_ticker.grab_focus()
def add_Page_Set(self,value):
newpage = ConfigPage(self.__Options)
newpage.show()
self.notebook.append_page(newpage, newpage.icon_image_tab)
self.pageCount += 1
self.button4.show()
newpage.set(value)
newpage.activate_Signals()
self.Cons.connect(newpage, 'changed_Page', self.changed_Page)
self.Cons.connect(newpage, 'refresh_icon_Page', self.refresh_icon_Page)
self.Cons.connect(newpage, 'refresh_feed_Page', self.refresh_feed_Page)
def get_xml(self):
from xml.dom.minidom import Document
doc = Document()
root = doc.createElement('Options')
doc.appendChild(root)
for i in range(0, self.pageCount):
self.notebook.get_nth_page(i)._to_xml(root)
return doc
def get_value(self):
doc = self.get_xml()
return doc.toxml()
def load_config(self, config):
self.refresh.show()
prelight_refresh = 1
yield None
currentPage = self.notebook.get_current_page()
for i in range(0,self.pageCount):
self.notebook.remove_page(0)
self.pageCount = 0
self.button4.hide()
from xml.dom import Node, minidom
doc = minidom.parseString(tool.unxml(config))
for i in doc.getElementsByTagName("source"):
if prelight_refresh == 1: self.refresh.set_state(g.STATE_PRELIGHT); prelight_refresh = 0
else: self.refresh.set_state(g.STATE_NORMAL); prelight_refresh = 1
yield None
self.add_Page_Set(i)
self.refresh.hide()
yield None
if currentPage <> -1: self.notebook.set_current_page(currentPage)
gobject.signal_new("changed_Conti", TickPrefs_Container, gobject.SIGNAL_RUN_LAST,gobject.TYPE_NONE, (gobject.TYPE_PYOBJECT,))
gobject.signal_new("refresh_feed_Conti", TickPrefs_Container, gobject.SIGNAL_RUN_LAST,gobject.TYPE_NONE, (gobject.TYPE_PYOBJECT,))
gobject.signal_new("refresh_icon_Conti", TickPrefs_Container, gobject.SIGNAL_RUN_LAST,gobject.TYPE_NONE, (gobject.TYPE_PYOBJECT,))
def auweia(dummy):
print "auwiea"
def kill_tp(widget):
yield tasks.TimeoutBlocker(0.3)
print "kill"
widget.destroy()
print "done"
yield None
class TickPrefs(rox.Window): ### only for testing purposes
def __init__(self):
rox.Window.__init__(self)
self.pages = []
table = g.Table()
table.show()
self.add(table)
fixed = TickPrefs_Container()
fixed.show()
table.add(fixed)
#self.set_events(g.gdk.DESTROY)
self.connect("destroy", self.ende)
#self.connect("delete-event", auweia)
#auweia()
def ende(self, dummy):
print "ende"
def __del__(self):
print "Container closed"
#tp = TickPrefs()
#tp.show()
#tasks.Task(kill_tp(tp))
#rox.mainloop()
Ticker_0.4.5pre17.4.04/task.py 0100644 0000766 0000766 00000034012 10037765321 014267 0 ustar rene rene #
__version__ = '$Id: task.py,v 1.28 2001/02/09 06:36:11 hooft Exp $'
#
# (C) Rob W.W. Hooft, Nonius BV, 1998, 1999, 2000
#
# Contact rob@hooft.net for questions/suggestions.
# See:
# Distribute freely.
#
import sys,os,signal,time
class error(Exception):
pass
class _ready(Exception):
pass
def which(filename):
"""Find the file 'filename' in the execution path. If no executable
file is found, return None"""
for dir in os.environ['PATH'].split(os.pathsep):
fn=os.path.join(dir,filename)
if os.path.exists(fn):
if os.stat(fn)[0]&0111:
return fn
else:
return None
def Kill(self,signal=signal.SIGTERM):
"""Send a signal to the running subprocess.
optional arguments:
signal=SIGTERM: number of the signal to send.
(see os.kill)
return value:
see os.kill()
"""
if self.status is None:
# Only if it is not already finished
return os.kill(self.pid,signal)
class Task:
"""Manage asynchronous subprocess tasks.
This differs from the 'subproc' package!
- 'subproc' connects to the subprocess via pipes
- 'task' lets the subprocess run autonomously.
After starting the task, we can just:
- ask whether it is finished yet
- wait until it is finished
- perform an 'idle' task (e.g. Tkinter's mainloop) while waiting for
subprocess termination
- kill the subprocess with a specific signal
- ask for the exit code.
Summarizing:
- 'subproc' is a sophisticated os.popen()
- 'task' is a sophisticated os.system()
Another difference of task with 'subproc':
- If the Task() object is deleted, before the subprocess status
was retrieved, the child process will stay.
It will never be waited for (i.e., the process will turn into
a zombie. Not a good idea in general).
Public data:
None.
Public methods:
__init__, __str__, Run, Wait, Kill, Done, Status.
"""
def __init__(self,command):
"""Constructor.
arguments:
command: the command to run, in the form of a string,
or a tuple or list of words.
"""
if type(command)==type(''):
self.cmd=command
self.words=command.split()
elif type(command)==type([]) or type(command)==type(()):
# Surround each word by ' '. Limitation: words cannot contain ' chars
self.cmd="'"+"' '".join(command)+"'"
self.words=tuple(command)
else:
raise error("command must be tuple, list, or string")
self.pid=None
self.status=None
def Run(self,usesh=0,detach=0,stdout=None,stdin=None,stderr=None):
"""Actually run the process.
This method should be called exactly once.
optional arguments:
usesh=0: if 1, run 'sh -c command', if 0, split the
command into words, and run it by ourselves.
If usesh=1, the 'Kill' method might not do what
you want (it will kill the 'sh' process, not the
command).
detach=0: if 1, run 'sh -c 'command&' (regardless of
'usesh'). Since the 'sh' process will immediately
terminate, the task created will be inherited by
'init', so you can safely forget it. Remember that if
detach=1, Kill(), Done() and Status() will manipulate
the 'sh' process; there is no way to find out about the
detached process.
stdout=None: filename to use as stdout for the child process.
If None, the stdout of the parent will be used.
stdin= None: filename to use as stdin for the child process.
If None, the stdin of the parent will be used.
stderr=None: filename to use as stderr for the child process.
If None, the stderr of the parent will be used.
return value:
None
"""
if self.pid!=None:
raise error("Second run on task forbidden")
self.pid=os.fork()
if not self.pid:
for fn in range(3,256): # Close all non-standard files in a safe way
try:
os.close(fn)
except os.error:
pass
if stdout: # Replace stdout by file
os.close(1)
i=os.open(stdout,os.O_CREAT|os.O_WRONLY|os.O_TRUNC,0666)
if i!=1:
sys.stderr.write("stdout not opened on 1!\n")
if stdin: # Replace stdin by file
os.close(0)
i=os.open(stdin,os.O_RDONLY)
if i!=0:
sys.stderr.write("stdin not opened on 0!\n")
if stderr: # Replace stderr by file
os.close(2)
i=os.open(stderr,os.O_CREAT|os.O_WRONLY|os.O_TRUNC,0666)
if i!=2:
sys.stdout.write("stderr not opened on 2!\n")
try:
if detach:
os.execv('/bin/sh',('sh','-c',self.cmd+'&'))
elif usesh:
os.execv('/bin/sh',('sh','-c',self.cmd))
elif self.words[0]=='/':
os.execv(self.words[0],self.words)
else:
os.execvp(self.words[0],self.words)
except:
print self.words
sys.stderr.write("Subprocess '%s' execution failed!\n"%self.cmd)
sys.exit(1)
else:
# Mother process
if detach:
# Should complete "immediately"
self.Wait()
def TextAbortableWait(self,text):
print text
try:
return self.Wait()
except KeyboardInterrupt:
print "Interrupted."
stat=self.Status()
if stat is None:
# The process has not died yet. Kill it.
self.Kill(signal=2)
return self.Wait()
def AbortableWait(self,interval=0.1,master=None,text=None):
"""Wait for the subprocess to terminate. Allowing user to abort using
a Tkinter Dialog window.
If the process has already terminated, this function will return
immediately without raising an error.
Optional arguments:
master=None: The master of a Tkinter dialog window to be
popped up saying 'busy', and allowing the
user to abort the task using an Abort button.
text=None: The text to be used in the dialog window mentioned
above. If no text is given, no dialog box will
be popped up.
return value:
the exit status of the subprocess (0 if successful).
"""
if master is None:
return self.TextAbortableWait(text)
import Pmw
d=Pmw.MessageDialog(master,
message_text=text,
title='Working...',
buttons=('Abort',),
command=self._buttonkill)
try:
from misc import config
d.configure(message_background=config.bgbusy)
except ImportError:
pass
d.component('message').pack(ipadx=15,ipady=15)
def doit(d=d,self=self,idlefunc=master.update,interval=interval):
d.update()
self.Wait(idlefunc=idlefunc,interval=interval)
raise _ready
d.configure(activatecommand=doit)
try:
try:
d.activate()
except _ready:
pass
finally:
d.deactivate()
d.destroy()
return self.status
def Wait(self,idlefunc=None,interval=0.1):
"""Wait for the subprocess to terminate.
If the process has already terminated, this function will return
immediately without raising an error.
optional arguments:
idlefunc=None: a callable object (function, class, bound method)
that will be called every 0.1 second (or see
the 'interval' variable) while waiting for
the subprocess to terminate. This can be the
Tkinter 'update' procedure, such that the GUI
doesn't die during the run. If this is set to
'None', the process will really wait. idlefunc
should ideally not take a very long time to
complete...
interval=0.1: The interval (in seconds) with which the 'idlefunc'
(if any) will be called.
return value:
the exit status of the subprocess (0 if successful).
"""
if self.status!=None:
# Already finished
return self.status
if callable(idlefunc):
while 1:
try:
pid,status=os.waitpid(self.pid,os.WNOHANG)
if pid==self.pid:
self.status=status
return status
else:
idlefunc()
time.sleep(interval)
except KeyboardInterrupt:
# Send the interrupt to the inferior process.
try:
self.Kill(signal=signal.SIGINT)
except OSError:
# Apparently the process has terminated?
pass
except OSError:
# Apparently the process is unfindable?
print "WARNING: Unfindable process. Somebody else asked for my status!"
self.status=0
return 0
elif idlefunc:
raise error("Non-callable idle function")
else:
while 1:
try:
pid,status=os.waitpid(self.pid,0)
self.status=status
return status
except KeyboardInterrupt:
# Send the interrupt to the inferior process.
try:
self.Kill(signal=signal.SIGINT)
except OSError:
# Apparently the process has terminated?
pass
except OSError:
# Apparently the process is unfindable?
print "WARNING: Unfindable process. Somebody else asked for my status!"
self.status=0
return 0
def _buttonkill(self,arg):
self.Kill()
def Kill(self,signal=signal.SIGTERM):
"""Send a signal to the running subprocess.
optional arguments:
signal=SIGTERM: number of the signal to send.
(see os.kill)
return value:
see os.kill()
"""
if self.status is None:
# Only if it is not already finished
return os.kill(self.pid,signal)
else:
print "DBG> trying to send signal to finished program"
def Done(self):
"""Ask whether the process has already finished.
return value:
1: yes, the process has finished.
0: no, the process has not finished yet.
"""
if self.status!=None:
return 1
else:
pid,status=os.waitpid(self.pid,os.WNOHANG)
if pid==self.pid:
#print "OK:",pid,status
self.status=status
return 1
else:
#print "NOK:",pid,status
return 0
def Status(self):
"""Ask for the status of the task.
return value:
None: process has not finished yet (maybe not even started).
any integer: process exit status.
"""
self.Done()
return self.status
def __str__(self):
if self.pid!=None:
if self.status!=None:
s2="done, exit status=%d"%self.status
else:
s2="running"
else:
s2="prepared"
return "<%s: '%s', %s>"%(self.__class__.__name__,self.cmd,s2)
class Attach:
def __init__(self,pid):
self.pid=pid
def Kill(self,signal=signal.SIGTERM):
"""Send a signal to the attached process.
optional arguments:
signal=SIGTERM: number of the signal to send.
(see os.kill)
return value:
see os.kill()
"""
return os.kill(self.pid,signal)
def Status(self):
try:
self.Kill(signal=0)
except OSError:
return 0 # Terminated (or owned by someone else)
return None # Still running
if __name__=="__main__":
################
print "Testing simple program run"
done=0
t=Task('ls /tmp')
print t
t.Run()
print t
print "done,status=",t.Done(),t.Status()
time.sleep(2)
print "done,status=",t.Done(),t.Status()
print t
print "Superfluous wait=",t.Wait()
#################
print "Testing interruption of task"
done=0
t=Task('sleep 10')
t.Run()
print "done,status=",t.Done(),t.Status()
t.Kill()
print "done,status=",t.Done(),t.Status()
t.Wait()
print "done,status=",t.Done(),t.Status()
################
print "Testing wait for simple program run"
done=0
t=Task('ls /tmp')
t.Run()
t.Wait()
print "done,status=",t.Done(),t.Status()
Ticker_0.4.5pre17.4.04/RETicker.py 0100644 0000766 0000766 00000031671 10037765321 015005 0 ustar rene rene #!/usr/bin/env python
#########################################################
# RETicker v. 0.5.0
# a programm to display xml-formatted rss/rdf-feeds in
# a one line display
#########################################################
# please read Help.txt for contact information
#########################################################
# This file contains the classes for all widgets to #
# build the ticker-window #
#########################################################
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 applet, g, tasks
import sys
import os
import tool
import overview
import Options
import ticker_menu
import show_list
from output import Label_box
global minsize ### a Identifier for miniatur icons (see tool.EventBuffer for use)
minsize = g.icon_size_register("minimal-size-12-12", 12, 12)
"""--------------------------------------------------------------------------------------------"""
"""--------------------------- Main Program Container -----------------------------------------"""
"""--------------------------------------------------------------------------------------------"""
### This is the Main-Container. It holds all the shown and unshown Objects of the Ticker
### and connects siganls between them for cross-actions. Only signals from Options are also
### connected directly to other instances, except this there should be no cross instance
### signalling on lower levels
class MainContainer:
def __init__(self, V, Version, user_conf, verbose):
### here are the Options (including info about the sources) stored
self.__Options = Options.Options_(V, Version, user_conf, verbose)
import sys; import gc; gc.collect();
print "Options created: --> refrences to Options: " + str(sys.getrefcount(self.__Options))
### The box holds the Ticker-Label and the Ticker-Icon
self.__box = Label_box(self.__Options); self.add(self.__box)
print "Box created: --> refrences to Options: " + str(sys.getrefcount(self.__Options))
### show_list is a class wich presents a view of the news
self.__show_list = show_list.show_list(self.__Options, self.__box)
print "Show_list created: --> refrences to Options: " + str(sys.getrefcount(self.__Options))
### this is the active-ticker-window
self.__act_tick = overview.ov_aktfeed(self.__Options, self.__show_list)
print "act_tick created: --> refrences to Options: " + str(sys.getrefcount(self.__Options))
### this is the overview-window an contain
self.__overview = overview.overview(self.__Options, self.__show_list)
print "overview created: --> refrences to Options: " + str(sys.getrefcount(self.__Options))
### and the hole thing needs a menu
self.__menu = ticker_menu.menu(self.__Options, self)
print "menu created: --> refrences to Options: " + str(sys.getrefcount(self.__Options))
### set cross-object reaction to signals
self.__Options.connect("refresh_scrollbars", self.__act_tick.set_scrollbars)
self.__Options.connect("refresh_update_time", self.__show_list.refresh_update)
self.__Options.connect("refresh_refresh_time", self.__show_list.refresh_refresh)
self.__Options.connect("refresh_win_size", self.set_size)
self.__Options.connect("refresh_label_color", self.__box.label.set_color)
self.__Options.connect("refresh_transparency", self.refresh_transparency)
self.__Options.connect("refresh_background", self.update_back_color)
self.__box.image.connect("img_entered", self.show_overview_as_tip)
self.__box.image.connect("img_leaved", self.__act_tick.hide_later)
self.__box.image.connect("img_click_button_1", self.__show_list.open_page_feed)
self.__box.image.connect("img_click_button_2", self.__show_list.show_next_msg_in_ticker) #self.con_show_list.show_next_msg_in_ticker()
self.__box.image.connect("img_click_button_3", self.open_menu)
self.__box.image.connect("img_click_button_3", self.__act_tick.show_now_as_menu)
self.__box.label.connect("lab_click_button_1", self.__show_list.open_page)
self.__box.label.connect("lab_click_button_2", self.__show_list.show_next_msg_in_ticker)
self.__box.label.connect("lab_click_button_3", self.__show_list.show_next_msg_in_ticker)
self.__box.label.connect("lab_tickbild_entered", self.__show_list.rem_update)
self.__box.label.connect("lab_tickbild_leaved", self.__show_list.add_update)
self.__box.label.connect("scroll_event", self.__show_list.scroll_msg)
self.__show_list.connect("cached_news_read_slave", self.__act_tick.create_window)
self.__show_list.connect("next_feed_in_showlist", self.__act_tick.akt_feed)
self.__show_list.connect("refresh_feed_done_slave", self.__act_tick.refresh_if_actual)
self.__show_list.connect("refresh_feed_done_slave", self.__overview.reinit)
self.__act_tick.connect("size_changed_tt_a", self.__Options.act_tick_size_changed)
self.__act_tick.nav.connect("refresh_all", self.__show_list.start_refresh)
self.__act_tick.nav.connect("open_options", self.__Options.show_options)
self.__act_tick.nav.connect("open_overview_window", self.__overview.recreate_window)
self.__act_tick.nav.connect("help", self.open_help)
self.__act_tick.nav.connect("info", self.info)
self.__act_tick.nav.connect("quit", self.exit_prog)
self.__act_tick.stat.connect("switch_active", self.__Options.sources_switch_feed_active)
self.__act_tick.stat.connect("refresh_feed", self.__show_list.refresh_feed)
self.__overview.connect("switch_active_slave", self.__Options.sources_switch_feed_active)
self.__overview.connect("refresh_feed_slave", self.__show_list.refresh_feed)
self.__overview.connect("size_changed_ov", self.__Options.overview_size_changed)
self.__menu.connect("m_quit", self.exit_prog)
self.__menu.connect("m_help", self.open_help)
self.__menu.connect("m_info", self.info)
self.__menu.connect("m_show_window", self.__overview.recreate_window)
self.__menu.connect("m_show_options", self.__Options.show_options)
self.__menu.connect("m_refresh_ticker", self.__show_list.start_refresh)
### some formatting an done !
if self.applet:
self.set_size_request(self.__Options.hor_size.int_value, self.__Options.ver_size.int_value)
else: self.set_size_request(10,10)
self.set_size()
### some pixbufs for transparency -- and initialisation
self.__pixbuf_back = None; self.__pixbuf = None
self.__pixbuf_label = None; self.__pixbuf_image = None
self.activate_transparency()
self.connect('configure-event',self.win_configure)
self.connect("destroy", self.__del__)
self.set_app_paintable(True)
self.__box.label.set_app_paintable(True)
self.__box.image.set_app_paintable(True)
#if self.applet: self.connect('expose-event', self.expose)
self.show()
### Some themes draw images and stuff here, so we have to
### override it manually.
def expose(self, widget, event):
self.window.draw_rectangle(self.style.bg_gc[g.STATE_NORMAL], True,
0, 0,self.allocation.width,self.allocation.height)
### central method to show the info-window
def info(self, dummy = None): InfoWin.infowin(" " + self.__Options.Version + " ")
### central method to show the help-window (uses the HelpContainer in Options-Dialog)
def open_help(self, dummy = None):
Help = g.Window()
Help.set_title(" " + self.__Options.Version + " ")
HelpTab = Options.Help_Book()
Help.add(HelpTab)
Help.show()
### shows usual menu, if not ActiveTooltip Choosen as a menu
def open_menu(self, dummy, event):
if self.__Options.tt_a.int_value == 0 \
or self.__Options.tt_a_as_menu.int_value == 0:
self.__menu.popup(self.__menu, event, self.position_menu)
### get Position and size of the window an ask for showing the Tip (this willbe denied if
### there is choosen to show it as a menu
def show_overview_as_tip(self, dummy):
x, y = self.window.get_position()
w, h = self.size_request()
self.__act_tick.show_now_as_tip(x, y, w, h)
### set the size of the Window: If its an applet, uses requests, for a window use resize
def set_size(self, dummy = None):
if self.applet or self.__Options.hor_size.int_value <= 0 or self.__Options.ver_size.int_value <= 0:
self.set_size_request(self.__Options.hor_size.int_value, self.__Options.ver_size.int_value)
else:
self.set_size_request(10,10)
self.resize(self.__Options.hor_size.int_value, self.__Options.ver_size.int_value)
### set or unset transparency of the windows
def refresh_transparency(self, dummy):
self.activate_transparency()
### if transparency had changed, shake the window a little bit ;)
### mightbe its better to tell this the win-manager directly, but its working this way
x, y = self.window.get_position(); self.move(x+1, y); self.move(x-1, y)
### set or unset transparency of the windows (like above und usually called,
### except while initialising the window)
def activate_transparency(self):
if (self.__Options.transparent.int_value) == 0 or not(os.path.isfile(self.__Options.back_datei.value)):
self.update_back_color(None)
else:
### read background-image from File (set in Options)
self.__pixbuf_back = g.gdk.pixbuf_new_from_file(self.__Options.back_datei.value)
### set's the background colors (for all states) to spezified values
def update_back_color(self, dummy):
self.modify_bg(g.STATE_NORMAL,self.get_colormap().alloc_color(self.__Options.back_color.value))
self.__box.label.modify_bg(g.STATE_NORMAL,\
self.__box.label.get_colormap().alloc_color(self.__Options.back_color.value))
self.__box.label.modify_bg(g.STATE_PRELIGHT,\
self.__box.label.get_colormap().alloc_color(tool.back_color_prelight(self.__Options)))
self.__box.image.modify_bg(g.STATE_NORMAL,\
self.__box.image.get_colormap().alloc_color(self.__Options.back_color.value))
self.__box.image.modify_bg(g.STATE_PRELIGHT,\
self.__box.image.get_colormap().alloc_color(tool.back_color_prelight(self.__Options)))
### Callback Mathod after Configure-Event of the window or applet (save size, refresh background)
def win_configure(self, dummy, event):
if self.applet: w, h = self.size_request()
else: w, h = self.get_size()
if w <> self.__Options.hor_size.int_value or h <> self.__Options.ver_size.int_value:
self.__Options.mainwin_size_changed(w, h)
if (self.__Options.transparent.int_value): self.refresh_background(w, h)
### The way make the background look transparent
def refresh_background(self, w, h):
if not(self.__pixbuf_back): return
w_b = self.__pixbuf_back.get_width()
h_b = self.__pixbuf_back.get_height()
x, y = self.window.get_position()
w, h = self.get_size()
if x < 0 or y < 0: return
if x + w > w_b or y + h > h_b: return
x_l, y_l = self.__box.label.window.get_position()
w_l, h_l = self.__box.label.window.get_size()
x_i, y_i = self.__box.image.window.get_position()
w_i, h_i = self.__box.image.window.get_size()
if self.__pixbuf: del self.__pixbuf
self.__pixbuf = g.gdk.Pixbuf(g.gdk.COLORSPACE_RGB, False, 8, w, h)
if self.__pixbuf_label: del self.__pixbuf_label
self.__pixbuf_label = g.gdk.Pixbuf(g.gdk.COLORSPACE_RGB, False, 8, w_b - x - x_l, h_l)
if self.__pixbuf_image: del self.__pixbuf_image
self.__pixbuf_image = g.gdk.Pixbuf(g.gdk.COLORSPACE_RGB, False, 8, w_i, h_i)
self.__pixbuf_back.copy_area(x, y, w, h, self.__pixbuf, 0, 0)
self.__pixbuf_back.copy_area(x+x_l, y+y_l, w_b - x - x_l, h_l, self.__pixbuf_label, 0, 0)
self.__pixbuf_back.copy_area(x+x_i, y+y_i, w_i, h_i, self.__pixbuf_image, 0, 0)
self.__pixmap, mask = self.__pixbuf.render_pixmap_and_mask()
self.__pixmap_label, mask = self.__pixbuf_label.render_pixmap_and_mask()
self.__pixmap_image, mask = self.__pixbuf_image.render_pixmap_and_mask()
self.window.set_back_pixmap(self.__pixmap, False)
self.__box.label.window.set_back_pixmap(self.__pixmap_label, False)
self.__box.image.window.set_back_pixmap(self.__pixmap_image, False)
self.resize(w,h)
self.__box.label.hide()
self.__box.label.show()
self.__box.image.hide()
self.__box.image.show()
### exit the while Programm (calls __del__ in callback)
def exit_prog(self, dummy): self.destroy()
### if exciting the Program, save the Options, and close all windows
def __del__(self, dummy):
self.__show_list.export_xml() ## save actual feeds
rox.app_options.save() ## save Options (mightbe changed since last Access to Optionsbox)
if self.__Options.OptionsBox: self.__Options.OptionsBox.destroy()
self.destroy(); g.main_quit()
### Program-Window
class TickerWindow(rox.Window, MainContainer):
def __init__(self, V, Version, user_conf, verbose):
rox.Window.__init__(self)
self.applet = False
self.__Options = None
MainContainer.__init__(self, V, Version, user_conf, verbose)
self.position_menu = None
self.set_title(" " + Version + " ")
### Program-applet
class TickerApplet(applet.Applet, MainContainer):
def __init__(self, V, Version, user_conf, verbose):
applet.Applet.__init__(self,sys.argv[1])
self.applet = True
MainContainer.__init__(self, V, Version, user_conf, verbose)
self.__Options = None
"""--------------------------------------------------------------------------------------------"""
Ticker_0.4.5pre17.4.04/tool.py 0100644 0000766 0000766 00000022663 10040216600 014274 0 ustar rene rene #!/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
import os
import gc
import gobject
#global minsize ### a Identifier for miniatur icons
#global minsize
class Connections:
def __init__(self):
self.__connections = []
def connect(self, source, signal, callback):
con = source.connect(signal, callback)
self.__connections.append({'source' : source, 'signal' : signal, 'con' : con})
def disconnect_all(self, dummy = None):
for con in self.__connections: con['source'].disconnect(con['con'])
self.__connections = []
def disconnect(self, source, signal):
i = 0
while i < len(self.__connections):
con = self.__connections[i]
if con['source'] == source and con['signal'] == signal:
con['source'].disconnect(con['con'])
self.__connections.pop(i)
else: i += 1
class Win_ProgBar(g.Window):
def __init__(self, Label = None):
g.Window.__init__(self)
self.set_decorated(g.FALSE)
self.prog = g.ProgressBar()
self.prog.set_size_request(100,6)
self.prog.set_pulse_step(0.2)
if Label: self.prog.set_text(Label)
self.add(self.prog)
x, y, mods = g.gdk.get_default_root_window().get_pointer()
if x - 50 > 0: x = x - 50
else: x = 0
if y - 10 > 0: y = y - 10
else: y = y + 10
self.move(x, y)
self.show_all()
def start_pulse(self): tasks.Task(self.pulse_loop())
def pulse_loop(self):
while(self.prog):
self.prog.pulse()
yield tasks.TimeoutBlocker(0.1)
def rem(self): self.prog = None; self.destroy()
class EventImage(g.EventBox):
def __init__(self, Options, StockOrTicker = g.STOCK_MISSING_IMAGE, \
press_event = None, size = g.ICON_SIZE_SMALL_TOOLBAR, tooltip = None):
self.__Options = Options
self.size = size
g.EventBox.__init__(self)
self.image = g.Image()
self.add(self.image)
self.set_events(g.gdk.ENTER_NOTIFY_MASK | g.gdk.LEAVE_NOTIFY_MASK)
if press_event <> None:
self.connect('button_press_event', self.button_pressed)
self.connect('button_press_event', press_event)
self.connect('button_release_event', self.button_released)
self.connect("enter-notify-event", self.enter_widget)
self.connect("leave-notify-event", self.leave_widget)
self.Cons = Connections()
self.connect("destroy", self.disconnect_all)
self.__iconset = None
self.set(StockOrTicker)
self.image.show()
self.show()
if tooltip: self.set_tip(tooltip)
self.__active = 1
def disconnect_all(self, dummy=None): self.Cons.disconnect_all()
### Changing the States of the Image
def enter_widget(self, widget=None, event=None): self.image.set_state(g.STATE_PRELIGHT)
def leave_widget(self, widget=None, event = None): self.image.set_state(g.STATE_NORMAL)
def set_active(self, active): self.image.set_sensitive(active)
def button_pressed(self, widget, event): self.image.set_state(g.STATE_SELECTED); tasks.Task(self.blink())
def button_released(self, widget, event): self.image.set_state(g.STATE_NORMAL)
def blink(self):
for i in range(0, 6):
self.image.set_state(g.STATE_PRELIGHT); yield tasks.TimeoutBlocker(0.02)
self.image.set_state(g.STATE_NORMAL); yield tasks.TimeoutBlocker(0.02)
### The set Method refers to the set_ method - this makes it easyer to override it (see output.py)
def set(self, StockOrTicker): self.set_(StockOrTicker)
def set_(self, StockOrTicker):
self.Cons.disconnect(self.__iconset, "icon_changed")
if StockOrTicker.find('gtk-') == 0:
self.image.set_from_icon_set(self.__Options.stock_iconsets.get(StockOrTicker), self.size)
else:
self.__iconset = self.__Options.sources.get_iconset_by_ticker(StockOrTicker)
if self.__iconset:
self.Cons.connect(self.__iconset, "icon_changed", self.refresh) # To keep Icon up to date
self.Cons.connect(self.__iconset, "icon_at_url_not_retrieved", self.no_icon) # To react if no icon
self.refresh()
else: self.set_(g.STOCK_DIALOG_ERROR) ### maybe Source was killed in meantime
def refresh(self, dummy = None): self.image.set_from_icon_set(self.__iconset.get(), self.size)
def no_icon(self, dummy = None): self.image.set_from_icon_set(self.__Options.stock_iconsets.get(g.STOCK_MISSING_IMAGE), self.size)
def set_tip(self, Text):
if not(Text): return
self.tooltip = g.Tooltips(); self.tooltip.enable()
self.tooltip.set_tip(self, Text)
def rem_tip(self):
self.tooltip.disable()
import re
def unxml(string):
""" removes tags and entities from a given string and returns
new string """
lt=re.compile('<')
gt=re.compile('>')
amp=re.compile('&')
auml=re.compile('ä|ä')
Auml=re.compile('Ä')
ouml=re.compile('ö|ö')
Ouml=re.compile('Ö')
uuml=re.compile('ü|ü')
Uuml=re.compile('Ü')
szlig=re.compile('ß|ß')
quot=re.compile('"')
apos=re.compile(''')
#tag=re.compile('<.*?>')
(string,null)=amp.subn("&",string,0)
(string,null)=auml.subn(u'\xE4',string,0)
(string,null)=Auml.subn(u'\xC4',string,0)
(string,null)=ouml.subn(u'\xF6',string,0)
(string,null)=Ouml.subn(u'\xD5',string,0)
(string,null)=Uuml.subn(u'\xDC',string,0)
(string,null)=szlig.subn(u'\xDF',string,0)
(string,null)=uuml.subn(u'\xFC',string,0)
(string,null)=quot.subn('"',string,0)
(string,null)=apos.subn("'",string,0)
(string,null)=lt.subn("<",string,0)
(string,null)=gt.subn(">",string,0)
#(string,null)=tag.subn("",string,0)
return string
import time
def conv_iso_time(date):
if date[-5] == "+" or date[-5] == "-": date = date[:-5]
if date[-6] == "+" or date[-6] == "-": date = date[:-6]
return time.mktime(time.strptime(date, "%Y-%m-%dT%H:%M:%S"))
def getdata(channel,name):
c_name_s=channel.getElementsByTagName(name)
c_name = ""
if c_name_s:
for t in c_name_s[0].childNodes:
if t: c_name+=t.data
return c_name
def getdata_wo_ret(channel,name): ### get data as String without return
c_name_s=channel.getElementsByTagName(name)
c_name = ""
if c_name_s:
for t in c_name_s[0].childNodes:
if t: c_name+=t.data
pos = c_name.find('\n')
while pos <> -1:
if pos <> 0: tmp = c_name[:pos] + " "
else: tmp = ""
tmp += c_name[pos+1:]
c_name = tmp
pos = c_name.find('\n')
return c_name
def getintdata(channel,name):
c_name_s=channel.getElementsByTagName(name)
c_name = ""
if c_name_s:
for t in c_name_s[0].childNodes:
if t: c_name+=t.data
try: return int(c_name)
except: return 0
def getfloatdata(channel,name):
c_name_s=channel.getElementsByTagName(name)
c_name = ""
if c_name_s:
for t in c_name_s[0].childNodes:
if t: c_name+=t.data
try: return float(c_name)
except: return 0
def gettimedata(channel,name):
c_name_s=channel.getElementsByTagName(name)
c_name = ""
if c_name_s:
for t in c_name_s[0].childNodes:
if t: c_name+=t.data
if c_name == "": return 0
else: return float(conv_iso_time(c_name))
def get_prelight_colors(Options):
back_obj = g.gdk.color_parse(Options.back_color.value)
text_obj = g.gdk.color_parse(Options.text_color.value)
if Options.transparent.int_value == 1:
if text_obj.red + text_obj.green + text_obj.blue > 65535/2:
text_obj = change_color(text_obj, 0.3)
else: text_obj = change_color(text_obj, -0.3)
if text_obj.red + text_obj.green + text_obj.blue \
> back_obj.red + back_obj.green + back_obj.blue:
# Text heller als Hintergrund
text_obj = change_color(text_obj, 0.3)
back_obj = change_color(back_obj, -0.3)
else:
text_obj = change_color(text_obj, -0.3)
back_obj = change_color(back_obj, 0.3)
return text_obj, back_obj
def set_color_part(color_part, value):
tmp = int(color_part * (1 + value))
if tmp > 65535: return 65535
if tmp < 0: return 0 # this shouldnt happen ;)
return tmp
def change_color(obj, value):
obj.red = set_color_part(obj.red, value)
obj.green = set_color_part(obj.green, value)
obj.blue = set_color_part(obj.blue, value)
obj.pixel = 0
return obj
def back_color_prelight(Options):
text_obj, back_obj = get_prelight_colors(Options)
return back_obj
def text_color_prelight(Options):
text_obj, back_obj = get_prelight_colors(Options)
return text_obj
def tmp_name(cache, url):
pos = url.find("http://")
if pos <> -1: url = url[pos+7:]
while 1:
pos = url.find("/")
if pos <> -1:
url = url[:pos] + "_" + url[pos+1:]
else: break
return cache + "/" + url
def makeshorter(text, length):
new_text = text[:length]
last_space = new_text[10:].find(" ")
if last_space <> 0: new_text = new_text[:len(new_text)-10+last_space]
return new_text + "..."
def urlretrieve(url, file):
###### special approach to stop blocking in urllib
import Options
if os.path.isfile(file): os.remove(file)
exec_file = os.path.join(rox.app_dir, 'gethttp.py')
command = ['python', exec_file, url, file, Options.use_proxy.value, Options.proxy.value]
import task
t = task.Task(command); t.Run()
return t
####### feed copyd without blocking
class WaitContainer:
def __init__(self, time_to_wait, function_to_call):
self.time_to_wait = time_to_wait
self.function_to_call = function_to_call
self.value = None
self.timeout = None
def set_time(self, time):
self.time_to_wait = time
if self.timeout:
g.timeout_remove(self.timeout)
self.timeout = g.timeout_add(long(self.time_to_wait * 1000), self.fire)
def set_value(self, value = None):
self.value = value
#print "set_value"
if self.timeout: g.timeout_remove(self.timeout)
if self.time_to_wait <> 0:
self.timeout = g.timeout_add(long(self.time_to_wait * 1000), self.fire)
else: self.timeout = None; self.fire()
def fire(self):
#print "fired"
self.fire_task = None
self.function_to_call(self.value)
self.value = None
Ticker_0.4.5pre17.4.04/show_list.py 0100644 0000766 0000766 00000041776 10037765321 015357 0 ustar rene rene #!/usr/bin/env python
#########################################################
# RETicker v. 0.4.5pre
# a programm to display xml-formatted rss/rdf-feeds in
# a one line display
#########################################################
# please read Help.txt for contact information
#########################################################
# This file contains the classes storing and showing #
# the actual news #
#########################################################
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 xml.dom import minidom
#from xml.dom.minidom import Document
#import xml.sax
import os
#import time
import gobject
import news
import tool
"""--------------------------------------------------------------------------------------------"""
"""------------------------------ The Container Which holds the News --------------------------"""
"""--------------------------------------------------------------------------------------------"""
### ShowList Class holds the news, ore better, it gives a view to the news. They are actually
### hold in news, whoich is now part of show_list. Maybe they are going together in future Versions
### or they will be really separated, like originally planned, to enable different views of the
### same sources
### For the moment show-list is more the connection to the ticker (switch to next msg etc.) while
### news is the connection to the real world :=)
"""--------------------------------------------------------------------------------------------"""
"""------------------------------ Show_List The View of the News ------------------------------"""
"""--------------------------------------------------------------------------------------------"""
### The Class contains 3 main sections
### 1. Methods for communication with Parent and Childs, or to open pages etc.
### 2. Methods to move forwards or backwards in Ticker, give next/prev message by regularily
### updates and get aktual Ticker-message etc
### 3. Methods to move forwards or backwards in ActiveTooltip
class show_list(gobject.GObject): # has to be a gobject to enable signals
def __init__(self, Options, box): # gets Options an for the Output also a box
gobject.GObject.__init__(self)
self.__Options = Options # given as params
self.__box = box
self.__news = news.news(Options, box) # create a news object, which hold the news
self.feeds = self.__news.feeds # and connect to feeds there
### some local values to recognize, where we are
self.__fd_count = None # Positon in news.feeds
self.__msg_index = None # msg-number in this feed
self.__error = "" # holds the last error msg
self.__updatetimeout = None # holds timeout for next update
self.__updating = False # blocks updating if still in process
self.__news.connect("cached_news_read", self.cached_news_read)
self.__news.connect("refresh_feed_done", self.refresh_feed_done)
self.__news.connect("feed_killed", self.feed_killed)
"""----------------------------------------------------------------------------------"""
""" 1. Methods for communication with Parent and Childs, or to open pages etc """
"""----------------------------------------------------------------------------------"""
### connect some methods directly to methods of the self.__news instance
def refresh_feed(self, dummy, feed): tasks.Task(self.__news.refresh_feed(feed))
def start_refresh(self, dummy): self.__news.start_refresh()
def export_xml(self): return self.__news.export_xml()
def stat(self): return self.__news.stat()
### if Options have changed, this methods are called to update the timeouts
def refresh_update(self, dummy): self.rem_update(); self.add_update()
def refresh_refresh(self, dummy): self.__news.rem_refresh(); self.__news.add_refresh()
### if a feed was killed, check if it was the actual one and change the actual one if needed
def feed_killed(self, dummy, number_of_killed_feed):
if number_of_killed_feed == self.__fd_count:
self.__fd_count = None; self.next_feed()
### some signals which arrive from self.__news will be send to a higher level
def cached_news_read(self, event):
self.emit("cached_news_read_slave") # send slave signal to higher level
self.update_ticker() # messages are there, show them in box
self.__news.start_refresh() # and then try to refresh the news
def refresh_feed_done(self, dummy, feed):
if (self.__msg_index == None):
self.update_ticker() # if still no msg for ticker, update it
self.emit("refresh_feed_done_slave", feed)
### methods to open the actual page or the actual feed (started as task)
def open_page(self, dummy = None): tasks.Task(self.open_page_task())
def open_page_task(self): # open message shown in ticker
msg = self.akt_msg(); yield None
if msg == None:
### This shouldnt happen, where from you reached this point?
### but its here for safety reasons ;)
print "ERROR: no actual message, how should i open this in browser?"
self.__box.status("ERROR: no actual message to open", g.STOCK_DIALOG_ERROR); yield None;
return
self.__box.status("opening page in browser", g.STOCK_CONVERT); yield None
msg.read = 1 ### dont forget to mark the message as read
if self.__Options.br_options.value <> "":
os.spawnlp(os.P_NOWAIT,self.__Options.browser.value,\
self.__Options.browser.value,self.__Options.br_options.value,msg.link)
else: os.spawnlp(os.P_NOWAIT,self.__Options.browser.value,self.__Options.browser.value,msg.link)
def open_page_feed(self, dummy = None): tasks.Task(self.open_page_feed_task())
def open_page_feed_task(self): # open homepage of the ticker
feed = self.akt_feed()
if feed == None:
### This shouldnt happen, where from you reached this point?
### but its here for safety reasons ;)
print "ERROR: no actual feed, how should i open this in browser?"
self.__box.status("ERROR: no actual feed-page to open", g.STOCK_DIALOG_ERROR); yield None;
return
self.__box.status("opening feed-page in browser", g.STOCK_CONVERT); 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,feed.link)
else: os.spawnlp(os.P_NOWAIT,self.__Options.browser.value,self.__Options.browser.value,feed.link)
"""----------------------------------------------------------------------------------"""
""" 2. Methods to move forwards or backwards in Ticker and update the Ticker """
"""----------------------------------------------------------------------------------"""
### two methods to add and remove the update-timeouts
def add_update(self, dummy = None):
if self.__updatetimeout == None:
self.__updatetimeout = g.timeout_add(1000*self.__Options.update_time.int_value, self.update_ticker)
def rem_update(self, dummy = None):
if self.__updatetimeout <> None:
g.timeout_remove(self.__updatetimeout); self.__updatetimeout = None
### the regularly called update-method: first remove the update to prevent
### double-updates and after updating (forward), add timeout again
def update_ticker(self):
self.rem_update()
if self.__Options.v: print "update Ticker"
self.show_next_msg_in_ticker()
self.add_update()
return True
### a callback which enables scrolling in messages
def scroll_msg(self, widget, event):
if event.direction == 1: self.show_next_msg_in_ticker()
elif event.direction == 0: self.show_prev_msg_in_ticker()
### two methods to show next or previous message in Ticker, those are called manually
### Usually Signals (think for istance of scroll signals) are usually stored till they
### could done - this might reult in storing 100 go forward events and blocking your
### CPU doing the job. Tasks allow to disable such fast-following signals
def show_next_msg_in_ticker(self, dummy = None): tasks.Task(self.show_next_msg_in_ticker_task())
def show_next_msg_in_ticker_task(self):
if self.__updating: return
import sys; import gc; gc.collect();
print "next_msg show_list --> refrences to Options: " + str(sys.getrefcount(self.__Options))
self.__updating = True;
yield None; i = self.next_msg();
yield None; self.show_msg(i); yield None; self.__updating = False
def show_prev_msg_in_ticker(self, dummy = None): tasks.Task(self.show_prev_msg_in_ticker_task())
def show_prev_msg_in_ticker_task(self):
if self.__updating: return
self.__updating = True; yield None; i = self.prev_msg();
yield None; self.show_msg(i); yield None; self.__updating = False
### Method to show the message in the box
def show_msg(self, i):
if not(i):
if len(self.__news.feeds) <> 0:
time_to_wait = self.__news.time_to_next_refresh()
if time_to_wait == None: message = ", refreshing"
elif int(time_to_wait) == 0: message = ", waiting " + str(int(time_to_wait*60)) + " seconds"
else: message = ", waiting " + str(int(time_to_wait)) + " minutes"
self.__error += message
self.__box.image.set(g.STOCK_CANCEL)
self.__box.label.tooltip.disable()
else:
self.__box.image.set(g.STOCK_DIALOG_ERROR)
self.__box.label.set_tip("I havn't found any News Sources in your Configuration, " +\
"you have to open the Options Dialog and add at least one source")
self.__box.label.update(self.__error)
self.__box.image.tooltip.disable()
return False
else:
fd = self.akt_feed()
name = tool.unxml(i.title).encode("utf-8")
self.__box.label.update(name)
#self.__box.image.get_from_file(fd.get_iconcache())
self.__box.image.set(fd.ticker)
self.__box.label.addTip(i)
self.__box.image.addTip(fd, self.__news)
return True
### returns the actual feed shown in ticker or none, if no actual feed available
### return None might happen if there are no (new) feed in self.__news or if
### the actually in ticker shown feed was killed recently or set inactive
def akt_feed(self):
try:
aktfeed = self.__news.feeds[self.__fd_count]
if aktfeed.get_active(): return aktfeed
#else: print "feed "+ aktfeed.get_ticker() + " not active"
except: print "uuups, beeing here"; return None
return None
### returns the actual message. as above, there might be no actual message, if there
### is no new message or if actual feed was killed recently
def akt_msg(self):
try: return self.akt_feed().msg[self.__msg_index]
except: return None
return None
### returns the Status of the actual message. As above, there might be no actual message
### if there is no new message or if actual feed was killed recently, then lets say this
### no-message isnt new ;)
def akt_msg_is_new(self):
try: return self.akt_feed().msg_is_new(self.akt_msg())
except: return False
return False
### checks if there are no messages left to show as new in ticker by user criteria
### this must be checked bevor going in recursion
### Cause time happens between checking of so called 'new messages' and using them,
### it might be a different situation later, but i think its ok to do so
def no_msg(self):
self.__error = "no messages"
for fd in self.__news.feeds: # check all feeds
if fd.get_active() == 1 \
and len(fd.msg) > 0 \
and fd.get_shownews() > 0:
### There are messages, check if they are too old
self.__error = "only old messages"
for i in range(0, len(fd.msg)-1):
if fd.msg_is_new(fd.msg[i]):
### ok, there is at least one new message
self.__error = ""
return False
if i + 1 == fd.get_shownews(): break
return True
### returns the next new message to show based on user configuration. If there is no
### new msg left, it returns None
def next_msg(self):
# If there were last time no mesages, try to start from 0
if self.__msg_index == None or self.__fd_count == None:
self.__msg_index = 0; self.__fd_count = 0
print "reinit feed and msg counts"
while(1):
akt_feed = self.akt_feed()
print "stats"
print str(akt_feed)
if akt_feed: print str(self.__msg_index) + " " + \
str(len(akt_feed.msg)) + " " + str(akt_feed.get_shownews())
if akt_feed and \
self.__msg_index + 1 < min(len(akt_feed.msg), akt_feed.get_shownews()):
print "try next message"
self.__msg_index += 1
else:
if not(self.next_feed()): # try next feed
self.__msg_index = None; return None
else: self.__msg_index = 0
if self.akt_msg_is_new():
self.akt_msg().showcount += 1; return self.akt_msg()
### search the next 'active' feed an set self.__fd_count to feed_nr
### Return Feed or None to indicate if it was succesful
def next_feed(self):
# If there is no actual feed, try 0
if self.__fd_count == None: self.__fd_count = 0
self.__error = ""
while(1):
if self.__fd_count < len(self.__news.feeds)-1: # try next feed
self.__fd_count += 1
else:
if self.no_msg():
self.__fd_count = None
if len(self.__news.feeds)==0:
self.__error = "no sources (use Options to add)"
else: self.__error = "no active feed found"
return None
else: self.__fd_count = 0 # use first feed
akt_feed = self.akt_feed()
if akt_feed:
self.emit("next_feed_in_showlist", akt_feed)
return akt_feed
### returns the prev new message to show based on user configuration. If there is no
### new msg left, it returns None
def prev_msg(self):
# If there were last time no mesages, try to start from 0
if self.__msg_index == None or self.__fd_count == None:
self.__fd_count = len(self.__news.feeds)-1
while(1):
akt_feed = self.akt_feed()
if akt_feed and self.__msg_index > 0:
self.__msg_index -= 1
else:
akt_feed = self.prev_feed()
if not(akt_feed): # try prev feed
self.__msg_index = None; return None
else: self.__msg_index = min(len(akt_feed.msg)-1, akt_feed.get_shownews()-1)
if self.akt_msg_is_new():
self.akt_msg().showcount += 1; return self.akt_msg()
### search the next 'active' feed an set self.__fd_count to feed_nr
### Return Feed or None to indicate if it was succesful
def prev_feed(self):
self.__error = ""
while(1):
if self.__fd_count > 0: # try prev feed
self.__fd_count -= 1
else:
if self.no_msg():
self.__fd_count = None
self.__error = "no active feed found"
return None
else:
self.__fd_count = len(self.__news.feeds)-1 # use last feed
akt_feed = self.akt_feed()
if akt_feed:
self.emit("prev_feed_in_showlist", akt_feed)
return akt_feed
"""----------------------------------------------------------------------------------"""
""" 3. Methods to move forwards or backwards in Overview/ActiveTooltip """
"""----------------------------------------------------------------------------------"""
### The following method checks, if the choosen feed is a valid overviev-feed
### on User-Options (this might be at the wrong place, should be someday at
### part of the overview-classes
### If the overview-feed, which is choosen from user by asking for the next
### or the previous feed, is an actual feed with 'new' messages, then update
### the ticker with this feed
def is_overview_feed(self, feed):
if feed.get_active() == 1:
for msg in feed.msg:
if feed.msg_is_new(msg): # if there are new messages in this feed
self.__fd_count = feed.feed_nr # update the ticker
self.__msg_index = 0
self.update_ticker()
return True
if self.__Options.tt_a_fd_wo_news.int_value == 1: return True
if self.__Options.tt_a_inactive_fd.int_value == 1: return True
return False
### check if there are still feeds which are valid by user criteria for overview
### its importend to check this bevor recursion
def no_ov_feed(self):
for fd in self.__news.feeds:
if self.is_overview_feed(fd): return False
return True
### return the next feed by user criteria for overview (and update ticker,
### see self.is_overview_feed
def ov_next_feed(self, feed):
if not(feed): # if feed = None, restart at the first feed
feed_nr = -1
else: feed_nr = feed.feed_nr
while feed_nr < len(self.__news.feeds)-1:
feed_nr += 1
if self.is_overview_feed(self.__news.feeds[feed_nr]):
return self.__news.feeds[feed_nr]
if self.no_ov_feed(): return None
else: return self.ov_next_feed(None)
### return the next feed by user criteria for overview (and update ticker,
### see self.is_overview_feed
def ov_prev_feed(self, feed):
if not(feed): # if feed = None, restart at the last feed
feed_nr = len(self.__news.feeds)
else: feed_nr = feed.feed_nr
while feed_nr <> 0:
feed_nr -= 1
if self.is_overview_feed(self.__news.feeds[feed_nr]):
return self.__news.feeds[feed_nr]
if self.no_msg(): return None
else: return self.ov_prev_feed(None)
gobject.signal_new("cached_news_read_slave", show_list, gobject.SIGNAL_RUN_LAST,gobject.TYPE_NONE, ())
gobject.signal_new("next_feed_in_showlist", show_list, gobject.SIGNAL_RUN_LAST,gobject.TYPE_NONE, (gobject.TYPE_PYOBJECT,))
gobject.signal_new("prev_feed_in_showlist", show_list, gobject.SIGNAL_RUN_LAST,gobject.TYPE_NONE, (gobject.TYPE_PYOBJECT,))
gobject.signal_new("refresh_feed_done_slave", show_list, gobject.SIGNAL_RUN_LAST,gobject.TYPE_NONE, (gobject.TYPE_PYOBJECT,))
Ticker_0.4.5pre17.4.04/Help/ 0040755 0000766 0000766 00000000000 10037765321 013646 5 ustar rene rene Ticker_0.4.5pre17.4.04/Help/Note.txt 0100644 0000766 0000766 00000000066 10037765321 015313 0 ustar rene rene Achtung,
file rox/options.py wurde von mir 'gepatcht'
Ticker_0.4.5pre17.4.04/Help/README.txt 0100644 0000766 0000766 00000003142 10037765321 015341 0 ustar rene rene *********** Version 0.4.4 **************************
still waiting for a translation of Help.txt,
BIG JUMP:
*********** Update RETicker v 0.4.2 ***************
I didnt published any Versions between the others, but now
there is a new and revolutionary newsticker prog available ;)
New Features:
- command line parameters allow multiple instances with different
configurations
- age of news will be checked, therefore news will be cached and by checking
them the next time they will be compared to the news before, mightbe declared
as old
- lot of bugfixes and changes in code, but still no real code-cleanup done
Have fun.
Rene
*********** Update RETicker v 0.2.4 ***************
The short hack is going longer and its time to publish
the Programm: here it is. its still beta, and I'm working
on it. But its still useful, so use it ;)
*********** ROX-Ticker v 0.2.3 by RE ***************
its a short hack to display a newsticker as an applet,
it works for me since two days, mightbe it never gets
a version 1 ;)
it is based on the work of
"mihi" http://freshmeat.net/projects/ticker.py/
Installation:
this application needs ROX-Lib (>1.9.12)
but it now serves a patched Version of rox/options.py
untargz the Archive
Starting:
In ROX-Filer click on the icon or drag it to the panel
Usage:
left-click in label-field
starts the browser, shows the message
right-click (or middle-click) in label-field
show next message
left-click on image
starts the browser with news-site
right-click on image
gives you a nice menu
Options:
I hope they are self-declared
any suggestions to rene_ejury at gmx dot net
Rene Ejury
Ticker_0.4.5pre17.4.04/Help/Help_en.txt 0100644 0000766 0000766 00000016115 10037765321 015762 0 ustar rene rene RETicker v. 0.4.3
Hello, this is the introduction for the news ticker RETicker
Read carefully before having fun.
The:
I. installation
II. function
III. operation
IV. details of the options
I'm always grateful for notes and bug messages (this is my first python program) or offers of translations. Send any feeback to:
rene_ejury at gmx dot net
WARNING: This is a beta Version (0.4.5pre), so dont think all Things are going like they should. But on the other Hand, i believe its better (and more stable) than the last so called relase ;)
I. installation
The installation is quite simple, because the actual version of the RETicker already includes the necessary ROXLib (here as a light patch version 2.9.12). Just unpack the file to start. A python interpreter must be installed on your computer.
checking signature:
#>gpg Ticker_0.4.2.tgz.sig
untar the programm:
#>tar xfz Ticker_0.4.3.tgzThe 3 possibilities to start the program:
1. click on the Ticker_0.4.3 icon in the ROX-Filer
2. drag the symbol Ticker_0.4.3 onto the main panel from the ROX-Filer
3. start the program in a shell console
#>./AppRun --helpII. function
RETicker is a news ticker widget that downloads news headlines from selected sites, and displays them on the screen periodically.
The RETicker was written by me for the ROX-Desktop but should work on other windowmanagers. A friend asked me whether there was anything like knewsticker for ROX and so I decide to write one for him.
The RETicker shows news from xml formatted rss/rdf-newsfeeds one by one and also offers the possibility of viewing these in a browser. The RETicker contains an overview window which shows all cached news.
II.a. basics
The basic function consists in the reading of xml-formatted rss/rdf-newsfeeds and show the titles in a window or applet. A click on this opens the link in a browser.
II.b. news or olds?
A special feature of the RETicker is the possibility to define when news becomes old. There are different methods of defining this:
i) when fetched every news item is given a time stamp and considered old after a defined time is exceeded.
ii) news items are declared old after they have been shown a defined number of times.
iii) some newsfeeds that contain their own time stamps. These can also be used to define when they have gone out of date.
iv) news items are defined as old once viewed in a browser
The news items are cached locally so if you are offline cached news will still be eventually defined as old.
III. operationIII.a. Shell options
--help a short help
-v or -verbose verbose mode
--config x configuration x is of use,
if x not exiting,
creating config x
III.b. ticker options
The ticker can be used with mouse clicks:
left button on news opens news in a browser
right button on news goes to the next message
left button on icon opens news-site in a browser
right button on icon opens the menu
III.c. Overview window -options
All cached news items are shown in the overview window. Clicking with the left mouse button on these news items opens their associated web pages, clicking with the right button opens an info window, which contains more information on the message. Different colors stand for the different status of the messages (colors are adaptable):
new newsold Newscached news, be not shown on the ticker
The data shown follows:
fetched Don 11:16 [Don 10:04] [3x] revolutionary new Ticker
The first date shows, when the message was fetched, second (only with time stamp for the messages) indicates the time stamp of the message and [3x] stands here for the fact that the message was indicated 3 times in the ticker already.
Once the fetch time of the news is activated it is displayed in the overview window, showing how often the item has been displayed and, where available, the time stamp of the message.
IV. Single overview of the optionsIV.a. Sources
i) News-Age options
How is the News to age? This can be done by either setting the maximum number of minutes that the news item remains current or by setting the ammount of times the news items are displayed befor being considered old. (value 0 ignores the respective option)
ii) Edit News-Sources
This menu contains the main configuration of the News sources.
Buttons
Changes within this menu are only valid after the refresh button has been clicked. Further Buttons permits the adding and deleting of news sources.
source html-address
Here is the url address of the news sources (for example http://slashdot.org/slashdot.rdf)Important: You must activate (green) or deactivate (red)the left button for this source.
Icon html-address
This field contains the address Icons, as default in the favicon.ico file from the root directory of the SOURCE HTML address. The button is used to store this file in the local cache. Otherwise, if the file in the local cache is not found, it will be taken from the source URL.
max. Number of News to show in Ticker
This sets the maximum number of News items which can be shown on the Ticker.
[ticker provides date info]
If news the time stamp has, it can be used for the determination of the age of the News
Attention, do not forget, to activate the source by presses of the red ButtonsIV.b. Layout
i) Color of News-Label
Here you can change the color of the News text in the Ticker.
ii) Window Transparency
Here you can select a background image.
iii) Window-Size
The window size of the Tickers can be set here. It is important that the static value in the panel is set so as not to cover other applications.
IV.c. Overview-Window
i) Special Info
If selected, numerical data or text is placed in the overview window, displaying how often the messages have already been shown in the ticker.
ii) Layout
Here you can change the color of the different messages (new, old, cached)
IV.d. Image-ToolTip
The information shown above the Tickerscan icon can be activated/deactivated.
IV.e. Label-ToolTip
The information shown over the news message can be activated/deactivated.
IV.f. Fetch Options
i) Time options
Here you can determine the time the Ticker takes to move to the next Message and the time required until new News is fetched.
ii) Notify fetching-process
If none of these options are selected, news items are fetched in the background.
If ' text + SiteIcon 'is selected, a reference text with the Newstickers respective Icon appears.
If ' Fetchicon ' is selected a special Icon is shown when news is fetched- even if the other option is selected.
IV.g. diverse
i) default Cache-Directorys
These directory's are set automatically and contain the newscache and local copies of the Icons.
IV.g. Help
this help
I hope that this introduction is sufficient. Have Fun reading the news!
Rene
Ticker_0.4.5pre17.4.04/Help/Help_de.txt 0100644 0000766 0000766 00000021242 10037765321 015745 0 ustar rene rene RETicker v. 0.4.4
Hallo, dies ist die Anleitung zum Newsticker,
also aufmerksam lesen und dann viel Spass.
Die Anleitung gliedert sich in folgende Teile:
I. Installation
II. Funktionsweise
III. Bedienung
IV. Einzelbersicht ber die Optionen
Fr Hinweise und Fehlermeldungen (sorry, dies ist mein erstes Python-Programm) oder Angebote fr bersetzungen bin ich immer dankbar, bitte schickt diese an:
rene_ejury at gmx dot net
ACHTUNG: Dies ist eine alpha-Version (0.4.5pre), erwartet nicht zu wenig bugs, einige Funktionen sind in diesem Hilfetext nicht dokumentiert oder berhaupt noch nicht nutzbarI. Installation
Die Installation ist recht einfach, da die momentane Version des RETickers die ROXLib (http://rox.sourceforge.net, hier in einer leicht gepatchten Version 1.9.12 - siehe Unterverzeichnis rox) bereits mitbringt. Also, alles entpacken und los gehts. Ein Python-Interpreter sollte auf eurem Rechner installiert sein ;)
Signatur prfen:
#>gpg Ticker_0.4.2.tgz.sig
Programm entpacken:
#>tar xfz Ticker_0.4.3.tgzProgramm-Start:
a) Im ROX-Filer auf das Symbol Ticker_0.4.3 klicken
b) Das Symbol Ticker_0.4.3 aus dem ROX-Filer auf die Taskleiste ziehen
c) Das Programm in einer shell starten.
#>./AppRun --helpII. Funktionsweise
Der RETicker wurde von mir fr den ROX-Desktop geschrieben, funktioniert aber mglicherweise auch auf anderen Umgebungen. Auslser war die Frage eines Freundes, ob es so etwas wie knewsticker auch fr ROX gbe und meine Antwort, das kann mensch doch selbst schreiben.
Der RETicker zeigt news aus xml-formatierten rss/rdf-newsfeeds einzeln an und bietet ansonsten die Mglichkeit, sich diese im Browser anzuschauen. Auf zustzliche eigene Darstellungen wurde weitgehend verzichtet. Dennoch enthlt der RETicker ein bersichtsfenster, welches alle gecachten News aufzeigt.
II.a. Grundlagen
Die grundlegende Funktion besteht im Lesen von xml-fomatierten rss/rdf feeds und die Anzeige von deren Titeln in einem Fenster bzw. Applet. Ein Klick darauf ffnet den zugehrigen link im Browser, das ist eigentlich alles.
II.b. News oder Olds?
Das besondere an dem vorliegendem Ticker ist die Mglichkeit, nach Nutzerkriterien zu entscheiden, ob eine News alt oder neu ist. Zur Bestimmung der Aktualitt gibt es dabei verschiedene Mglichkeiten:
i) jede News wird beim Abholen mit einem Zeitstempel versehen und wenn eine bestimmte Zeit berschritten ist, wird diese news als alt erklrt.
ii) jede News wird mindestens x-mal angezeigt, danach wird sie als alt deklariert.
iii) einige Newsfeeds enthalten Zeitstempel der einzelnen Meldungen, diese knnen ebenso genutzt werden, um festzustellen, dass diese veraltet sind.
iv) wird eine News zur Anzeige im Browser angeklickt, wird diese danach als alt gewertet.
Da die news lokal gecacht werden, kann dieses 'Altern' der news auch bei Unterbrechungen der Internetverbindung (zum Beispiel ber Nacht) erfolgen.
III. BedienungIII.a. Shell-Optionen
--help gibt eine kurze Hilfe aus
-v oder --verbose gibt Meldungen aus
--config X nutzt Configuration X,
wenn X nicht vorhanden,
wird X angelegt
III.b. Ticker-Optionen
Der Ticker kann mit Mausklicks bedient werden.
linke Taste auf Newstext: ffne Meldung in Browser
rechte Taste auf Newstext: gehe zur nchsten Meldung
linke Taste auf Icon: ffne News-Site im Browser
rechte Taste auf Icon: ffne Menu
III.c. bersichts-Optionen
Im bersichtsfenster werden alle gecachten News angezeigt. Ein Klick mit der linken Taste auf diese News ffnet die zugehrigen Webseiten, ein Klick mit der rechten Taste ffnet ein Infofenster, welches weitergehende Informationen zur Nachricht enthlt. Dabei stehen verschiedene Farben fr den unterschiedlichen Status der Nachrichten (Farben sind anpassbar):
neue Newsalte NewsNews im Cache, werden nicht im Ticker angezeigt
Wenn aktiviert, wird im bersichtsfenster zustzlich die Abholzeit der News, wie oft diese bereits angezeigt wurde und wenn vorhanden der Zeitstempel der Nachricht vermerkt.
Die angezeigten Daten sind wie folgt zu interpetieren:
fetched Don 11:16 [Don 10:04] [3x] revolutionary new Ticker
Die erste Zeitangabe zeigt, wann die message abgeholt wurde, die zweite (die nur bei Tickern mit Zeitstempel fr die Nachrichten angezeigt wird) zeigt den Zeitstempel der Nachricht an und das [3x] steht hier dafr, dass diese Nachricht bereits 3 mal im Ticker angezeigt wurde.
IV. Einzelbersicht ber die OptionenIV.a. Sources
i) News-Age options
Wie sollen die News altern? Einstellung des maximalen Alters nach dem Abholen oder der maximalen Anzahl von Anzeigen der Einzelmeldung im Ticker (die Einstellung 0 ignoriert die jeweilige Option)
ii) Edit News-Sources
Dieser Bereich enthlt die Hauptkonfiguration der News-Quellen.
Buttons
nderungen in diesem Bereich werden teilweise erst bei einem 'refresh' der News-Quellen wirksam, dafr existiert ein besonderer Button. Weitere Buttons erlauben das hinzufgen und das Lschen von News-Quellen.
source html-adress
Hier wird die html-adresse des Newstickers angegeben (bspw. http://de.indymedia.org/RSS/newswire.xml) Der nebenstehende runde Button erlaubt, diese Quelle zu aktivieren (grn) bzw. zu deaktivieren (rot).
Icon html-adress
Dieses Feld enthlt die Adresse eines Icons, als default wird die Datei favicon.ico im root-Verzeichis der source-html-adresse gewhlt. Der nebenstehende Button erlaubt das gezielte Holen dieser Datei in den lokalen Cache (Dies erfolgt sonst, wenn die Datei im lokalen Cache nicht gefunden wird)
local Icon (or cache adress)
Diese Datei wird als Icon fr die Darstellung der News dieser Quelle genutzt. Der default-Pfad weist in das lokale Cachdir (siehe Option diverse), es kann jedoch jede beliebige lokale Datei gewhlt werden.
max. Number of News to show in Ticker
Dies ist die Zahl der News, die im Ticker angezeigt wird. Im Cache werden mindestens soviele News, wie generell von der Quelle zur Verfgung stehen, vorgehalten.
[ticker provides date info]
Wenn beim Abholen von News festgestellt wurde, dass die Nachrichten des Tickers einen einzelnen Timestamp enthalten, knnen diese Timestamps hier fr den jeweiligen Ticker zur Bestimmung des maximalen Alters einer News genutzt werden.
Achtung, nicht vergessen, die Quelle durch Pressen des roten Buttons zu aktivieren IV.b. Layout
i) Color of News-Label
Hier kann die Farbe des News-Textes im Ticker gendert werden
ii) Window Transparency
Um das Tickerfenster 'durchsichtig' zu machen, muss hier neben der Aktivierung der entsprechenden Option auch das Hintergrundbild in Bildschirmgrsse angegeben werden.
iii) Window-Size
Einstellung der Fenstergrsse des Tickers (-1 steht fr dynamische Anpassung der Grsse). Die absolute Festlegung ist beispielsweise sinvoll im Panel, um andere Starter etc. nicht zu berdecken.
IV.c. Overview-Window
i) Special Info
Wenn gewhlt, werden im bersichtsfenster Zeitangaben bzw. Angaben, wie oft die Nachrichten bereits gezeigt wurden und/oder bergreifende Informationen angezeigt.
ii) Layout
Hier knnen die Farben der unterschiedlichen Nachrichten (neu, alt, gecacht) eingestellt werden.
IV.d. Image-ToolTip
Die Angaben, die im Tooltip ber dem Icon des Tickers gezeigt werden, knnen aktiviert/deaktiviert werden.
IV.e. Label-ToolTip
Die Angaben, die im Tooltip ber dem Label des Tickers gezeigt werden, knnen aktiviert/deaktiviert werden.
IV.f. Fetch Options
i) Time options
Die Zeiten, nach denen im Ticker automatisch zur nchsten News gewechselt wird, knnen hier ebenso eingestellt werden, wie die zwischen zwei Versuchen, neue news vom Server zu empfangen.
ii) Notify fetching-process
Wenn keine dieser Optionen gewhlt ist, erfolgt die berprfung der Server auf neue News im Hintergrund. Ist 'Text + SiteIcon' gewhlt, erscheint ein Hinweistext mit dem jeweiligen Icon des Newstickers. Wenn 'Fetchicon' gewhlt wird, wird bei Holen neuer news ein spezielles Icon angezeigt - auch wenn die andere Option ausgewhlt ist.
IV.g. diverse
i) Browser to start on left-click
Hier knnen der Browser (bspw. opera) und mglicherweise sinnvolle Optionen (bspw. -newpage) angegeben werden.
ii) default Cache-Directorys
Diese Verzeichnisse werden automatisch gesetzt und enthalten den Newscache sowie lokale Kopien der Icons.
IV.g. Help
Diese Hilfe ;)
Ich hoffe, dass die Erklrungen ausreichend waren, viel Spass bei newslesen,
Rene
Ticker_0.4.5pre17.4.04/news.py 0100644 0000766 0000766 00000035775 10037765321 014322 0 ustar rene rene #!/usr/bin/env python
#########################################################
# RETicker v. 0.4.5pre
# a programm to display xml-formatted rss/rdf-feeds in
# a one line display
#########################################################
# please read Help.txt for contact information
#########################################################
# This file contains the classes storing and showing #
# the actual news #
#########################################################
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 xml.dom import minidom
from xml.dom.minidom import Document
import xml.sax
import os
import time
import gobject
import tool
import feed
HTTP_TIMEOUT = 20 ### This is the timeout for http-connections in seconds
### cause there are started as spezial Tasks by fork()
### there is no blocking while trying to reach the server
"""--------------------------------------------------------------------------------------------"""
"""------------------------------ news_ - The Class which holds the news ----------------------"""
"""--------------------------------------------------------------------------------------------"""
### The news class is holding a list of feeds where the messages are stored. Additionally it
### holds some methods to retrieve the news
### The Class contains 5 main sections
### 1. Methods to get news structure parallel to Options.sources
### 2. common Methods
### 3. Import of xml-data into lower structures (feeds, msgs) used by 4. and 5.
### 4. Methods for xml in- or export (reading and saving news to cache)
### 5. Methods to refresh the news and the icons
### Warning: Cause module news contains a signal connection to a signal from __Options, it will
### not be removed from memory while removing any other refrence to this instance
class news(gobject.GObject):
def __init__(self, Options, box):
gobject.GObject.__init__(self)
self.__Options = Options
self.__box = box # this is needed for directig the output
self.feeds = [] # here are the news stored
self.__refresh_possible = True # to block refresh-requests
self.__manual_refresh_possible = True # to block manual refresh-requests
self.__refreshtimeout = None # pointer to the refresh-timeout
self.__lastrefresh = time.time() # last_refresh_time
self.Cons = tool.Connections()
self.Cons.connect(self.__Options.sources, "source_added", self.add_source)
# first init the structure by sources, but dont refresh them (cause they willl blocking each other)
for source in self.__Options.sources.sources:
self.add_source(None, source, False)
tasks.Task(self.import_xml()) # then fill the struture from cache
def disconnect(self, dummy=None): self.Cons.disconnect_all()
"""----------------------------------------------------------------------------------"""
""" 1. Methods to get news structure parallel to Options.sources """
"""----------------------------------------------------------------------------------"""
### create for a specific source a (empty) feed and add this to self.feeds[]
def add_source(self, dummy, source, refresh = True):
fd = feed.feed(self.__Options, source)
fd.feed_nr = len(self.feeds)
self.Cons.connect(source, "source_killed", self.kill_feed)
self.feeds.append(fd)
if refresh:
print "####### Try to refresh new feed"
tasks.Task(self.refresh_feed(fd))
### remove a feed (or all feeds, but there should be only one) with a given
### ticker (used as id) from self.feeds
def kill_feed(self, source, ticker):
self.Cons.disconnect(source, "source_killed")
i = 0
while i < len(self.feeds):
if ticker == self.feeds[i].get_ticker(): self.feeds.pop(i)
else: i += 1
self.emit("feed_killed", i)
"""----------------------------------------------------------------------------------"""
""" 2. common Methods """
"""----------------------------------------------------------------------------------"""
### return a feed by the given ticker
def get_by_ticker(self, ticker):
for fd in self.feeds:
if ticker == fd.get_ticker(): return fd
return None
### stat returns some Information about the news-feeds, like number of feeds at all
### and number of active feeds. Includes Information abaout Messages
def stat(self): return self.__str__()
def __str__(self):
stat = { \
'all_feed_count' : len(self.feeds) , \
'act_feed_count' : 0, \
'all_msg_count' : 0 , \
'act_msg_count' : 0 , \
'new_msg_count' : 0 , \
}
for fd in self.feeds: stat = fd.stat(stat)
return "feeds: " + str(stat['all_feed_count']) + "[all]/" + \
str(stat['act_feed_count']) + "[active] " + \
"msg:" + str(stat['all_msg_count']) + "[all]/" + \
str(stat['act_msg_count']) + "[active]/" + \
str(stat['new_msg_count']) + "[new]"
"""----------------------------------------------------------------------------------"""
""" 3. Import of xml-data into lower structures (feeds, msgs) used by 4. and 5. """
"""----------------------------------------------------------------------------------"""
### read xml-formatted data. First has to be decided, which kind of feed-format
### the xml-doc is (it had to be changed in a more standard way)
def read_xml(self, xmldoc, ticker = None):
### there are different types of feed-protocols possible
### 'news' is the cache-format, fallback is a try to get the rest
types = ['rdf:RDF', 'rss', 'news', 'fallback']
for type in types:
news_feeds = xmldoc.getElementsByTagName(type)
if len(news_feeds) > 0: break
if type == 'news':
feeds = xmldoc.getElementsByTagName('feed')
for node in feeds: self.read_xml_childNode(node, type, ticker)
elif type <> 'fallback':
for node in news_feeds: self.read_xml_childNode(node, type, ticker)
else: self.read_xml_childNode(xmldoc, type, ticker)
### convert xml_data into accessible feed information; if ticker is not given, read ticker
### information from xmldoc (happens if read from cache)
def read_xml_childNode(self, xmldoc, type, ticker = None):
### ticker - field to recognize the feed in sources - cached data contains ticker
if type == 'news':
ticker = tool.getdata(xmldoc, "ticker") # This is used to recognize the feed
fd = self.get_by_ticker(ticker)
if not(fd): return ### feed not found in sources, might happen if reading cached data
fd._from_xml(xmldoc, type, self.__box)
### calculate the time till next refresh (of all sources) should happen
def time_to_next_refresh(self):
if self.__refreshtimeout <> None:
return self.__Options.refresh_time.int_value - \
(time.time() - self.__lastrefresh)/60
else: return None
"""----------------------------------------------------------------------------------"""
""" 4. Methods for xml in- or export (reading and saving news to cache) """
"""----------------------------------------------------------------------------------"""
### export actual news feeds in xml-file
def export_xml(self):
if not self.__Options.xml_cache.value: return # Saving is disabled
doc = Document()
root = doc.createElement('news')
doc.appendChild(root)
for i in self.feeds: i._to_xml(root)
file = open(self.__Options.xml_cache.value, 'w')
doc.writexml(file)
file.close()
print "Export xml done (" + self.stat() + ")"
### import news information from previously saved xml-file (usually started as
### Tasks) if done, emit signal and start_refresh of news
def import_xml(self):
if self.__Options.v: print "import cached news ..."
if not os.path.isfile(self.__Options.xml_cache.value):
print "No cached news found - initialising"
self.emit("cached_news_read"); self.start_refresh(); return
self.__box.status("import cached news ...", g.STOCK_CONVERT)
yield None
try: doc=minidom.parse(self.__Options.xml_cache.value)
except xml.sax.SAXParseException: ### only happens if saving was interrupted
self.__box.status("parse error in cached news ...", g.STOCK_CANCEL)
rox.alert("parse error in cached news file:\n" + self.__Options.xml_cache.value)
yield tasks.TimeoutBlocker(2);
self.emit("cached_news_read"); self.start_refresh(); return
#root = doc.documentElement
self.read_xml(doc)
if self.__Options.v: print "Cached news imported (" + self.stat() + ")"
print "Cached news imported (" + self.stat() + ")"
self.emit("cached_news_read")
self.start_refresh();
"""----------------------------------------------------------------------------------"""
""" 5. Methods to refresh the news and the icons """
"""----------------------------------------------------------------------------------"""
### two methods to add and remove the refresh-timeouts
def add_refresh(self):
if self.__refreshtimeout == None:
#print "refresh_timeout added"
self.__refreshtimeout = g.timeout_add(60000*self.__Options.refresh_time.int_value, self.start_refresh)
def rem_refresh(self):
if self.__refreshtimeout <> None:
#print "refresh_timeout removed"
g.timeout_remove(self.__refreshtimeout);
self.__refreshtimeout = None
### start the tasks to refetch the icons and the news feeds
def start_refresh(self, dumy = None):
if self.__Options.v: print "refresh Ticker"
#tasks.Task(self.get_icons_for_all_feeds())
tasks.Task(self.get_news_for_all_feeds())
self.__lastrefresh = time.time()
#~ ### if the iconc still in cache this method does nothing. if not they will be fetched.
#~ def get_icons_for_all_feeds(self):
#~ for feed in self.feeds:
#~ ### catch icon if feed is active and icon is not in cache
#~ if feed.get_active() == 1 and not(os.path.isfile(feed.get_iconcache())):
#~ icon = feed.get_icon()
#~ self.__box.status("Getting Icon from " + icon, g.STOCK_JUMP_TO)
#~ yield None
#~ t = tool.urlretrieve(icon, feed.get_iconcache())
#~ ### wait a little bit till icon might be cached locally
#~ for tick in range (0, HTTP_TIMEOUT):
#~ if t.Done() == 1: break
#~ yield tasks.TimeoutBlocker(1);
#~ if t.Status() == None: t.Kill()
#~ #### now check if file is here
#~ if not(os.path.isfile(feed.get_iconcache())):
#~ iconcache = rox.app_dir+"/AppIcon.xpm"
#~ self.__box.status("Icon at " + icon + " not retrieved",g.STOCK_CANCEL)
#~ yield tasks.TimeoutBlocker(2)
### for every feed in cache try to fetch the news
def get_news_for_all_feeds(self):
### to prevent double refreshings, there is a check if (regularily)
### refreshing is still going on
if self.__refresh_possible:
self.__refresh_possible = False
else:
self.__box.status("New refresh request blocked, refresh still going on", g.STOCK_CANCEL)
return
yield None
### remove timeouts cause refreshing may take to long (shouldnt happen)
self.rem_refresh() ### timeout is once again added after completing check_feed_task
for feed in self.feeds:
if feed.get_active() == 1:
ticker = feed.get_ticker()
self.__box.status("Checking " + ticker + " ...", g.STOCK_CONVERT, feed.get_iconcache())
yield None
cache_file = tool.tmp_name(self.__Options.icon_cache_dir.value, ticker)
t = tool.urlretrieve(ticker, cache_file)
### wait a little bit till feed might be cached locally
for tick in range (0, HTTP_TIMEOUT):
if t.Done() == 1: break
yield tasks.TimeoutBlocker(1);
if t.Status() == None: t.Kill()
### now check if file is here
try:
cached_feed = open(cache_file, 'r');
except (IOError, EOFError):
print "could not open url " + ticker
self.__box.status("Could not open url: " + ticker + " ...", g.STOCK_CANCEL, feed.get_iconcache())
yield tasks.TimeoutBlocker(2); self.__refresh_possible = True; continue
try:
xmldoc = minidom.parse(cached_feed)
except (xml.parsers.expat.ExpatError, xml.sax.SAXParseException):
self.__box.status("No Valid xml found at " + ticker + " ...", g.STOCK_CANCEL, feed.get_iconcache())
yield tasks.TimeoutBlocker(2);
del cached_feed; os.remove(cache_file) ### remove cache_file, no longer needed
self.__refresh_possible = True; continue
yield None
### read the contents of the locally cached news-feed
self.read_xml(xmldoc, ticker)
self.emit("refresh_feed_done", feed)
del cached_feed; os.remove(cache_file) ### remove cache_file, no longer needed
elif self.__Options.v: print str(feed) + "not refreshed cause not active"
print "Refresh done (" + self.stat() +")"
yield None
### Data refreshed, save it (its better to do it now then loose it later ;)
### It is also possible to save it only while killing the prog, maybe its
### a good place to do a consistency check ?
self.export_xml()
### allow refresh again and set timer
self.__refresh_possible = True
self.add_refresh()
### this is nearly the same like the method above, the difference is that this method
### refreshes only one feed
def refresh_feed(self, feed):
### to prevent double refreshings, there is a check if (regularily)
### refreshing is still going on
if self.__manual_refresh_possible:
self.__manual_refresh_possible = False
else: return
ticker = feed.get_ticker()
self.__box.status("Checking " + ticker + " ...", g.STOCK_CONVERT, feed.get_iconcache())
yield None
cache_file = tool.tmp_name(self.__Options.icon_cache_dir.value, ticker) + "_manually"
prog = tool.Win_ProgBar()
prog.start_pulse()
t = tool.urlretrieve(ticker, cache_file)
### wait a little bit till feed might be cached locally
for tick in range (0, HTTP_TIMEOUT):
if t.Done() == 1: break
yield tasks.TimeoutBlocker(1);
if t.Status() == None: t.Kill()
prog.rem()
### now check if file is here
try:
cached_feed = open(cache_file, 'r');
xmldoc = minidom.parse(cached_feed)
except (IOError, EOFError):
rox.alert("could not open url :\n" + ticker)
self.__box.status("Could not open url: " + ticker + " ...", g.STOCK_CANCEL, feed.get_iconcache())
yield tasks.TimeoutBlocker(2); self.__manual_refresh_possible = True; return
except (xml.parsers.expat.ExpatError, xml.sax.SAXParseException):
rox.alert("error in parsing feed from :\n" + ticker)
self.__box.status("No Valid xml found at " + ticker + " ...", g.STOCK_CANCEL, feed.get_iconcache())
yield tasks.TimeoutBlocker(2);
del cached_feed; os.remove(cache_file) ### remove cache_file, no longer needed
self.__manual_refresh_possible = True; return
yield None
### read the contents of the locally cached news-feed
self.read_xml(xmldoc, ticker)
self.emit("refresh_feed_done", feed)
del cached_feed; os.remove(cache_file) ### remove cache_file, no longer needed
### allow manual refresh again
self.__manual_refresh_possible = True
gobject.signal_new("feed_killed", news, gobject.SIGNAL_RUN_LAST,gobject.TYPE_NONE, (gobject.TYPE_PYOBJECT,))
gobject.signal_new("refresh_feed_done", news, gobject.SIGNAL_RUN_LAST,gobject.TYPE_NONE, (gobject.TYPE_PYOBJECT,))
gobject.signal_new("cached_news_read", news, gobject.SIGNAL_RUN_LAST,gobject.TYPE_NONE, ())
Ticker_0.4.5pre17.4.04/ticker_menu.py 0100644 0000766 0000766 00000004334 10037765321 015636 0 ustar rene rene #!/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 applet, g, Menu, InfoWin, tasks, ButtonMixed, choices, options
from rox.Menu import Menu, set_save_name
from Options import *
from rox import app_options
"""
_options_box = None
v = 0
def open_menu(widget, event, position_menu):
menu.popup(widget, event, position_menu)
"""
class menu(gobject.GObject, Menu):
def __init__(self, Options, Window):
gobject.GObject.__init__(self)
self.__Options = Options
set_save_name(self.__Options.program)
Menu.__init__(self, 'main', [
('/Quit', 'quit', '', '', g.STOCK_QUIT),
('/Help', 'help', '', '', g.STOCK_HELP),
('/Info', 'info', '', '', g.STOCK_DIALOG_INFO),
('/Show Window', 'show_window', '', '', g.STOCK_INDEX),
('/Options', 'show_options', '', '', g.STOCK_PREFERENCES),
('/Refresh', 'refresh_ticker', '', '', g.STOCK_REFRESH),
('/Next Msg', 'update_ticker', '', '', g.STOCK_GO_FORWARD)
])
self.attach(Window, self)
def quit(self): self.emit("m_quit")
def help(self): self.emit("m_help")
def info(self): self.emit("m_info")
def show_window(self): self.emit("m_show_window")
def show_options(self): self.emit("m_show_options")
def refresh_ticker(self): self.emit("m_refresh_ticker")
def update_ticker(self): self.emit("m_update_ticker")
#def help(self):
#Help = g.Window()
#HelpTab = Help_Container()
#Help.add(HelpTab)
#Help.show()
gobject.signal_new("m_quit", menu, gobject.SIGNAL_RUN_LAST,gobject.TYPE_NONE, ())
gobject.signal_new("m_help", menu, gobject.SIGNAL_RUN_LAST,gobject.TYPE_NONE, ())
gobject.signal_new("m_info", menu, gobject.SIGNAL_RUN_LAST,gobject.TYPE_NONE, ())
gobject.signal_new("m_show_window", menu, gobject.SIGNAL_RUN_LAST,gobject.TYPE_NONE, ())
gobject.signal_new("m_show_options", menu, gobject.SIGNAL_RUN_LAST,gobject.TYPE_NONE, ())
gobject.signal_new("m_refresh_ticker", menu, gobject.SIGNAL_RUN_LAST,gobject.TYPE_NONE, ())
gobject.signal_new("m_update_ticker", menu, gobject.SIGNAL_RUN_LAST,gobject.TYPE_NONE, ())
Ticker_0.4.5pre17.4.04/gethttp.py 0100644 0000766 0000766 00000002324 10040216467 015001 0 ustar rene rene #!/usr/bin/env python
#########################################################
# RETicker v. 0.4.5pre
# a programm to display xml-formatted rss/rdf-feeds in
# a one line display
#########################################################
# please read Help.txt for contact information
#########################################################
# This file contains the classes storing and showing #
# the actual news #
#########################################################
"""--------------------------------------------------------------------------------------------"""
"""------------------------------ The Funtion to fetch http data ------------------------------"""
"""----- it is started after a fork() as a special task to prevent blocking the Ticker --------"""
""" it will be called from tool.py with 4 arguments: url_address, filename, use_proxy, proxy_address """
import urllib
import sys
import os
proxy = sys.argv[4]
if proxy.find("://") == -1: proxy = "http://" + proxy
if sys.argv[3] == "True": os.environ["http_proxy"]=proxy
else: os.environ["http_proxy"]=""
try: urllib.urlretrieve( sys.argv[ 1 ], sys.argv[ 2 ] )
except (IOError, EOFError): sys.exit(1)
Ticker_0.4.5pre17.4.04/images/ 0040755 0000766 0000766 00000000000 10037765321 014223 5 ustar rene rene Ticker_0.4.5pre17.4.04/images/label_tip_10.png 0100644 0000766 0000766 00000000225 10037765321 017160 0 ustar rene rene PNG
IHDR ) ]^ pHYs ~ tIME
3cVݘ 4IDATx1 ( 4 d HJΐzYtԔI S71K IENDB` Ticker_0.4.5pre17.4.04/images/label_tip_1.png 0100644 0000766 0000766 00000000225 10037765321 017100 0 ustar rene rene PNG
IHDR ) ]^ pHYs ~ tIME
3::? 4IDATx1 ( 4 d HJΐzYtԔI S71K IENDB` Ticker_0.4.5pre17.4.04/images/label_tip_2.png 0100644 0000766 0000766 00000000332 10037765321 017100 0 ustar rene rene PNG
IHDR )
zA pHYs ~ tIME
yIDATxٱPE1 T Cz#0 (>,Lm@367ڦ
]Cz)A C{= d 8Mr>]w3? O5s߃A C{ q IENDB` Ticker_0.4.5pre17.4.04/images/label_tip_3.png 0100644 0000766 0000766 00000004451 10037765321 017107 0 ustar rene rene PNG
IHDR ) db=b pHYs ~ tIME
i IDATxoHyǿ{b_(RHL\&BG{`BMK5-Dʵfkreפ]ՃI6v;uM]\b=1˝pM6/^Mf4v>ߟg<- Kl!U:TTP{}'ܛA( tݝ϶;e``6Fv\JYUT5L6a3Qf]tu)Y$ '- 7#
TE9Y{?4aYM6J\Mڰ}2pEa4]~oc Nٔ Tzkyq弼TouF^fHUCOjW/_JCA| t}S< \~}5-9=#0n,ǹvT%/<8F&S}2CQxy-[bs.h4Օg(y<4E 2zk pw / h5Y4!vwgA@+g# ~ Z܊ٽY
HOBWݽaKȖ=:F&c~,g }yHCua {t)q rυd*q tQb7QFS]IQ!mfOš)XrѸ8F1 מ 4M.gvwxfC57&f{@jxeaL[ gWQx"mLvu?x?2#d^#o5& $ A|%USW#h6 ̇1\(
;,nwvunTFl (O^ϯeP*e4 7zx>&dh6YӨetFy%7"XL ? x#_STl%40d -pv Gփ6?{vR߹ i:&1bD5:>r^<W~TehfGw檊$4u `/. -lt)V_A[w K\ȷFb](r ޕ ÿ5oΜ ǪcNB0w⭜MCWS
y*iq!PW,%RnhaMF_ßҏ*'kO? ~Ki&pe,s&Qd[Qgr WP XF;gs.SGya}%t "䩸^ 0ٽS 'h*&7iBm&.-ˑ)B1Et!k rJ{ZWxKIƵlT߀ _=ſݰp?25>b,KĨlvuO$;L?gfh8+g 0u{E1%bT u6bK m#JyPDcyļ!** {$***Y^Ǒ!1^o!Hwl%Q9ȫDE'op8
S"8-- @ZEEE!{ \~_.J<+!VO@m٥J{Nv O".a.z][O{ OQsC**+ҹgj
0{
3CQ|* >8pK197D[~ƔlTQ6Թ= @_% IENDB` Ticker_0.4.5pre17.4.04/images/label_tip_4.png 0100644 0000766 0000766 00000000332 10037765321 017102 0 ustar rene rene PNG
IHDR )
zA pHYs ~ tIME
!m;3 yIDATxٱPE1 T Cz#0 (>,Lm@367ڦ
]Cz)A C{= d 8Mr>]w3? O5s߃A C{ q IENDB` Ticker_0.4.5pre17.4.04/images/label_tip_5.png 0100644 0000766 0000766 00000007067 10037765321 017117 0 ustar rene rene PNG
IHDR ) 4 YY$ pHYs ~ tIME
!;5S
IDATxmH[YǟYp~*ELJoq&8&Bol&jhF&aGұa֤ ua%QSK
ۭ ;v0+MJvK͇\|9ܗhbz~s<9'o MP(Hu}ϊٛ_6M_tzNQ ,1%^Foo}ҿJ8:gd?lZ [BJ6Q_<6'KnO׳Υ}((2wTmRE =.k&Đx1t>,] ,ݘ kC'>+~d**nGqyEO2 zN֞xȠsP/6v10 SQ< xN:j*: o _.P)r{ja ON3贶OS.
/{܍E\hg67Yu:d53`m:O!!xOO[27a1w1+=iyKq n,3un.r{q#gQNB H RJ93B.SayxL? T^|㛄+X Ӻ=)GTqocSwcyզ=]2in E6
@u}룦gg3 K/CƆZ&NG(P)-⤘Xh`'0:fמ!Eɳu]wwԚ'KY)jRE2ۈw S]~Qk k~5vcmfI؊˖IuQ?VߌVmt'_m!ȂFn,_J'^s2 c x*
c⏒ַY)f" L
KqG$xf{t= :Hp" H9SgFn/ #mQM>MIۅg>=QYwxd)| J@bx5)Y[X س˘O
5VJuRzxo_B?
G RJzͩIW`H4q a^Lz5eZ
5Ud
ЉE zr 0k3;<2my{0J-ai9nm1Ŗ
;j3 6*
DOVJSſEHLR>EJ@L&L?? q9Hd]_ߺ(BJf*LE>KI8{mOU9rv[[Sezhi1
L"c&y]' sa[ZNrCU%\ lN}8 > n00ܯMw\}rJ9iq{Bc!~@|%j܈ZCЄ w٦<,ȖIuQ 8᧱/4~ZXIOYlr=#J a ^2`3 L'>b?}(yI{ ܊?|`>(ʾ-
}Iųz;LW|L_O䭵^~W|zQTL`)i_6 |L_Od=saiqw 0=gnOW QTf!W)$74W/}6|Qsѹȭ&gu$m| ?8C"j VKgB1ʽxB8x|Sr
JAZTZ{1 h4 R>P}|d/VSiӏ_N:x_bljMv'4~!: v
ܟf*Mϯr }L}
;m_@ W D,Uc!Tױo'uE# gU׀Ir7A45lcB"w~:,xbv>XZ#q!5RSTN{}2(vסi^>.a$a= F55/^\Q "H%h5g)F[IObG]ګSDR?k0hQ$Vzd9v^~y #q!5R&. VR'SJbw=fu| zF.yA~zS-yhn*UcC܍ 0}1 9p a
?}%+ b gw
CųU"sFyf5 #Ub,XE"vףiVQ>.#+ -DΠzS| acYc+t{zf)WnfB)(uiQ8K 8w Kj`$&RD/^1Tm7P[cǫw '= 9F:;ӗG^jʐ2'y w:ϦEY0"RGvTf陞_缡?̵rnK FOV vȻLH/#7?WoQ)Ff @ #;5 4 z`o!JNShsQulᥨ)CsgoF[4BlR|ޣ_
=B)Q(Ł=
8гGz(@ R ٣PC!$~AP
Kũ/(Ja)9M:P]NQ(Ł=
8 ,CG| IENDB` Ticker_0.4.5pre17.4.04/images/label_tip_6.png 0100644 0000766 0000766 00000000256 10037765321 017111 0 ustar rene rene PNG
IHDR )
zA pHYs ~ tIME
"'
p MIDATxA@P G$W @-L63Ϻq^{ ?=hxރ=hxރ=hxރ tR+ IENDB` Ticker_0.4.5pre17.4.04/images/label_tip_7.png 0100644 0000766 0000766 00000002714 10037765321 017113 0 ustar rene rene PNG
IHDR )
zA pHYs ~ tIME
# kIDATxQHw >Y|"B/9N9 5Gb$C
b۬IU I]#meKaΤM0L+4a <$G
|1 oF֑75+Ѳ≲VM'2}z[].Nˢ#y3VŕPY Gqw^PiM荒 ?zSؓbC5!JH
DP;L 0`RmbJ=mǘ;EX?q73n6],O A{hG @1⺰ԮFt17q BH1[O @?2XU"Ī ^ "n6ٽ̸;x ۩ fݐ7'7q8"ڎ1QgW vS xYw)2ENP,(x}! _Bz_S֯J[\y( vnD
bTCGt#zz*oβ+w. he:Ľ~xFt' YHu >~\ƛp ލatwÔp~$M^_X+|? 7ᕨ57Ks. 'Sflm,I!-R$o!wޟ,NQclo,7q`_P0,.+ vm%RW1j aS$ 8_wsJj
s d! A{ 010$?lgܬ_עFҤi8mrX? z (ٓ? //LE o= HLCVU
iR)Bի!IQޯJ[]VJzMP*FS ^sr kx$ 7 D㛴t/'tDgׇV\0!~'MvldvsƢ!?v^l'Xq,&! 0C/1w)DuIYmk7$|[T)P\Fy/rQxdOvO^bj8m H3v|S]ݢziXc.F
Y w҃CH0g<4 f#AiǨc5W~L ݒ}Y̦5jxq] *SH[(W.h_Ōi/r9m_?(B}!/.$fcPk!:ud:=a6JBp%2{UGjrϽ*NNh*֑=-, IENDB` Ticker_0.4.5pre17.4.04/images/label_tip_8.png 0100644 0000766 0000766 00000002017 10037765321 017110 0 ustar rene rene PNG
IHDR )
zA pHYs ~ tIME
#50 IDATxAhG_J4(ZD
RYk,bEd E`:$!r-X9֡$k](XV![`b" =簇 ֖כ]vNOyǼ 10 w he v9=gvfkrְwPi]Cu *6JB s25+ ȠBWE"W7R+
> xǷ!BT* džKæÂ'"(cB-*kh
ྼ`iDv9c)92u;WKeMd,~+`a0,2 h! X+H NB 3t#M*T_Zc! B%A6ɜ#59[\/: ߍQ:\f S hD蕖NyCW?Yz<&rIwSLXn|+'F^[O|gvnY|mäʋ}Yq e j멩zN }7tUIir#tfD۠\WC|gk !03h:IuDuMRn. ENjozjH Ƒc`=Zc q<
#J! IENDB` Ticker_0.4.5pre17.4.04/images/label_tip_9.png 0100644 0000766 0000766 00000000221 10037765321 017104 0 ustar rene rene PNG
IHDR ) ]^ pHYs ~ tIME
$8-i 0IDATxcd``xh (@H·i0
FyoQ0
FH Ud 6 IENDB` Ticker_0.4.5pre17.4.04/images/image_tip_1.png 0100644 0000766 0000766 00000000233 10037765321 017102 0 ustar rene rene PNG
IHDR H pHYs ~ tIME
9"#O :IDATxԱ p&0k"X"oTIF.`CR uI19IO [ IENDB` Ticker_0.4.5pre17.4.04/images/image_tip_2.png 0100644 0000766 0000766 00000000341 10037765321 017103 0 ustar rene rene PNG
IHDR
Gu pHYs ~ tIME
:
IDATxڡ@? 過E-dB A
DfчxOZq풼) U%$@I 8 %q J ˇ:gݳn2 ;_ΧFs 9 ?P$@
(G(H IENDB` Ticker_0.4.5pre17.4.04/images/image_tip_3.png 0100644 0000766 0000766 00000002500 10037765321 017103 0 ustar rene rene PNG
IHDR
Gu pHYs ~ tIME
:!aMv IDATx_H[W ? >܀W!"F,4:fJ MBk,,ڂ&Ʉ5e5+60Qhk|MaRئu0)EJ+c>-]=Ust-~.{~r9w@CCCU^{&444^N6,9ǒ5K6Vl+קEHMcj v̕U:y% I"PՊ ySUcQڙ
+OnW91²@5r ,.o XTt`? ys8Xַug^]cHL&T4ݰ5>vXƖBB# we䠡}!Nbc :*Qb+lX644W1 U IENDB` Ticker_0.4.5pre17.4.04/images/image_tip_4.png 0100644 0000766 0000766 00000000341 10037765321 017105 0 ustar rene rene PNG
IHDR
Gu pHYs ~ tIME
::b IDATxڡ@? 過E-dB A
DfчxOZq풼) U%$@I 8 %q J ˇ:gݳn2 ;_ΧFs 9 ?P$@
(G(H IENDB` Ticker_0.4.5pre17.4.04/images/image_tip_5.png 0100644 0000766 0000766 00000004435 10037765321 017116 0 ustar rene rene PNG
IHDR V bKGD pHYs d_ tIME 5R^ IDATx_H\ ?[|B FɃJHd'n!]؉]vY ɸ[je;1yX@5Р)-5ZqVPB!l! h fgp{g K|߹5 6666)B)Na{Xh b+W-!5ĵ}hywOn7Jh״:7UwpۢI%:mRwS5.jƯEfP
GU hB jO;Q6K~zonp^ϟݔ`X~;!\GԿ_=dq\Y]MC7 }Iq=Xz1 $5ZlqTj~I' Iա6fp EeE0fY KJQ~N+Ho(?ʽH}t9 Ҹ͓QWFzWFCu*/_4CS4j 鳵H(}G"ͻh}dU
A?9SbD M 9@Ic+!Jz-
vK~"白NM[]U{/l{s찕v
Z"M?Ѿ눊%oOb)O ~6 U!W$4(QM~(;<ڃ'Jc ]5(3 Q:(7%Ұ]Y'\q`!C
Wr"$}D%5j]5s]{)cHN,HIU%'
(Jr PYX&vKQT@Iz|4Pn3<?/d1m$ʏQVĨ8%c{q'YmEHGAPb6 c8 q`hpʊ2Vc@ra##d[Y ֵ#,_%(&V9QFpc/f8RnN p(x~.:
iIn`Hؗ}^ šDkW9 k7inc "dY2}"Mkizc4퇹ŸsɓQmζ7?{,Cʊ2\;i8b`hAp|OS8D}]~֖͑l>DqXbCY]Y{xq)鵝M~(/$oE[ڰ)Ժ Ey]ᬭH>oqo+
Z_]h 66mMٵ̃GtY}^h)yaœ-dTIk_]JI#"\.:>cB`k~ xqTwFXةx6j.1)X;N!} 7|LN`nL#&$٘$$;6t,69kDoOA35PzUhlic66`dV +Өϳ~\f%}~7v;WzÇ1`&.YLv8NJuD56C-LIMCr#L+oNF LJfg}f*So02HKDF +&\.YLԏ8ª edvh5J^وkc~g7#=#cJdb~ ]0X el4lek~~ioMӈ}qw!-ad13X>V/,fV P)LCzV۪֝0ʵO#=;ϝMO/[zzwQOFl^hW,f(JoniڊB˰]2 J IENDB` Ticker_0.4.5pre17.4.04/images/image_tip_6.png 0100644 0000766 0000766 00000000263 10037765321 017112 0 ustar rene rene PNG
IHDR
Gu pHYs ~ tIME
;5bƨJ RIDATx1 "V [vd23ynގ d@2 H $s 9 d@2 ݘE[ IENDB` Ticker_0.4.5pre17.4.04/images/image_tip_7.png 0100644 0000766 0000766 00000003207 10037765321 017114 0 ustar rene rene PNG
IHDR
Gu pHYs ~ tIME 8L@ &IDATx]h[U J +*ew Y&uæn!e-Q6Qp Q4{Z.2ND҈ D\ DPЇdH{|mϩSN"<|ڈ:u7Y!=Y 5|'"_kSTltMXxA:0 ]LQNp<ær[sWMla9˱10s& n{bL /\և zיcR(j`Xm[ V[[}?IP @jJ}m 5 yTZ.&in멈I7Y n x,@7Jv6G
Щ]
0Joqhl ׇ5٥nfY[ K5"}xjI
Õ 瓸2 yG BB!Ntr_2w=6J?8 P! jW
5b?=
9ɩ F yL iڴ+$dzۭ{RiOip倓˃ƫ2FZ;eDE|Ld.x
!7jWw }?d~33=lc6WAS?e4g18OVs= o\_Vyq^#$UA3*03y.'ΖWV0 l6}!GxC>Iõ[^RIp#I¤0{KFBᦀ[Р=W. 3 ɫ\xɩ3(+3x"~>|.G6;ǩc ]Lnƫg3N!H^6l9 ; 2;Lu[$IЀ&7ʙw3mf*/Z '^-U0= s%ٽǮҺM,ok)`wa!߶A4T:5y
i]N; Y@ւͶ>dfs%ޮSJDZSָho%n t2w)1y[ 3W,-6AmV\VzUy||Ņ6eu6gKjV˾|#] y3:IPk6gkjrc$;uk{C:w >ȿ r
IENDB` Ticker_0.4.5pre17.4.04/images/image_tip_8.png 0100644 0000766 0000766 00000002610 10037765321 017112 0 ustar rene rene PNG
IHDR
Gu pHYs ~ tIME -O^a} 'IDATx_hSW ?>܂-"0I: V 0lD]6f`[aLa<-ұnч(F0daly<k$7&ӖK;o_an^xN<TT/_O7t ఏgD;8
m.zcyNV[= [<9dp?1k
O#HY+{K?-?WTd4z3yOI:ր$I[:g.\#Yu4Hd /1ڛF< in<ǧad[\k:^-bJ Ŵ߅䔪-y>cvM]]PSeԻ˗kVFR#ITybʔ97h@QB$&{ U?
F[Fq#҈P\Rqr2۶Xd"ہLe [kGҘݞEhl?֒ i:X83yOf5#4J$h|0؋*ծƠifKk&3<0pğ%2=3F !{q`1JI
Z}F uШ:Ce):w! C> ՓYn]q18LpvEݧjT^5bb%8z^0Pd6}l^Yf*0؋*ծ`
Ɇ>~`sx|Ybp~vY ذoH-M%VR)z:4z33f̳ DZ!W:ZIv4 ۶wVTz IENDB` Ticker_0.4.5pre17.4.04/images/image_tip_9.png 0100644 0000766 0000766 00000005200 10037765321 017111 0 ustar rene rene PNG
IHDR V pHYs ~ tIMEť
IDATxoh ? }q8,L5i D*e),ہJFbcjhm7RG ;v kVyJ3uQJTRa*ͽ0`lٲ$ْݤss{O ̎]
vBGG ·"߷ ::?(mEx,F3l{MEmgXTQی,Ba]e>E G`'26NO~V5??`
#2m!E ];EUh,N/k!
]G Ր?9.EQEYn V^J uej-n# L"lV¼D1f`BW]2%0;_Y!⮣S
>sp,((
mGMExzW5b};{?6XTtt?CdrfU=
B ]krs|&?H,N!['37B "z')gut6JK,#bCYyAễۢ{ p >-[g:
:{#HH9eb6VFFm#xK2%S;s@1 )yQ&FoEh]seD1}!e%QZ[ wh_M9⮣S*yCeUۢ[(e #U^_a}BMn^`vnD} HmKACJ}z_?U.,/%9炔 \237 ~8.(OutJI~9/m !0Lh_
#t;IJD_I³e C6|vKNdV'i;&xiy*)ij-E_Ɩ$ ^3[C ٷ ]:UoV3|ABWm |_0qDk{kb}X6Aho[[ 8攝Mm!&&g2V $Jq@}pZF2uttWHh' U䠣 tttTQM'ΧJ<tZ\~큼6 @JrQn6VfTn~[59N
1pJ
aQ
j I|9Gz )Orr#3o\ev>U^QZ{]j~n6x:CXl;jdVٱ!k_d}*D90_dY鸟z"J
Ŀ *eT9Ȳ\rb(7 ƸXTΥ0>cVۨq3އс(Xc>mꗖon>|s^"3;rE ﯝE {qLD?c4VbY i-Yuxq8imq=i/&aQc0L 25CrY1AYP鴆6_٨ /i=
=l6_,K:>v?uxh}QX1J6{ 闖O.:*!F;SC Es~i]f"F XmUAKP\z4Y"hyJ9or4zCimq4`zx'
| A[KnC[=PrW V kj10~'= WRIN(Xc>m/-!X,Nr>&K -lV3ݧ06bzQ \;hW/iV·4ϞA (
Vŝgj &?wN pHT*0?oĺL_(g'slLݧ֒~9~nb0vB.ڸZ D+6VK`W;29\~:q 8܃]@Vu=-uLҧ b% 㥭3QXT<+B7Q)ffJNr(eGucԻzi E2)Nt~Qc+d+|*[O`}Wu-q0VW2Jњ3,O`r02I?w0t5BmeW i쌓$9B(sDO " wee5tK'_C
/-~pkcErQAݝ@ XRnȼz I; ʷ: t =EIZ 5̌@}~o &$Ƶ<4]> >>. vD/IBpNhKΏ^ܾ;@X5eNH UW߮[7f5@Ek@h
,aϐ$!Hk^wU{yKu^kbgޙ!Gȼd
ӚEru~9R{w[7V&u6_,:>Ek@hHm$'%i3a3
$~8emZK6aP:# 3d[u_G'I̜$:Aʵ|/ ߃8֚iuMvX-k/
Dk,dvb?⽕-#/n+g=iw$[}.HE(DTt\^[wmL;ﳾŊ>=)V\W/
}|~ ~ 1|=2n >Yb; zr;gc%$W/gLIk?" Z6M}x]O]:+.Ћ{_6rIWX6JU0=uqg;zrx;+
ƛ*$yWϐ;>3Cϵ(3/L yT٭k}}pи(.Vhh+)S#^][ -`.}뮞[d/e#ߋ4g<ޫPE0jSߙ'*5I[yaTk]V
C?vOs{X̓ѰۡkgTvi.ŲͱN駗jMF=ĸ&֘%tIwm[C:-委%nur\kzvVh^$V;nU
a_'^V݊-m ڰ\WpLY
Qaʷ>kqf%tbySZӳKd^>H'y@_Sau뽸 bybK6D:huo u ZaR NNuYyzvV#oUQ$ɼ0A⣓i`~~mz/}ͩ>/Nv)e;*:a9頛˦j
;/zcy֗nf*;fbEu,ɿ1i?-]8U~!' ;w/W2o"m ũr$Dۇ~HgmX/N?@||\R,[u2=psmDj^D|kZxYe7jęk;H2uOc'QTGR$R땇eIr= ,VD~aew% sȠ&]:cu1a,A ¹=Etx/qoٮnSo7)bЧyIQm[ϒOvKӼRivH쒲K qN"67NLڪeۧ[
g;{nM/uc9"E/i;Rr" ) =nw-"s-+p g/u[qrD:Ib#ci[y){9BN"դ YhoϠ AnS 7&^ZnnN=/nŁ+!RM Ƽ#oQs%$v,G Si{
LTP&Q&l) p;ݦ nxѭ\;1R8{u+v+\ b'ć yu/
N\!H
Y ~ k z4lY ڭºcv2QXֻy+I H]>Y$I"bgܑNquc_ڝzkNWYl JX^;yzv P,:X.0Z\D خR,i,@:
Ҽh T
HlSPSl Tx,Dź%P!foo@[B&7_vwS i;w0})} 9)_U>uU . RۮEA[dxy1s9OyAUn]~7ScVf5&=CelŻHtphtNخ2sE#96:1D"rҡ1g-1u`go5,03 ؓFQHRblBN| 9`(Otz;:@cpL_4Pe;ۭ* ѝQ>Ovy-g@
ɳB$U"žn$M~>ۦ0u>; %bSm~;fmVO"I6eƜ /(6' gŒIFkMRimO
` `\VUk z{!w~HP]ցsb5ѩrpR#I Q;hKL]ʵ 2;~E]K*iC=+UW"Ъ2@|)+&&HZ, qaM!ObWZ!;o-/1}9iÉ'r/:lN&s~^SNbven褯w. -G-EY%2-li Ů4 !kiyRÌ iOE]T2IpJ>;N/\I;"0U[ ? (vqMUHXNjiNr"UaP-1c$k_u9 W`i?-ɽ1~KtV<{cL~uH A)/M^6 Q}4ϫ0, 3WTkĐvZq+N@iN,$$t&U2vP# Ag0/ѱҫ(v5 <!W!WE~K_Lv9!87ԥ xCV{uB& ;8 U MEd-\ QJyN[!"DtOqC!o9;ιK95_NsZe?+ Z"[Ȯ8ENv7v¿n^puv|:* ÖXMbH'"2#8w)D?yudvgQd;ʀ)B%t/=|$:/Vyq+dObE/&>>. >>.iHn=.G0T>h9J1@VR,[ V- O\ D}ue/kRik'S Sr5|Y ^Ha8n'{EaJ%
q Ox.*mHEr sW.$:99\atw|wٴjyE
R&r H]0
&?HsՅ4Y-L;:犝5Yx
{,Y,BHXnh`y/A^tk! x՝vdVV80;+CDm"4GX٩ＸTv[ ρk =_/z
;^$ jLql|L :AHҥneu+l(R*kķ:?9p9 ` fbf|궋FwE[Ɵv/99yIfɭZEnuvssڹ.ևIH5Cڷ Gp\B@f}0b0*b|&
2ƜIj웓X1nXeAӊ4>ɚ*erܡd
,;?@||\X Y
g:+%v\BS" 6;u32ҭd镪S"Rw;8OJ 6\Gf-\'W ~ 6z$Rޗή#jzI7M^ѮN2<\EjM}:ŎN4Yg5{m
Z-qfN3-ߧb &sk+jݑn+ՏNu$xi1})(Rkǫj:bK}M7kL.RSdWXbI,[N7!YB^uNi+ $IBX ;grT n":L7-&tiW B2;+>. >>.ƃyaΕrf=FJ8Av]͡wJ.S;`{^ '+ff\)Wo Ċc̕H_\_+[O
"B^_Wp\m_tuH $L_ΑuAlՅt yщqI9(|^dto
--oEXh[WΑ *zKv_'H}u]L/K;f{ScRW5WkAPCdb/WABXpM Bbt8.)RshƋ.$TQi1k8vr tW'a`;N"^BM/mwjO+ei
`dgNmw_t^ K7)taVҹ9ئ0}9w
/mP_fP]1y_+% U`iSӜS
aM^gAhAwW
Nlf7m9UuFv
> k nMƕ4gfnĘ 鯕Xvfꮔc E54n=t[ߺ% ST
: v夳:m*0dn΄n4已, ,ދӉJRnL{n
LZ@v IDATڹ/vn{Ŋ>+vk
ϗܭ8ڿF"ķ 4>R q %
s]֩;k-Yk]gO 鬎~H#Icapr'?oO_ۖ*J%{1*Dܱߊwێ6umQ:N|m2S|tSn![{UX4Ĉm ?'hjIiÝ_5:.=Uvp.eڋɖ-%IrM_ȓ@W4swtJdyX"DLE1MW;.+|^lI܍ S4
r%Ͱl
n,\vx%u\j=+KEXwP69[."@45 X|[nw*COE>3PjCQ!X\L]pI+DLm-w+PT!2% mB_&Ӑ9u lW7Hd>bg c|H@ *>eǟn+`赜S
3fߵb]n^EiG/JQ7EH] 5-w 'f{U++yƟyU˓ɇOtbՍl//=`$b{;Y MπWU ̄Îq
o Lax1wٚ,O
? |}vnx3UxXתAꎇґN.k 1vpWNn_4Nm5vڽ"5ÔJw YM+]I~is//gk RG=G(c%4A>[5zj%>ܮZhwKTJ_=J P>(L>[>] [T6OnqۮYhGB/?C=G U~YԵd
~UGBfIyAO5_
Sv^^C㳻~vsG؆%}0s9>|r.Bܚ x~gG/tިF&]A 'qUEWi]EZ7V[$&߭%/e:IR:n J:8b:G:B.XeJ0"9rtqԬ. !VڃR[]\ \zunN+m:n"{$u/KwF7%-s|@po1$u
>4!Cb5TSsC[OpG/XMziwг
wmZnѫH] D7:ujsBr=vیvu器ySԵYj
2Az>Zf@s\8W
_ Xg 8׀ rG[_+_Vq/m N%_Vq k|dԃKp >_Bx>p ? dW$b3LaĻxq|X]aezm='8OKwb*L_ʒ.V%owW ? %븥^4;qt#ݰ=H73 {ߙ, QE ؋㌽8rw|QB_$}Q3BS2Xm
-6Ξ`[]*LBgL;އŹ'~x)Hl2+{⢚D]jm/#ɶ}.0}!2Q͖P$>)eE} &
cm9Wf>oB[ Xq2!m351gL4#WJ҉t@b ƘHwS㞁Q룝7v@WD~4ˇdLOs/ ϧ6[@z!2Gd@BAdA}D/) ,jܹ/P6?d< m$G>1}a$&ߟ! k({QsA ~%( 2"lOZǷ
?ǩy^09V{? #U%XgT\!ďRd0{o$>*8qzG| }uJU9{/ZWw}(
*.ui*/u996!Sg88Ͻpb\rM>G TAm5Aq!DtkBT@U
kӈj-mJ T1
EI_M
X>%o>M. ۚd o"*fbf˔?=9or[1 Y (G ?/?:Ş%w C
1
`y,t3/OXS B2741I`ggH}ܫGH0Z8=0̒+
J%J%O
%{a<$Y
>HX&ou ElxH$Q(
^8N*A*{LMIkًES"sȡ)ϗ8mΛU3}v`htq/@U4եN/> D( Ř+\B}Ad 1=I&OO2 &N`i(HLJ҄ @JjJl bǁ3$"2Ɯɑ'D//12I]3x{cT@kHg5Fcfz,ĩ?<&HO/~{a50։~X Ǭ
=]M4h|y'hb
23WS AzO"shРR||p`=I s:Μ`Ⳡ$I
lXi2}%G(a jBL4"4-BAR yytV%hVtvUW5婊J%p>1>/]#>+9[#S>R2kipj0ST@vsWǹx"@٬ݩ?w@$QNq?|q"`3H o4mMn#1yP(J
eL.ǻlje?+cQ L< !AFe
2ca)n8RwW"賠" E_$~3B1 ԕs-@$
Zib$11eX*-NT+J g;'T#ۮQAu+H ᵷ1d~%!/g
&)1ño'*x"A&QP{pPPFC *A> jl'o)-t
{ ID;Xr8J&3RPX47DH_1vp(˲̝IMUˤ]@4ȰRN,R$,˄TRHVºؔ2&W IW2 (5T H b Hy*_,ԮM
m>F& a?[Z
WlVƜj|&2EU gBY<_!RHXFU@' ?#SD/x !LsɅHTrK sbR0siJSCĶz b5 P⹗
9}hicqdk䐥2pEQvH,1S, ǂ@&-
UʧPYb*;0FCօq9+P$` LsXAc/RY{B`Η[ʒ@8,cY``6E"6M X(chĶ5R ۡ04` H/8ݗ%W3|0_ F%0!' 9P^~
Ar
I
98fpknx;[1 %}-EbqO'1d쥗(ÙwflMaF;4Bs@bDe3蟦H/yVP#>YEDRR6LcX29&.[ 2F:>+#0oR?+8@ T<1,%A@"(``,`Qp)6[pׄiR +6(BR3 k3M22K7QlVglC e cǜ91"{P ??0
W-:*eۢ8u) qf.]$ԗ@,~1
%]=4U uK CK :;řSIA>;3 eu/ J&# TFB[d@vvP5ǨUc;\MsTFFQ7F(}0)H}g1cl ڿ|coDݤ.G4 -Qx9彷99dŚyǐֹX4kr7uC$Ijy-1{`V̇M1V+p˦WcxȪGD Q7 S!$>wgT,βgx,Ɍ|G(DE`Y
T2SQ(q4/za`L
BpyCDOg$_ #tyi>Q/ A"YPF,Q²,*L_&u}
)*ʖ8v` $*E \LP6
l3 ;;?n={h G,T Av.i|Ho^j
&@@Bfצ"a 0 -lV{-*#;cGQoWNF鏐*Ak"',ItCkwk/prs9UkXy 4U=m$`P٫MToyK3e)sƱ7NJ5| ꓐdۢ#
21±WFG&pRUǦc\[`ؾbjaU;,s@!Xe(M
!"iŊns+)M>
6?C PB5 /v3CQ0v AxC$Q$Ig4BݴOA֞ؽ
C[TF:96Wbd{9 Ah !.$yAQۣ[^Zv 8.͗t4k.Q&X;}*5 `90fof N>J|dUTL3Ý{ｑ@.1K (I]G wm k$ q F##^', = 'u9E~gMXcneYQBEd3ً=65_{>=jݥ]̬C}iB@(9t(ӝ$}v} q2de5"aʦ@$!KVp|^gdggQY uf?%,.ãd1H-vZd819tUhw/~ ŒeCķux]s &whQ{ X{
yN)aM:k7 9ÚΕhՖ5Q+=߃SH]/2A6 3FwʒguAa]w1W0l%0qzY:(9DluUEm&
J8xe ՉGPI5hVUԟϨ++E}|)r;Kg)/ ?(mu IENDB` Ticker_0.4.5pre17.4.04/images/image_tip_10.png 0100644 0000766 0000766 00000000233 10037765321 017162 0 ustar rene rene PNG
IHDR H pHYs ~ tIME.aRE :IDATx! A$" @b`j8{M$i}P#$ $}DGHL IENDB` Ticker_0.4.5pre17.4.04/output.py 0100644 0000766 0000766 00000022600 10037765321 014665 0 ustar rene rene #!/usr/bin/env python
#########################################################
# RETicker v. 0.5.0
# a programm to display xml-formatted rss/rdf-feeds in
# a one line display
#########################################################
# please read Help.txt for contact information
#########################################################
# This file contains the classes for all widgets to #
# build the ticker-window #
#########################################################
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 applet, g, tasks
import gobject
import tool
"""--------------------------------------------------------------------------------------------"""
"""------------------------------- Ticker Output Container ------------------------------------"""
"""--------------------------------------------------------------------------------------------"""
### if Applet or Window, the messages will be shown in the following
### box. It contain's the icon and the label and holds methods to
### set and reset mesages and icons
class Label_box(g.HBox):
def __init__(self, Options):
self.Options = Options
g.HBox.__init__(self,g.FALSE, 0)
### set a little border, then there is space in applet for rox-standard-applet menu
self.set_border_width(1)
self.image = TickBild(Options)
self.label = TickLabel(Options)
self.pack_start(self.image, g.FALSE, g.FALSE, 3)
self.pack_start(self.label, g.FALSE, g.FALSE, 3)
self.show()
self.wait_cont = tool.WaitContainer(3, self.reset) # keep last tmp message 3 sek.
### a method to show status messages
### those messages (and icons) will be deleted after some seconds
def status(self, Message, Stock = None, File = None):
if self.Options.check_verbose.int_value: self.label.set_status(Message)
if self.Options.v: print Message
if Stock and self.Options.check_image.int_value: self.image.set_tmp(Stock)
elif self.Options.check_verbose.int_value:
if Stock: self.image.set_tmp(Stock)
elif File: self.image.set_tmp(File)
self.wait_cont.set_value()
### method which will reset icon and label to original value after some seconds
def reset(self, dummy):
self.label.reset(); self.image.reset()
### initiate callback-events, its importend to initiate them after initiating
### show_list (and subclass news) in main class
def set_callback_events(self):
self.label.set_callback_events()
self.image.set_callback_events()
### The folloing class contains the iconimage and is directly derived from EventImage
### as a special Feauture this class contains a second EventBuf, which enables storing
### and displaying of another icon as a (graphical) status-message
class TickBild(tool.EventImage):
def __init__(self, Options):
self.Options = Options
tool.EventImage.__init__(self, Options, g.STOCK_MISSING_IMAGE, \
self.callback_image)
self.tooltip = g.Tooltips(); self.tooltip.enable()
self.tooltip.set_tip(self, " " + self.Options.Version + " ")
self.StockOrTicker = None #
### second set of Methods for setting/resetting status Icon (parallel to tool.EventImage)
def set(self, StockOrTicker):
self.StockOrTicker = StockOrTicker; self.set_(StockOrTicker)
def set_tmp(self, StockOrTicker): self.set_(StockOrTicker)
def reset(self):
print "reset_image to " + str(self.StockOrTicker)
if self.StockOrTicker: self.set_(self.StockOrTicker)
### adding a tooltip as the user like it :)
def addTip(self, fd, news):
def brk_tip(tooltip):
if tooltip == "": return ""
else: return "\n"
tooltip = ""
if self.Options.tt_i.int_value:
if self.Options.tt_i_frame.int_value: tooltip += "---------------------------------------------"
if self.Options.tt_i_title.int_value: tooltip += brk_tip(tooltip) + "Ticker : " + tool.unxml(fd.title).encode("utf-8")
if self.Options.tt_i_frame.int_value: tooltip += brk_tip(tooltip) + "---------------------------------------------"
if self.Options.tt_i_desc.int_value:
desc = fd.desc
if len(desc) > 100: desc = desc[:100] + "..."
tooltip += brk_tip(tooltip) + tool.unxml(desc).encode("utf-8")
if self.Options.tt_i_frame.int_value: tooltip += brk_tip(tooltip)
if self.Options.tt_i_src.int_value: tooltip += brk_tip(tooltip) + "Src : " + tool.unxml(fd.ticker).encode("utf-8")
if self.Options.tt_i_link.int_value: tooltip += brk_tip(tooltip) + "Link : " + tool.unxml(fd.link).encode("utf-8")
if self.Options.tt_i_ver.int_value: tooltip += brk_tip(tooltip) + " *** " + self.Options.Version + " *** \n" + news.stat()
self.set_tip(tooltip)
else:
self.tooltip.disable()
def set_tip(self, tooltip): self.tooltip.enable(); self.tooltip.set_tip(self, tooltip)
### the callback on user-clicks on the image sends some signals
def callback_image(self, widget, event):
if event.button == 1: self.emit("img_click_button_1")
if event.button == 2: self.emit("img_click_button_2")
if event.button == 3: self.emit("img_click_button_3", event) # event argument is used by menu
### override the tool.EventImage methods for entering and leaving the widget
def enter_widget(self, widget, event):
self.emit("img_entered"); widget.set_state (g.STATE_PRELIGHT)
def leave_widget(self, widget, event):
self.emit("img_leaved"); widget.set_state (g.STATE_NORMAL)
gobject.signal_new("img_click_button_1", TickBild, gobject.SIGNAL_RUN_LAST,gobject.TYPE_NONE, ())
gobject.signal_new("img_click_button_2", TickBild, gobject.SIGNAL_RUN_LAST,gobject.TYPE_NONE, ())
gobject.signal_new("img_click_button_3", TickBild, gobject.SIGNAL_RUN_LAST,gobject.TYPE_NONE, (gobject.TYPE_PYOBJECT,))
gobject.signal_new("img_entered", TickBild, gobject.SIGNAL_RUN_LAST,gobject.TYPE_NONE, ())
gobject.signal_new("img_leaved", TickBild, gobject.SIGNAL_RUN_LAST,gobject.TYPE_NONE, ())
### The next Class is a label with two kinds of messages, news and status messages
### news messages should be shown always, but status messages should only be shown
### for some seconds (see parent box class)
class TickLabel(g.EventBox):
def __init__(self, Options):
self.Options = Options
g.EventBox.__init__(self)
#### create the main label
self.text = " " + self.Options.Version + " " # The 'normal' Message
self.label = g.Label(self.text)
self.label.show()
self.add(self.label)
self.tooltip = g.Tooltips(); self.tooltip.enable()
self.tooltip.set_tip(self, " " + self.Options.Version + " ")
self.set_events(g.gdk.ENTER_NOTIFY_MASK | g.gdk.LEAVE_NOTIFY_MASK)
self.set_color()
self.show()
self.connect("enter-notify-event", self.enter_widget)
self.connect("leave-notify-event", self.leave_widget)
self.connect("button_press_event", self.callback_label)
### show status message
def set_status(self, Label): self.label.set_text(Label)
### and reset to 'normal' message
def reset(self): self.label.set_text(self.text)
### update changes 'normal' message and double-stores this message in self.text
def update(self,Label): self.text = Label; self.label.set_text(self.text)
### as called, to set the text-color (foreground) in normal and prelight stage
def set_color(self, dummy = None):
self.label.modify_fg(g.STATE_NORMAL, g.gdk.color_parse(self.Options.text_color.value))
self.label.modify_fg(g.STATE_PRELIGHT, tool.text_color_prelight(self.Options))
### adding a tooltip as the user like it :)
def addTip(self, i):
def brk_tip(tooltip):
if tooltip == "": return ""
else: return "\n"
tooltip = ""
if self.Options.tt_l.int_value:
if self.Options.tt_l_frame.int_value: tooltip += "---------------------------------------------"
if self.Options.tt_l_title.int_value: tooltip += brk_tip(tooltip) + tool.unxml(i.title).encode("utf-8")
if self.Options.tt_l_frame.int_value: tooltip += brk_tip(tooltip) + "---------------------------------------------"
tooltip += brk_tip(tooltip) + tool.unxml(i.desc).encode("utf-8")
if self.Options.tt_l_frame.int_value: tooltip += brk_tip(tooltip)
if self.Options.tt_l_link.int_value: tooltip += brk_tip(tooltip) + "Link : " + tool.unxml(i.link).encode("utf-8")
if self.Options.tt_l_ver.int_value: tooltip += brk_tip(tooltip) + " *** " + self.Options.Version + " *** "
self.set_tip(tooltip)
else:
self.tooltip.disable()
def set_tip(self, tooltip): self.tooltip.enable(); self.tooltip.set_tip(self, tooltip)
### the following callbacks are connected an main hirarchie
def enter_widget(self, widget, event):
self.emit("lab_tickbild_entered"); widget.set_state (g.STATE_PRELIGHT)
def leave_widget(self, widget, event):
self.emit("lab_tickbild_leaved"); widget.set_state (g.STATE_NORMAL)
def callback_label(self, widget, event):
print event.button
if event.button == 1: self.emit("lab_click_button_1")
if event.button == 2: self.emit("lab_click_button_2")
if event.button == 3: self.emit("lab_click_button_3")
gobject.signal_new("lab_click_button_1", TickLabel, gobject.SIGNAL_RUN_LAST,gobject.TYPE_NONE, ())
gobject.signal_new("lab_click_button_2", TickLabel, gobject.SIGNAL_RUN_LAST,gobject.TYPE_NONE, ())
gobject.signal_new("lab_click_button_3", TickLabel, gobject.SIGNAL_RUN_LAST,gobject.TYPE_NONE, ())
gobject.signal_new("lab_tickbild_entered", TickLabel, gobject.SIGNAL_RUN_LAST,gobject.TYPE_NONE, ())
gobject.signal_new("lab_tickbild_leaved", TickLabel, gobject.SIGNAL_RUN_LAST,gobject.TYPE_NONE, ())
"""--------------------------------------------------------------------------------------------"""
Ticker_0.4.5pre17.4.04/start.py 0100744 0000766 0000766 00000004136 10037766612 014473 0 ustar rene rene #!/usr/bin/env python
#########################################################
# RETicker v. 0.4.5pre
# a programm to display xml-formatted rss/rdf-feeds in
# a one line display
#########################################################
# please read Help.txt for contact information
#########################################################
# This is the starter for the real Ticker-Application #
# it checks, if it is started as an applet an proofes #
# command line options #
#########################################################
import findrox; findrox.version(1,9,13)
import rox
import sys
V = "0.4.5pre16.4.04"
Version = "RETicker v " + V
user_conf = ""
applet = None
verbose = 0
if len(sys.argv) > 1:
### check if started as an Applet, then the first param is a number
try:
int(sys.argv[1])
print Version
print "[starting as a rox-applet]"
print "If this is happening on the command-line"
print "and you don't want this, stop giving the"
print "program a Number as a parameter"
applet = True
import RETicker
RETicker.TickerApplet(V, Version, "_applet", verbose)
except:
### started as standalone Program
i = 1
print "*** " + Version + " ***"
### check for comand-line options
while i < len(sys.argv):
if sys.argv[i] == '--config':
if len(sys.argv) < i+2:
print "ERROR: to few arguments (try --help)"
sys.exit()
else:
user_conf = "_" + sys.argv[i+1]
i += 2
continue
if sys.argv[i] == '-v' or sys.argv[i] == '--verbose':
verbose = 1; i += 1; continue
if sys.argv[i] == '--help':
print "usage: ./AppRun [--config X][--verbose|-v][--help]"
print " --config X start with Konfiguration X"
print " use any Name for X"
print " --verbose be more verbose"
print " --help shows this help ;)"
print "Please report any Problems (see README.txt)"
sys.exit()
print "ERROR: unknown argument : " + sys.argv[i] + \
"\ntry --help"
sys.exit()
if not(applet):
import RETicker
RETicker.TickerWindow(V, Version, user_conf, verbose)
rox.mainloop()
Ticker_0.4.5pre17.4.04/feed.py 0100644 0000766 0000766 00000016451 10037765321 014237 0 ustar rene rene #!/usr/bin/env python
#########################################################
# RETicker v. 0.4.5pre
# a programm to display xml-formatted rss/rdf-feeds in
# a one line display
#########################################################
# please read Help.txt for contact information
#########################################################
# This file contains the classes storing and showing #
# the actual news #
#########################################################
#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 xml.dom import minidom
#from xml.dom.minidom import Document
#import xml.sax
#import os
import time
#import gobject
import tool
import message
"""--------------------------------------------------------------------------------------------"""
"""------------------------------ feed - The Class which holds the Channel / Feed -------------"""
"""--------------------------------------------------------------------------------------------"""
### class for a news feed -- The most importend contents are a list of Messages (self.msg),
### the self.ticker string as a definite key to this feed and the source, which is directly
### connected with the feed
import Options
class feed:
def __init__(self, myOptions, source):
self.__Options = myOptions
self.__source = source
## use own Ticker only as label...
self.ticker = self.__source.ticker
### additional data-fields with basic information
self.title = None
self.link = None
self.desc = None
# stores the messages
self.msg = []
### additional fields
self.type = None # recognized feed-type
self.feed_nr = None # number in parent news feed-list
self.__add_pos = 0 # pos to add next msg
self.__cache_count = 0 # max number of msg to cache
self.__tmp_cache_count = 0
### some methods, to simply get the fields directly connected to this feed by
### getting it from the connected source
def get_active(self): return self.__source.get_active()
def get_ticker(self): return self.__source.get_ticker()
def get_icon(self): return self.__source.get_icon()
def get_iconcache(self): return self.__source.get_iconcache()
def get_iconset(self): return self.__source.get_iconset()
def get_shownews(self): return self.__source.get_shownews()
def get_news_age_by_date(self): return self.__source.get_news_age_by_date()
def get_provides_date_info(self): return self.__source.get_provides_date_info()
### stat returns some Information about the feed, like number of messages at all
### and number of active messages. Usually called by parent news_ class method stat
def stat(self, stat):
stat['all_msg_count'] += len(self.msg)
if self.get_active() == 1:
stat['act_feed_count'] += 1
stat['act_msg_count'] += len(self.msg)
for i in range(0, len(self.msg)-1):
if i >= self.get_shownews(): continue
if self.msg_is_new(self.msg[i]): stat['new_msg_count'] += 1
return stat
### say if message is in feed (here same title and same link)
def msg_in_feed(self, msg):
for msg_old in self.msg:
if msg.title == msg_old.title and \
msg.link == msg_old.link: return True
return False
### check, if message is new in terms of user wishes
def msg_is_new(self, msg):
# check if message was read in browser
if msg.read == 1: return False
# check if msg-fetchtimestamp is to old
if self.__Options.news_age.int_value <> 0 and \
msg.fetchtime + self.__Options.news_age.int_value*60 < time.time():
return False
# check if msg-timestamp is to old
if self.get_news_age_by_date() <> 0 and self.get_provides_date_info() == 1 and \
msg.time + self.get_news_age_by_date() * 60 < time.time():
return False
# check if msg-showcount is less then max showcount
if self.__Options.news_showcount.int_value <> 0 and \
msg.showcount >= self.__Options.news_showcount.int_value:
return False
return True
### export feed contents to xml, usually used to write cache
def _to_xml(self, parent):
def createNode(doc, name, data):
node = doc.createElement(name)
if data == None: data = ""
node.appendChild(doc.createTextNode(data))
return node
doc = parent.ownerDocument
root = doc.createElement('feed')
parent.appendChild(root)
root_c = doc.createElement('channel')
root.appendChild(root_c)
root_c.appendChild(createNode(doc, 'title', self.title))
root_c.appendChild(createNode(doc, 'ticker', self.ticker))
root_c.appendChild(createNode(doc, 'link', self.link))
root_c.appendChild(createNode(doc, 'description', self.desc))
for i in self.msg:
i._to_xml(root)
return doc
### import or update contents of feed from xml-data
def _from_xml(self, xmldoc, type, box = None):
self.type = type # store the feed-type, mightbe sometimes useful
### get channel == feed information. If xml-data structure wasnt recongnized
### ('fallback') then use the whole structure as channel
if self.type <> 'fallback': channel = xmldoc.getElementsByTagName("channel")[0]
else: channel = xmldoc
### search for additional information (it might have been updated)
self.title = tool.getdata_wo_ret(channel, "title")
self.link = tool.getdata(channel, "link")
self.desc = tool.getdata_wo_ret(channel, "description")
### search xmldoc for items to add to the feed, if it is a rss feed, items are
### a part of the channel element
if self.type == 'rss': items = channel.getElementsByTagName("item")
else: items = xmldoc.getElementsByTagName("item")
self.__add_pos = 0 ### reinit position to add new msgs
### check all 'item' elements for new messages
for i in items:
if box: box.status("Checking " + self.title + " (" + str(self.__tmp_cache_count) + ")")
### create new message and try to add it
self.try_to_add_msg(message.message(i, self.type))
### if number of msg had grown, grow also value if cached news
if len(items) > self.__cache_count:
self.__cache_count = len(items)
### reduce number of cached messages
while len(self.msg) > self.__cache_count:
self.msg.pop()
### check if messages now providing date-info
self.reinit_provides_date_info()
### check, if at least one message has a dc:date field (means msg.time <> 0)
def reinit_provides_date_info(self):
for msg in self.msg:
if msg.time <> 0:
self.__source.set_provides_date_info(1); return
self.__source.set_provides_date_info(0)
### adds message, if it is not still in feed
def try_to_add_msg(self,msg_new):
if self.msg_in_feed(msg_new): return
### ok, add message, but where?
if msg_new.time <> 0: # feed-msg provides dc:date info, so use it
# to find right position for new msg
#search timeposition
for index in range(0, len(self.msg)-1):
### to compare msg-times, use time-stamp of message
### if the old message hasnt a timestamp, use fethtime instead
if self.msg[index].time <> 0: index_time = self.msg[index].time
else: index_time = self.msg[index].fetchtime
if index_time < msg_new.time:
self.msg.insert(index, msg_new)
if index < self.__add_pos: self.__add_pos += 1
return
self.msg.append(msg_new) # not found
else:
# if no cd_timestamp provided, add at self.__add_pos position
self.msg.insert(self.__add_pos, msg_new)
self.__add_pos += 1
Ticker_0.4.5pre17.4.04/message.py 0100644 0000766 0000766 00000007134 10037765321 014756 0 ustar rene rene #!/usr/bin/env python
#########################################################
# RETicker v. 0.4.5pre
# a programm to display xml-formatted rss/rdf-feeds in
# a one line display
#########################################################
# please read Help.txt for contact information
#########################################################
# This file contains the classes storing and showing #
# the actual news #
#########################################################
#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 xml.dom import minidom
#from xml.dom.minidom import Document
#import xml.sax
#import os
import time
#import gobject
import tool
EMPTY_DESC = "(no further Information)" ### This String indicates an empty
### description field in message
"""--------------------------------------------------------------------------------------------"""
"""------------------------------ message - The Class which holds the Message -----------------"""
"""--------------------------------------------------------------------------------------------"""
### class for a news message and all information related to one, see __init__ for contents
class message:
def __init__(self, xml_source = None, type = 'fallback'):
self.title = ""
self.link = ""
self.desc = ""
self.time = 0 # time wich found in field dc:date
self.fetchtime = 0 # time when message was fetched
self.showcount = 0 # how often message was shown in ticker
self.read = 0 # if 1, message was opened in browser
# usually an empty message is useless
if xml_source: self._from_xml(xml_source, type)
### import contents of message from xml; usually called by __init__
def _from_xml(self, xml_source, type):
self.title = tool.getdata(xml_source, "title")
self.link = tool.getdata(xml_source, "link")
self.desc = tool.getdata_wo_ret(xml_source, "description")
# if there is no title for the message, try to get some from description
if self.title == "": self.title = tool.makeshorter(self.desc, 50)
if self.title == "": self.title = tool.makeshorter(self.link, 50)
# if still no title - forget the whole thing
if self.desc == "": self.desc = EMPTY_DESC
self.fetchtime = tool.getfloatdata(xml_source, "fetchtime")
if self.fetchtime <> 0: ### only happens if cache-data is read
self.time = tool.getfloatdata(xml_source, "time")
else:
self.time = tool.gettimedata(xml_source, "dc:date")
self.fetchtime = time.time()
self.showcount = tool.getintdata(xml_source, "showcount")
self.read = tool.getintdata(xml_source, "read")
### export contents of message to xml
def _to_xml(self, parent):
def createNode(doc, name, data):
node = doc.createElement(name)
node.appendChild(doc.createTextNode(data))
return node
doc = parent.ownerDocument
root = doc.createElement('item')
parent.appendChild(root)
root.appendChild(createNode(doc, 'title', self.title))
root.appendChild(createNode(doc, 'link', self.link))
root.appendChild(createNode(doc, 'description', self.desc))
root.appendChild(createNode(doc, 'time', str(self.time)))
root.appendChild(createNode(doc, 'fetchtime', str(self.fetchtime)))
root.appendChild(createNode(doc, 'showcount', str(self.showcount)))
root.appendChild(createNode(doc, 'read', str(self.read)))
return doc
### print Message contents xml-formatted
def __str__(self):
doc = Document()
root = doc.createElement('message'); doc.appendChild(root)
self._to_xml(root)
return doc.toxml()
Ticker_0.4.5pre17.4.04/icon.py 0100644 0000766 0000766 00000010207 10037765321 014255 0 ustar rene rene #!/usr/bin/env python
#########################################################
# RETicker v. 0.4.5pre
# a programm to display xml-formatted rss/rdf-feeds in
# a one line display
#########################################################
# please read Help.txt for contact information
#########################################################
# This file contains the classes storing and showing #
# the actual news #
#########################################################
from __future__ import generators
import rox
from rox import g, tasks
import os
import tool
import gobject
class IconBuffer(gobject.GObject):
def __init__(self, filename= None, url = None, Stock = g.STOCK_MISSING_IMAGE):
gobject.GObject.__init__(self)
self.stock_iconsets = Stock_IconSets()
self.__filename = filename
self.__url = url
self.__stock = Stock
self.__iconset = None
self.__pixbuf = None
self.__pixbuf_active = None
self.status = None ### Indicates the status: One of None, get_file, get_url or done
self.t = None
def get(self):
if not(self.__iconset): self.__initialize()
if not(self.__iconset):
if self.__url: return self.stock_iconsets.get(g.STOCK_CONVERT)
else: return self.stock_iconsets.get(Stock)
return self.__iconset
def __set_image(self):
#print "pixbuf " + str(self.__pixbuf)
self.__iconset = g.IconSet(self.__pixbuf)
tmp_pixbuf = self.__pixbuf.copy()
tmp_pixbuf.saturate_and_pixelate(tmp_pixbuf, 5, g.FALSE)
iconsrc = g.IconSource()
iconsrc.set_pixbuf(tmp_pixbuf)
iconsrc.set_state_wildcarded(g.FALSE)
iconsrc.set_state(g.STATE_PRELIGHT)
self.__iconset.add_source(iconsrc)
self.emit("icon_changed")
def reinit(self, filename= None, url = None, Stock = g.STOCK_MISSING_IMAGE):
self.__filename = filename
self.__url = url
self.__stock = Stock
self.__iconset = None
self.get()
def __initialize(self): ### trying to read icon from file
if self.__filename:
print "try to read icon from cached file";
if (self.__set_from_file()):
return
if self.__url:
print "try to read icon from url";
self.__set_from_url()
def __set_from_file(self):
if self.t and self.t.Status() == None: self.t.Kill()
self.status = 'get_file'
if os.path.isfile(self.__filename):
if self.__pixbuf: del self.__pixbuf; self.__pixbuf = None
try:
self.__pixbuf = g.gdk.pixbuf_new_from_file(self.__filename)
self.__set_image()
except (gobject.GError): return False
else: return False
self.status = 'done'; return True
def __set_from_url(self): tasks.Task(self.__set_from_url_task())
def __set_from_url_task(self):
self.status = 'get_url'
#prog = tool.Win_ProgBar()
#prog.start_pulse()
if self.t and self.t.Status() == None: self.t.Kill()
self.t = tool.urlretrieve(self.__url, self.__filename)
yield None
### wait a little bit till icon might be cached locally
from news import HTTP_TIMEOUT
for tick in range (0, HTTP_TIMEOUT):
if self.t.Done() == 1: break
yield tasks.TimeoutBlocker(1);
#prog.rem()
if self.t.Status() == None:
self.t.Kill()
self.emit("icon_at_url_not_retrieved")
#rox.alert("Icon could not retrieved from url:\n" + self.__url)
#### try to set from file
self.__set_from_file()
gobject.signal_new("icon_changed", IconBuffer, gobject.SIGNAL_RUN_LAST,gobject.TYPE_NONE, ())
gobject.signal_new("icon_at_url_not_retrieved", IconBuffer, gobject.SIGNAL_RUN_LAST,gobject.TYPE_NONE, ())
class Stock_IconSets:
def __init__(self):
self.__sets = []
def get(self, Stock):
for set in self.__sets:
if set['Stock'] == Stock: return set['iconset']
new_iconset = self.__create_iconset_from_stock(Stock)
self.__sets.append({'Stock' : Stock, 'iconset' : new_iconset})
return new_iconset
def __create_iconset_from_stock(self, Stock):
tmp_ebuf = g.EventBox()
pixbuf = tmp_ebuf.render_icon(Stock, g.ICON_SIZE_SMALL_TOOLBAR, "")
iconset = g.IconSet(pixbuf)
tmp_pixbuf = pixbuf.copy()
tmp_pixbuf.saturate_and_pixelate(tmp_pixbuf, 5, g.FALSE)
iconsrc = g.IconSource()
iconsrc.set_pixbuf(tmp_pixbuf)
iconsrc.set_state_wildcarded(g.FALSE)
iconsrc.set_state(g.STATE_PRELIGHT)
iconset.add_source(iconsrc)
return iconset