gpodder-3.1.2/ 0000775 0001750 0001750 00000000000 11760761026 012561 5 ustar thp thp 0000000 0000000 gpodder-3.1.2/src/ 0000775 0001750 0001750 00000000000 11760761026 013350 5 ustar thp thp 0000000 0000000 gpodder-3.1.2/src/gpodder/ 0000775 0001750 0001750 00000000000 11760761026 014774 5 ustar thp thp 0000000 0000000 gpodder-3.1.2/src/gpodder/extensions.py 0000664 0001750 0001750 00000037250 11751103635 017550 0 ustar thp thp 0000000 0000000 # -*- coding: utf-8 -*-
#
# gPodder - A media aggregator and podcast client
# Copyright (c) 2005-2009 Thomas Perl and the gPodder Team
#
# gPodder is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# gPodder is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see ; 2010-01-19
#
import gpodder
_ = gpodder.gettext
import atexit
import datetime
import calendar
import os
import sys
import threading
import time
import logging
logger = logging.getLogger(__name__)
from gpodder import util
from gpodder import minidb
# Append gPodder's user agent to mygpoclient's user agent
import mygpoclient
mygpoclient.user_agent += ' ' + gpodder.user_agent
MYGPOCLIENT_REQUIRED = '1.4'
if not hasattr(mygpoclient, 'require_version') or \
not mygpoclient.require_version(MYGPOCLIENT_REQUIRED):
print >>sys.stderr, """
Please upgrade your mygpoclient library.
See http://thp.io/2010/mygpoclient/
Required version: %s
Installed version: %s
""" % (MYGPOCLIENT_REQUIRED, mygpoclient.__version__)
sys.exit(1)
from mygpoclient import api
from mygpoclient import public
from mygpoclient import util as mygpoutil
EXAMPLES_OPML = 'http://gpodder.org/directory.opml'
TOPLIST_OPML = 'http://gpodder.org/toplist.opml'
# Database model classes
class SinceValue(object):
__slots__ = {'host': str, 'device_id': str, 'category': int, 'since': int}
# Possible values for the "category" field
PODCASTS, EPISODES = range(2)
def __init__(self, host, device_id, category, since=0):
self.host = host
self.device_id = device_id
self.category = category
self.since = since
class SubscribeAction(object):
__slots__ = {'action_type': int, 'url': str}
# Possible values for the "action_type" field
ADD, REMOVE = range(2)
def __init__(self, action_type, url):
self.action_type = action_type
self.url = url
@property
def is_add(self):
return self.action_type == self.ADD
@property
def is_remove(self):
return self.action_type == self.REMOVE
@classmethod
def add(cls, url):
return cls(cls.ADD, url)
@classmethod
def remove(cls, url):
return cls(cls.REMOVE, url)
@classmethod
def undo(cls, action):
if action.is_add:
return cls(cls.REMOVE, action.url)
elif action.is_remove:
return cls(cls.ADD, action.url)
raise ValueError('Cannot undo action: %r' % action)
# New entity name for "received" actions
class ReceivedSubscribeAction(SubscribeAction): pass
class UpdateDeviceAction(object):
__slots__ = {'device_id': str, 'caption': str, 'device_type': str}
def __init__(self, device_id, caption, device_type):
self.device_id = device_id
self.caption = caption
self.device_type = device_type
class EpisodeAction(object):
__slots__ = {'podcast_url': str, 'episode_url': str, 'device_id': str,
'action': str, 'timestamp': int,
'started': int, 'position': int, 'total': int}
def __init__(self, podcast_url, episode_url, device_id, \
action, timestamp, started, position, total):
self.podcast_url = podcast_url
self.episode_url = episode_url
self.device_id = device_id
self.action = action
self.timestamp = timestamp
self.started = started
self.position = position
self.total = total
# New entity name for "received" actions
class ReceivedEpisodeAction(EpisodeAction): pass
class RewrittenUrl(object):
__slots__ = {'old_url': str, 'new_url': str}
def __init__(self, old_url, new_url):
self.old_url = old_url
self.new_url = new_url
# End Database model classes
# Helper class for displaying changes in the UI
class Change(object):
def __init__(self, action, podcast=None):
self.action = action
self.podcast = podcast
@property
def description(self):
if self.action.is_add:
return _('Add %s') % self.action.url
else:
return _('Remove %s') % self.podcast.title
class MygPoClient(object):
STORE_FILE = 'gpodder.net'
FLUSH_TIMEOUT = 60
FLUSH_RETRIES = 3
def __init__(self, config):
self._store = minidb.Store(os.path.join(gpodder.home, self.STORE_FILE))
self._config = config
self._client = None
# Initialize the _client attribute and register with config
self.on_config_changed()
assert self._client is not None
self._config.add_observer(self.on_config_changed)
self._worker_thread = None
atexit.register(self._at_exit)
def create_device(self):
"""Uploads the device changes to the server
This should be called when device settings change
or when the mygpo client functionality is enabled.
"""
# Remove all previous device update actions
self._store.remove(self._store.load(UpdateDeviceAction))
# Insert our new update action
action = UpdateDeviceAction(self.device_id, \
self._config.mygpo.device.caption, \
self._config.mygpo.device.type)
self._store.save(action)
def get_rewritten_urls(self):
"""Returns a list of rewritten URLs for uploads
This should be called regularly. Every object returned
should be merged into the database, and the old_url
should be updated to new_url in every podcdast.
"""
rewritten_urls = self._store.load(RewrittenUrl)
self._store.remove(rewritten_urls)
return rewritten_urls
def process_episode_actions(self, find_episode, on_updated=None):
"""Process received episode actions
The parameter "find_episode" should be a function accepting
two parameters (podcast_url and episode_url). It will be used
to get an episode object that needs to be updated. It should
return None if the requested episode does not exist.
The optional callback "on_updated" should accept a single
parameter (the episode object) and will be called whenever
the episode data is changed in some way.
"""
logger.debug('Processing received episode actions...')
for action in self._store.load(ReceivedEpisodeAction):
if action.action not in ('play', 'delete'):
# Ignore all other action types for now
continue
episode = find_episode(action.podcast_url, action.episode_url)
if episode is None:
# The episode does not exist on this client
continue
if action.action == 'play':
logger.debug('Play action for %s', episode.url)
episode.mark(is_played=True)
if (action.timestamp > episode.current_position_updated and
action.position is not None):
logger.debug('Updating position for %s', episode.url)
episode.current_position = action.position
episode.current_position_updated = action.timestamp
if action.total:
logger.debug('Updating total time for %s', episode.url)
episode.total_time = action.total
episode.save()
if on_updated is not None:
on_updated(episode)
elif action.action == 'delete':
if not episode.was_downloaded(and_exists=True):
# Set the episode to a "deleted" state
logger.debug('Marking as deleted: %s', episode.url)
episode.delete_from_disk()
episode.save()
if on_updated is not None:
on_updated(episode)
# Remove all received episode actions
self._store.delete(ReceivedEpisodeAction)
self._store.commit()
logger.debug('Received episode actions processed.')
def get_received_actions(self):
"""Returns a list of ReceivedSubscribeAction objects
The list might be empty. All these actions have to
be processed. The user should confirm which of these
actions should be taken, the reest should be rejected.
Use confirm_received_actions and reject_received_actions
to return and finalize the actions received by this
method in order to not receive duplicate actions.
"""
return self._store.load(ReceivedSubscribeAction)
def confirm_received_actions(self, actions):
"""Confirm that a list of actions has been processed
The UI should call this with a list of actions that
have been accepted by the user and processed by the
podcast backend.
"""
# Simply remove the received actions from the queue
self._store.remove(actions)
def reject_received_actions(self, actions):
"""Reject (undo) a list of ReceivedSubscribeAction objects
The UI should call this with a list of actions that
have been rejected by the user. A reversed set of
actions will be uploaded to the server so that the
state on the server matches the state on the client.
"""
# Create "undo" actions for received subscriptions
self._store.save(SubscribeAction.undo(a) for a in actions)
self.flush()
# After we've handled the reverse-actions, clean up
self._store.remove(actions)
@property
def host(self):
return self._config.mygpo.server
@property
def device_id(self):
return self._config.mygpo.device.uid
def can_access_webservice(self):
return self._config.mygpo.enabled and self._config.mygpo.device.uid
def set_subscriptions(self, urls):
if self.can_access_webservice():
logger.debug('Uploading (overwriting) subscriptions...')
self._client.put_subscriptions(self.device_id, urls)
logger.debug('Subscription upload done.')
else:
raise Exception('Webservice access not enabled')
def _convert_played_episode(self, episode, start, end, total):
return EpisodeAction(episode.channel.url, \
episode.url, self.device_id, 'play', \
int(time.time()), start, end, total)
def _convert_episode(self, episode, action):
return EpisodeAction(episode.channel.url, \
episode.url, self.device_id, action, \
int(time.time()), None, None, None)
def on_delete(self, episodes):
logger.debug('Storing %d episode delete actions', len(episodes))
self._store.save(self._convert_episode(e, 'delete') for e in episodes)
def on_download(self, episodes):
logger.debug('Storing %d episode download actions', len(episodes))
self._store.save(self._convert_episode(e, 'download') for e in episodes)
def on_playback_full(self, episode, start, end, total):
logger.debug('Storing full episode playback action')
self._store.save(self._convert_played_episode(episode, start, end, total))
def on_playback(self, episodes):
logger.debug('Storing %d episode playback actions', len(episodes))
self._store.save(self._convert_episode(e, 'play') for e in episodes)
def on_subscribe(self, urls):
# Cancel previously-inserted "remove" actions
self._store.remove(SubscribeAction.remove(url) for url in urls)
# Insert new "add" actions
self._store.save(SubscribeAction.add(url) for url in urls)
self.flush()
def on_unsubscribe(self, urls):
# Cancel previously-inserted "add" actions
self._store.remove(SubscribeAction.add(url) for url in urls)
# Insert new "remove" actions
self._store.save(SubscribeAction.remove(url) for url in urls)
self.flush()
def _at_exit(self):
self._worker_proc(forced=True)
self._store.commit()
self._store.close()
def _worker_proc(self, forced=False):
if not forced:
# Store the current contents of the queue database
self._store.commit()
logger.debug('Worker thread waiting for timeout')
time.sleep(self.FLUSH_TIMEOUT)
# Only work when enabled, UID set and allowed to work
if self.can_access_webservice() and \
(self._worker_thread is not None or forced):
self._worker_thread = None
logger.debug('Worker thread starting to work...')
for retry in range(self.FLUSH_RETRIES):
must_retry = False
if retry:
logger.debug('Retrying flush queue...')
# Update the device first, so it can be created if new
for action in self._store.load(UpdateDeviceAction):
if self.update_device(action):
self._store.remove(action)
else:
must_retry = True
# Upload podcast subscription actions
actions = self._store.load(SubscribeAction)
if self.synchronize_subscriptions(actions):
self._store.remove(actions)
else:
must_retry = True
# Upload episode actions
actions = self._store.load(EpisodeAction)
if self.synchronize_episodes(actions):
self._store.remove(actions)
else:
must_retry = True
if not must_retry:
# No more pending actions. Ready to quit.
break
logger.debug('Worker thread finished.')
else:
logger.info('Worker thread may not execute (disabled).')
# Store the current contents of the queue database
self._store.commit()
def flush(self, now=False):
if not self.can_access_webservice():
logger.warn('Flush requested, but sync disabled.')
return
if self._worker_thread is None or now:
if now:
logger.debug('Flushing NOW.')
else:
logger.debug('Flush requested.')
self._worker_thread = threading.Thread(target=self._worker_proc, args=[now])
self._worker_thread.setDaemon(True)
self._worker_thread.start()
else:
logger.debug('Flush requested, already waiting.')
def on_config_changed(self, name=None, old_value=None, new_value=None):
if name in ('mygpo.username', 'mygpo.password', 'mygpo.server') \
or self._client is None:
self._client = api.MygPodderClient(self._config.mygpo.username,
self._config.mygpo.password, self._config.mygpo.server)
logger.info('Reloading settings.')
elif name.startswith('mygpo.device.'):
# Update or create the device
self.create_device()
def synchronize_episodes(self, actions):
logger.debug('Starting episode status sync.')
def convert_to_api(action):
dt = datetime.datetime.utcfromtimestamp(action.timestamp)
action_ts = mygpoutil.datetime_to_iso8601(dt)
return api.EpisodeAction(action.podcast_url, \
action.episode_url, action.action, \
action.device_id, action_ts, \
action.started, action.position, action.total)
def convert_from_api(action):
dt = mygpoutil.iso8601_to_datetime(action.timestamp)
action_ts = calendar.timegm(dt.timetuple())
return ReceivedEpisodeAction(action.podcast, \
action.episode, action.device, \
action.action, action_ts, \
action.started, action.position, action.total)
try:
# Load the "since" value from the database
since_o = self._store.get(SinceValue, host=self.host, \
device_id=self.device_id, \
category=SinceValue.EPISODES)
# Use a default since object for the first-time case
if since_o is None:
since_o = SinceValue(self.host, self.device_id, SinceValue.EPISODES)
# Step 1: Download Episode actions
try:
changes = self._client.download_episode_actions(since_o.since)
received_actions = [convert_from_api(a) for a in changes.actions]
logger.debug('Received %d episode actions', len(received_actions))
self._store.save(received_actions)
# Save the "since" value for later use
self._store.update(since_o, since=changes.since)
except Exception, e:
logger.warn('Exception while polling for episodes.', exc_info=True)
# Step 2: Upload Episode actions
# Convert actions to the mygpoclient format for uploading
episode_actions = [convert_to_api(a) for a in actions]
# Upload the episode actions
self._client.upload_episode_actions(episode_actions)
# Actions have been uploaded to the server - remove them
self._store.remove(actions)
logger.debug('Episode actions have been uploaded to the server.')
return True
except Exception, e:
logger.error('Cannot upload episode actions: %s', str(e), exc_info=True)
return False
def synchronize_subscriptions(self, actions):
logger.debug('Starting subscription sync.')
try:
# Load the "since" value from the database
since_o = self._store.get(SinceValue, host=self.host, \
device_id=self.device_id, \
category=SinceValue.PODCASTS)
# Use a default since object for the first-time case
if since_o is None:
since_o = SinceValue(self.host, self.device_id, SinceValue.PODCASTS)
# Step 1: Pull updates from the server and notify the frontend
result = self._client.pull_subscriptions(self.device_id, since_o.since)
# Update the "since" value in the database
self._store.update(since_o, since=result.since)
# Store received actions for later retrieval (and in case we
# have outdated actions in the database, simply remove them)
for url in result.add:
logger.debug('Received add action: %s', url)
self._store.remove(ReceivedSubscribeAction.remove(url))
self._store.remove(ReceivedSubscribeAction.add(url))
self._store.save(ReceivedSubscribeAction.add(url))
for url in result.remove:
logger.debug('Received remove action: %s', url)
self._store.remove(ReceivedSubscribeAction.add(url))
self._store.remove(ReceivedSubscribeAction.remove(url))
self._store.save(ReceivedSubscribeAction.remove(url))
# Step 2: Push updates to the server and rewrite URLs (if any)
actions = self._store.load(SubscribeAction)
add = [a.url for a in actions if a.is_add]
remove = [a.url for a in actions if a.is_remove]
if add or remove:
logger.debug('Uploading: +%d / -%d', len(add), len(remove))
# Only do a push request if something has changed
result = self._client.update_subscriptions(self.device_id, add, remove)
# Update the "since" value in the database
self._store.update(since_o, since=result.since)
# Store URL rewrites for later retrieval by GUI
for old_url, new_url in result.update_urls:
if new_url:
logger.debug('Rewritten URL: %s', new_url)
self._store.save(RewrittenUrl(old_url, new_url))
# Actions have been uploaded to the server - remove them
self._store.remove(actions)
logger.debug('All actions have been uploaded to the server.')
return True
except Exception, e:
logger.error('Cannot upload subscriptions: %s', str(e), exc_info=True)
return False
def update_device(self, action):
try:
logger.debug('Uploading device settings...')
self._client.update_device_settings(action.device_id, \
action.caption, action.device_type)
logger.debug('Device settings uploaded.')
return True
except Exception, e:
logger.error('Cannot update device %s: %s', self.device_id,
str(e), exc_info=True)
return False
def get_devices(self):
result = []
for d in self._client.get_devices():
result.append((d.device_id, d.caption, d.type))
return result
def open_website(self):
util.open_website('http://' + self._config.mygpo.server)
class Directory(object):
def __init__(self):
self.client = public.PublicClient()
def toplist(self):
return [(p.title or p.url, p.url)
for p in self.client.get_toplist()
if p.url]
def search(self, query):
return [(p.title or p.url, p.url)
for p in self.client.search_podcasts(query)
if p.url]
gpodder-3.1.2/src/gpodder/webui/ 0000775 0001750 0001750 00000000000 11760761026 016107 5 ustar thp thp 0000000 0000000 gpodder-3.1.2/src/gpodder/webui/__init__.py 0000664 0001750 0001750 00000007514 11751103635 020223 0 ustar thp thp 0000000 0000000 # -*- coding: utf-8 -*-
#
# gPodder - A media aggregator and podcast client
# Copyright (c) 2005-2012 Thomas Perl and the gPodder Team
#
# gPodder is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# gPodder is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see ; 2011-02-12
import gpodder
from gpodder import core
from gpodder import model
from gpodder import util
import BaseHTTPServer
try:
# For Python < 2.6, we use the "simplejson" add-on module
import simplejson as json
except ImportError:
# Python 2.6 already ships with a nice "json" module
import json
import os
import re
import sys
def to_json(o):
return dict((key, getattr(o, key)) for key in o.__slots__ + ('id',))
def json_response(path_parts):
core = WebUI.core
if path_parts == ['podcasts.json']:
return map(to_json, core.model.get_podcasts())
elif (len(path_parts) == 3 and path_parts[0] == 'podcast' and
path_parts[2] == 'episodes.json'):
podcast_id = int(path_parts[1])
for podcast in core.model.get_podcasts():
if podcast.id == podcast_id:
return map(to_json, podcast.get_all_episodes())
return None
class WebUI(BaseHTTPServer.BaseHTTPRequestHandler):
STATIC_PATH = os.path.join(gpodder.prefix, 'share', 'gpodder', 'ui', 'web')
DEFAULT_PORT = 8086
core = None
@classmethod
def run(cls, only_localhost=True, server_class=BaseHTTPServer.HTTPServer):
if only_localhost:
server_address = ('localhost', cls.DEFAULT_PORT)
else:
server_address = ('', cls.DEFAULT_PORT)
print >>sys.stderr, """
Server running. Point your web browser to:
http://localhost:%s/
Press Ctrl+C to stop the web server.
""" % (cls.DEFAULT_PORT,)
httpd = server_class(server_address, cls)
try:
httpd.serve_forever()
except KeyboardInterrupt:
del httpd
def do_GET(self):
if self.path == '/':
self.path = '/static/index.html'
path_parts = filter(None, self.path.split('/'))[1:]
if '..' not in path_parts:
if self.path.startswith('/static/'):
filename = os.path.join(self.STATIC_PATH, *path_parts)
_, extension = os.path.splitext(filename)
mimetype = util.mimetype_from_extension(extension)
self.send_response(200)
self.send_header('Content-type', mimetype)
self.end_headers()
self.wfile.write(open(filename).read())
self.wfile.close()
return
elif self.path.startswith('/json/'):
data = json_response(path_parts)
if data is not None:
self.send_response(200)
self.send_header('Content-type', 'application/json')
self.end_headers()
self.wfile.write(json.dumps(data))
self.wfile.close()
return
self.send_response(400)
self.send_header('Content-type', 'text/html')
self.end_headers()
self.wfile.write('Invalid request
')
self.wfile.close()
def main(only_localhost=True, core=None):
WebUI.core = core
return WebUI.run(only_localhost)
gpodder-3.1.2/src/gpodder/dbsqlite.py 0000664 0001750 0001750 00000021555 11751103635 017161 0 ustar thp thp 0000000 0000000 # -*- coding: utf-8 -*-
#
# gPodder - A media aggregator and podcast client
# Copyright (c) 2005-2012 Thomas Perl and the gPodder Team
#
# gPodder is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# gPodder is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see
# 2010-04-24 Thomas Perl
#
from __future__ import with_statement
import gpodder
_ = gpodder.gettext
import sys
from sqlite3 import dbapi2 as sqlite
import logging
logger = logging.getLogger(__name__)
from gpodder import schema
from gpodder import util
import threading
import re
class Database(object):
TABLE_PODCAST = 'podcast'
TABLE_EPISODE = 'episode'
def __init__(self, filename):
self.database_file = filename
self._db = None
self.lock = threading.RLock()
def close(self):
self.commit()
with self.lock:
cur = self.cursor()
cur.execute("VACUUM")
cur.close()
self._db.close()
self._db = None
def purge(self, max_episodes, podcast_id):
"""
Deletes old episodes. Should be called
before adding new episodes to a podcast.
"""
if max_episodes == 0:
return
with self.lock:
cur = self.cursor()
logger.debug('Purge requested for podcast %d', podcast_id)
sql = """
DELETE FROM %s
WHERE podcast_id = ?
AND state <> ?
AND id NOT IN
(SELECT id FROM %s WHERE podcast_id = ?
ORDER BY published DESC LIMIT ?)""" % (self.TABLE_EPISODE, self.TABLE_EPISODE)
cur.execute(sql, (podcast_id, gpodder.STATE_DOWNLOADED, podcast_id, max_episodes))
cur.close()
@property
def db(self):
if self._db is None:
self._db = sqlite.connect(self.database_file, check_same_thread=False)
# Check schema version, upgrade if necessary
schema.upgrade(self._db, self.database_file)
logger.debug('Database opened.')
return self._db
def cursor(self):
return self.db.cursor()
def commit(self):
with self.lock:
try:
logger.debug('Commit.')
self.db.commit()
except Exception, e:
logger.error('Cannot commit: %s', e, exc_info=True)
def get_content_types(self, id):
"""Given a podcast ID, returns the content types"""
with self.lock:
cur = self.cursor()
cur.execute('SELECT mime_type FROM %s WHERE podcast_id = ?' % self.TABLE_EPISODE, (id,))
for (mime_type,) in cur:
yield mime_type
cur.close()
def get_podcast_statistics(self, podcast_id=None):
"""Given a podcast ID, returns the statistics for it
If the podcast_id is omitted (using the default value), the
statistics will be calculated over all podcasts.
Returns a tuple (total, deleted, new, downloaded, unplayed)
"""
total, deleted, new, downloaded, unplayed = 0, 0, 0, 0, 0
with self.lock:
cur = self.cursor()
if podcast_id is not None:
cur.execute('SELECT COUNT(*), state, is_new FROM %s WHERE podcast_id = ? GROUP BY state, is_new' % self.TABLE_EPISODE, (podcast_id,))
else:
cur.execute('SELECT COUNT(*), state, is_new FROM %s GROUP BY state, is_new' % self.TABLE_EPISODE)
for count, state, is_new in cur:
total += count
if state == gpodder.STATE_DELETED:
deleted += count
elif state == gpodder.STATE_NORMAL and is_new:
new += count
elif state == gpodder.STATE_DOWNLOADED:
downloaded += count
if is_new:
unplayed += count
cur.close()
return (total, deleted, new, downloaded, unplayed)
def load_podcasts(self, factory):
logger.info('Loading podcasts')
sql = 'SELECT * FROM %s' % self.TABLE_PODCAST
with self.lock:
cur = self.cursor()
cur.execute(sql)
keys = [desc[0] for desc in cur.description]
result = map(lambda row: factory(dict(zip(keys, row)), self), cur)
cur.close()
return result
def load_episodes(self, podcast, factory):
assert podcast.id
logger.info('Loading episodes for podcast %d', podcast.id)
sql = 'SELECT * FROM %s WHERE podcast_id = ? ORDER BY published DESC' % self.TABLE_EPISODE
args = (podcast.id,)
with self.lock:
cur = self.cursor()
cur.execute(sql, args)
keys = [desc[0] for desc in cur.description]
result = map(lambda row: factory(dict(zip(keys, row))), cur)
cur.close()
return result
def delete_podcast(self, podcast):
assert podcast.id
with self.lock:
cur = self.cursor()
logger.debug('delete_podcast: %d (%s)', podcast.id, podcast.url)
cur.execute("DELETE FROM %s WHERE id = ?" % self.TABLE_PODCAST, (podcast.id, ))
cur.execute("DELETE FROM %s WHERE podcast_id = ?" % self.TABLE_EPISODE, (podcast.id, ))
cur.close()
self.db.commit()
def save_podcast(self, podcast):
self._save_object(podcast, self.TABLE_PODCAST, schema.PodcastColumns)
def save_episode(self, episode):
self._save_object(episode, self.TABLE_EPISODE, schema.EpisodeColumns)
def _save_object(self, o, table, columns):
with self.lock:
try:
cur = self.cursor()
values = [util.convert_bytes(getattr(o, name))
for name in columns]
if o.id is None:
qmarks = ', '.join('?'*len(columns))
sql = 'INSERT INTO %s (%s) VALUES (%s)' % (table, ', '.join(columns), qmarks)
cur.execute(sql, values)
o.id = cur.lastrowid
else:
qmarks = ', '.join('%s = ?' % name for name in columns)
values.append(o.id)
sql = 'UPDATE %s SET %s WHERE id = ?' % (table, qmarks)
cur.execute(sql, values)
except Exception, e:
logger.error('Cannot save %s: %s', o, e, exc_info=True)
cur.close()
def get(self, sql, params=None):
"""
Returns the first cell of a query result, useful for COUNT()s.
"""
with self.lock:
cur = self.cursor()
if params is None:
cur.execute(sql)
else:
cur.execute(sql, params)
row = cur.fetchone()
cur.close()
if row is None:
return None
else:
return row[0]
def podcast_download_folder_exists(self, foldername):
"""
Returns True if a foldername for a channel exists.
False otherwise.
"""
foldername = util.convert_bytes(foldername)
return self.get("SELECT id FROM %s WHERE download_folder = ?" %
self.TABLE_PODCAST, (foldername,)) is not None
def episode_filename_exists(self, podcast_id, filename):
"""
Returns True if a filename for an episode exists.
False otherwise.
"""
filename = util.convert_bytes(filename)
return self.get("SELECT id FROM %s WHERE podcast_id = ? AND download_filename = ?" %
self.TABLE_EPISODE, (podcast_id, filename,)) is not None
def get_last_published(self, podcast):
"""
Look up the most recent publish date of a podcast.
"""
return self.get('SELECT MAX(published) FROM %s WHERE podcast_id = ?' % self.TABLE_EPISODE, (podcast.id,))
def delete_episode_by_guid(self, guid, podcast_id):
"""
Deletes episodes that have a specific GUID for
a given channel. Used after feed updates for
episodes that have disappeared from the feed.
"""
guid = util.convert_bytes(guid)
with self.lock:
cur = self.cursor()
cur.execute('DELETE FROM %s WHERE podcast_id = ? AND guid = ?' %
self.TABLE_EPISODE, (podcast_id, guid))
gpodder-3.1.2/src/gpodder/qmlui/ 0000775 0001750 0001750 00000000000 11760761026 016123 5 ustar thp thp 0000000 0000000 gpodder-3.1.2/src/gpodder/qmlui/model.py 0000664 0001750 0001750 00000031644 11751103635 017601 0 ustar thp thp 0000000 0000000 # -*- coding: utf-8 -*-
#
# gPodder - A media aggregator and podcast client
# Copyright (c) 2005-2012 Thomas Perl and the gPodder Team
#
# gPodder is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# gPodder is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see ; 2011-02-06
from PySide.QtGui import QApplication
from PySide.QtCore import Qt, QObject, Signal, Slot, Property, QUrl
from PySide.QtCore import QAbstractListModel, QModelIndex
from PySide.QtDeclarative import QDeclarativeView
import os
import threading
import signal
import functools
import subprocess
import dbus
import dbus.service
from dbus.mainloop.glib import DBusGMainLoop
import gpodder
_ = gpodder.gettext
N_ = gpodder.ngettext
from gpodder import core
from gpodder import util
from gpodder import my
from gpodder import query
from gpodder.model import Model
from gpodder.qmlui import model
from gpodder.qmlui import helper
from gpodder.qmlui import images
import logging
logger = logging.getLogger("qmlui")
EPISODE_LIST_FILTERS = [
# (UI label, EQL expression)
(_('All'), None),
(_('Hide deleted'), 'not deleted'),
(_('New'), 'new or downloading'),
(_('Downloaded'), 'downloaded or downloading'),
(_('Deleted'), 'deleted'),
(_('Finished'), 'finished'),
(_('Archived'), 'downloaded and archive'),
(_('Videos'), 'video'),
]
class ConfigProxy(QObject):
def __init__(self, config):
QObject.__init__(self)
self._config = config
config.add_observer(self._on_config_changed)
def _on_config_changed(self, name, old_value, new_value):
if name == 'ui.qml.autorotate':
self.autorotateChanged.emit()
def get_autorotate(self):
return self._config.ui.qml.autorotate
def set_autorotate(self, autorotate):
self._config.ui.qml.autorotate = autorotate
autorotateChanged = Signal()
autorotate = Property(bool, get_autorotate, set_autorotate,
notify=autorotateChanged)
class Controller(QObject):
def __init__(self, root):
QObject.__init__(self)
self.root = root
self.context_menu_actions = []
self.episode_list_title = u''
self.current_input_dialog = None
self.root.config.add_observer(self.on_config_changed)
def on_config_changed(self, name, old_value, new_value):
logger.info('Config changed: %s (%s -> %s)', name,
old_value, new_value)
if name == 'mygpo.enabled':
self.myGpoEnabledChanged.emit()
elif name == 'mygpo.username':
self.myGpoUsernameChanged.emit()
elif name == 'mygpo.password':
self.myGpoPasswordChanged.emit()
elif name == 'mygpo.device.caption':
self.myGpoDeviceCaptionChanged.emit()
episodeListTitleChanged = Signal()
def setEpisodeListTitle(self, title):
if self.episode_list_title != title:
self.episode_list_title = title
self.episodeListTitleChanged.emit()
def getEpisodeListTitle(self):
return self.episode_list_title
episodeListTitle = Property(unicode, getEpisodeListTitle, \
setEpisodeListTitle, notify=episodeListTitleChanged)
@Slot(result='QStringList')
def getEpisodeListFilterNames(self):
return [caption for caption, eql in EPISODE_LIST_FILTERS]
@Slot('QVariant', str)
def multiEpisodeAction(self, selected, action):
if not selected:
return
count = len(selected)
episodes = map(self.root.episode_model.get_object_by_index, selected)
def delete():
for episode in episodes:
if not episode.qarchive:
episode.delete_episode()
self.update_subset_stats()
self.root.mygpo_client.on_delete(episodes)
self.root.mygpo_client.flush()
for episode in episodes:
self.root.on_episode_deleted(episode)
self.root.episode_model.sort()
if action == 'delete':
msg = N_('Delete %(count)d episode?', 'Delete %(count)d episodes?', count) % {'count':count}
self.confirm_action(msg, _('Delete'), delete)
elif action == 'download':
for episode in episodes:
if episode.qdownloaded:
print ' XXX already downloaded'
continue
episode.qdownload(self.root.config, self.update_subset_stats)
self.root.mygpo_client.on_download(episodes)
self.root.mygpo_client.flush()
elif action == 'play':
for episode in episodes:
self.root.enqueue_episode(episode)
@Slot(str, result=str)
def translate(self, x):
return _(x)
@Slot(str, str, int, result=str)
def ntranslate(self, singular, plural, count):
return N_(singular, plural, count)
@Slot(str, int, result=str)
def formatCount(self, template, count):
return template % {'count': count}
@Slot(result=str)
def getVersion(self):
return gpodder.__version__
@Slot(result=str)
def getReleased(self):
return gpodder.__date__
@Slot(result=unicode)
def getCredits(self):
credits_file = os.path.join(gpodder.prefix, 'share', 'gpodder', 'credits.txt')
return util.convert_bytes(open(credits_file).read())
@Slot(result=unicode)
def getCopyright(self):
return util.convert_bytes(gpodder.__copyright__)
@Slot(result=str)
def getLicense(self):
return gpodder.__license__
@Slot(result=str)
def getURL(self):
return gpodder.__url__
@Slot()
def loadLastEpisode(self):
self.root.load_last_episode()
@Slot(QObject, int, int)
def storePlaybackAction(self, episode, start, end):
if end - 5 < start:
logger.info('Ignoring too short playback action.')
return
total = episode.qduration
self.root.mygpo_client.on_playback_full(episode, start, end, total)
self.root.mygpo_client.flush()
@Slot(QObject)
def playVideo(self, episode):
"""Video Playback on MeeGo 1.2 Harmattan"""
if episode.qnew:
episode.toggle_new()
self.update_subset_stats()
url = episode.get_playback_url()
if gpodder.ui.harmattan:
subprocess.Popen(['video-suite', url])
else:
util.gui_open(url)
self.root.mygpo_client.on_playback([episode])
self.root.mygpo_client.flush()
@Slot(QObject)
def podcastSelected(self, podcast):
self.setEpisodeListTitle(podcast.qtitle)
self.root.select_podcast(podcast)
windowTitleChanged = Signal()
def getWindowTitle(self):
return self.root.view.windowTitle()
def setWindowTitle(self, windowTitle):
if gpodder.ui.fremantle:
self.root.view.setWindowTitle(windowTitle)
windowTitle = Property(unicode, getWindowTitle,
setWindowTitle, notify=windowTitleChanged)
@Slot()
def myGpoUploadList(self):
def upload_proc(self):
self.root.start_progress(_('Uploading subscriptions...'))
try:
try:
self.root.mygpo_client.set_subscriptions([podcast.url
for podcast in self.root.podcast_model.get_podcasts()])
except Exception, e:
self.root.show_message('\n'.join((_('Error on upload:'), unicode(e))))
finally:
self.root.end_progress()
t = threading.Thread(target=upload_proc, args=[self])
t.start()
@Slot()
def saveMyGpoSettings(self):
# Update the device settings and upload changes
self.root.mygpo_client.create_device()
self.root.mygpo_client.flush(now=True)
myGpoEnabledChanged = Signal()
def getMyGpoEnabled(self):
return self.root.config.mygpo.enabled
def setMyGpoEnabled(self, enabled):
self.root.config.mygpo.enabled = enabled
myGpoEnabled = Property(bool, getMyGpoEnabled,
setMyGpoEnabled, notify=myGpoEnabledChanged)
myGpoUsernameChanged = Signal()
def getMyGpoUsername(self):
return model.convert(self.root.config.mygpo.username)
def setMyGpoUsername(self, username):
self.root.config.mygpo.username = username
myGpoUsername = Property(unicode, getMyGpoUsername,
setMyGpoUsername, notify=myGpoUsernameChanged)
myGpoPasswordChanged = Signal()
def getMyGpoPassword(self):
return model.convert(self.root.config.mygpo.password)
def setMyGpoPassword(self, password):
self.root.config.mygpo.password = password
myGpoPassword = Property(unicode, getMyGpoPassword,
setMyGpoPassword, notify=myGpoPasswordChanged)
myGpoDeviceCaptionChanged = Signal()
def getMyGpoDeviceCaption(self):
return model.convert(self.root.config.mygpo.device.caption)
def setMyGpoDeviceCaption(self, caption):
self.root.config.mygpo.device.caption = caption
myGpoDeviceCaption = Property(unicode, getMyGpoDeviceCaption,
setMyGpoDeviceCaption, notify=myGpoDeviceCaptionChanged)
@Slot(QObject)
def podcastContextMenu(self, podcast):
menu = []
if isinstance(podcast, model.EpisodeSubsetView):
menu.append(helper.Action(_('Update all'), 'update-all', podcast))
else:
menu.append(helper.Action(_('Update'), 'update', podcast))
menu.append(helper.Action(_('Mark episodes as old'), 'mark-as-read', podcast))
menu.append(helper.Action(_('Rename'), 'rename-podcast', podcast))
menu.append(helper.Action(_('Change section'), 'change-section', podcast))
menu.append(helper.Action(_('Unsubscribe'), 'unsubscribe', podcast))
#menu.append(helper.Action('Force update all', 'force-update-all', podcast))
#menu.append(helper.Action('Force update', 'force-update', podcast))
self.show_context_menu(menu)
def show_context_menu(self, actions):
if gpodder.ui.harmattan:
actions = filter(lambda a: a.caption != '', actions)
self.context_menu_actions = actions
self.root.open_context_menu(self.context_menu_actions)
def update_subset_stats(self):
# This should be called when an episode changes state,
# so that all subset views (e.g. "All episodes") can
# update its status (i.e. download/new counts, etc..)
for podcast in self.root.podcast_model.get_objects():
if isinstance(podcast, model.EpisodeSubsetView):
podcast.qupdate()
def find_episode(self, podcast_url, episode_url):
for podcast in self.root.podcast_model.get_podcasts():
if podcast.url == podcast_url:
for episode in podcast.get_all_episodes():
if episode.url == episode_url:
return episode
return None
@Slot()
def updateAllPodcasts(self):
# Process episode actions received from gpodder.net
def merge_proc(self):
self.root.start_progress(_('Merging episode actions...'))
def find_episode(podcast_url, episode_url, counter):
counter['x'] += 1
self.root.start_progress(_('Merging episode actions (%d)')
% counter['x'])
return self.find_episode(podcast_url, episode_url)
try:
d = {'x': 0} # Used to "remember" the counter inside find_episode
self.root.mygpo_client.process_episode_actions(lambda x, y:
find_episode(x, y, d))
finally:
self.root.end_progress()
t = threading.Thread(target=merge_proc, args=[self])
t.start()
for podcast in self.root.podcast_model.get_objects():
podcast.qupdate(finished_callback=self.update_subset_stats)
@Slot(int)
def contextMenuResponse(self, index):
assert index < len(self.context_menu_actions)
action = self.context_menu_actions[index]
if action.action == 'update':
action.target.qupdate(finished_callback=self.update_subset_stats)
elif action.action == 'force-update':
action.target.qupdate(force=True, \
finished_callback=self.update_subset_stats)
elif action.action == 'update-all':
self.updateAllPodcasts()
elif action.action == 'force-update-all':
for podcast in self.root.podcast_model.get_objects():
podcast.qupdate(force=True, finished_callback=self.update_subset_stats)
if action.action == 'unsubscribe':
def unsubscribe():
action.target.remove_downloaded()
action.target.delete()
self.root.remove_podcast(action.target)
self.confirm_action(_('Remove this podcast and episodes?'),
_('Unsubscribe'), unsubscribe)
elif action.action == 'episode-toggle-new':
action.target.toggle_new()
self.update_subset_stats()
elif action.action == 'episode-toggle-archive':
action.target.toggle_archive()
self.update_subset_stats()
elif action.action == 'episode-delete':
self.deleteEpisode(action.target)
elif action.action == 'episode-enqueue':
self.root.enqueue_episode(action.target)
elif action.action == 'mark-as-read':
for episode in action.target.get_all_episodes():
if not episode.was_downloaded(and_exists=True):
episode.mark(is_played=True)
action.target.changed.emit()
self.update_subset_stats()
elif action.action == 'change-section':
def section_changer(podcast):
section = yield (_('New section name:'), podcast.section,
_('Rename'))
if section and section != podcast.section:
podcast.set_section(section)
self.root.resort_podcast_list()
self.start_input_dialog(section_changer(action.target))
elif action.action == 'rename-podcast':
def title_changer(podcast):
title = yield (_('New name:'), podcast.title,
_('Rename'))
if title and title != podcast.title:
podcast.rename(title)
self.root.resort_podcast_list()
self.start_input_dialog(title_changer(action.target))
def confirm_action(self, message, affirmative, callback):
def confirm(message, affirmative, callback):
args = (message, '', affirmative, _('Cancel'), False)
if (yield args):
callback()
self.start_input_dialog(confirm(message, affirmative, callback))
def start_input_dialog(self, generator):
"""Carry out an input dialog with the UI
This function takes a generator function as argument
which should yield a tuple of arguments for the
"show_input_dialog" function (i.e. message, default
value, accept and reject message - only the message
is mandatory, the other arguments have default values).
The generator will receive the user's response as a
result of the yield expression. If the user accepted
the dialog, a string is returned (the value that has
been input), otherwise None is returned.
Example usage:
def some_function():
result = yield ('A simple message', 'default value')
if result is None:
# user has rejected the dialog
else:
# user has accepted, new value in "result"
start_input_dialog(some_function())
"""
assert self.current_input_dialog is None
self.current_input_dialog = generator
args = generator.next()
self.root.show_input_dialog(*args)
@Slot(bool, str, bool)
def inputDialogResponse(self, accepted, value, is_text):
if not is_text:
value = accepted
elif not accepted:
value = None
try:
self.current_input_dialog.send(value)
except StopIteration:
# This is expected, as the generator
# should only have one yield statement
pass
self.current_input_dialog = None
@Slot(QObject)
def downloadEpisode(self, episode):
episode.qdownload(self.root.config, self.update_subset_stats)
self.root.mygpo_client.on_download([episode])
self.root.mygpo_client.flush()
@Slot(QObject)
def cancelDownload(self, episode):
episode.download_task.cancel()
episode.download_task.removed_from_list()
@Slot(QObject)
def deleteEpisode(self, episode):
def delete():
episode.delete_episode()
self.update_subset_stats()
self.root.mygpo_client.on_delete([episode])
self.root.mygpo_client.flush()
self.root.on_episode_deleted(episode)
self.root.episode_model.sort()
self.confirm_action(_('Delete this episode?'), _('Delete'), delete)
@Slot(QObject)
def acquireEpisode(self, episode):
self.root.add_active_episode(episode)
@Slot(QObject)
def releaseEpisode(self, episode):
self.root.remove_active_episode(episode)
@Slot()
def contextMenuClosed(self):
self.context_menu_actions = []
@Slot(QObject)
def episodeContextMenu(self, episode):
menu = []
toggle_new = _('Mark as old') if episode.is_new else _('Mark as new')
menu.append(helper.Action(toggle_new, 'episode-toggle-new', episode))
toggle_archive = _('Allow deletion') if episode.archive else _('Archive')
menu.append(helper.Action(toggle_archive, 'episode-toggle-archive', episode))
if episode.state != gpodder.STATE_DELETED:
menu.append(helper.Action(_('Delete'), 'episode-delete', episode))
menu.append(helper.Action(_('Add to play queue'), 'episode-enqueue', episode))
self.show_context_menu(menu)
@Slot('QVariant')
def addSubscriptions(self, urls):
def not_yet_subscribed(url):
for podcast in self.root.podcast_model.get_objects():
if isinstance(podcast, model.EpisodeSubsetView):
continue
if podcast.url == url:
logger.info('Already subscribed: %s', url)
return False
return True
urls = map(util.normalize_feed_url, urls)
urls = filter(not_yet_subscribed, urls)
def subscribe_proc(self, urls):
self.root.start_progress(_('Adding podcasts...'))
try:
for idx, url in enumerate(urls):
print idx, url
self.root.start_progress(_('Adding podcasts...') + ' (%d/%d)' % (idx, len(urls)))
try:
podcast = self.root.model.load_podcast(url=url, create=True,
max_episodes=self.root.config.max_episodes_per_feed)
podcast.save()
self.root.insert_podcast(model.QPodcast(podcast))
except Exception, e:
logger.warn('Cannot add pocast: %s', e)
# XXX: Visual feedback in the QML UI
finally:
self.root.end_progress()
t = threading.Thread(target=subscribe_proc, args=[self, urls])
t.start()
@Slot()
def currentEpisodeChanging(self):
self.root.save_pending_data()
@Slot()
def quit(self):
self.root.quit.emit()
@Slot()
def switcher(self):
if gpodder.ui.harmattan:
self.root.view.showMinimized()
elif gpodder.ui.fremantle:
os.system('dbus-send /com/nokia/hildon_desktop '+
'com.nokia.hildon_desktop.exit_app_view')
else:
self.root.view.showMinimized()
class gPodderListModel(QAbstractListModel):
def __init__(self, objects=None):
QAbstractListModel.__init__(self)
if objects is None:
objects = []
self._objects = objects
self.setRoleNames({0: 'modelData', 1: 'section'})
def sort(self):
# Unimplemented for the generic list model
self.reset()
def insert_object(self, o):
self._objects.append(o)
self.sort()
def remove_object(self, o):
self._objects.remove(o)
self.reset()
def set_objects(self, objects):
self._objects = objects
self.sort()
def get_objects(self):
return self._objects
def get_object(self, index):
return self._objects[index.row()]
def rowCount(self, parent=QModelIndex()):
return len(self.get_objects())
def data(self, index, role):
if index.isValid():
if role == 0:
return self.get_object(index)
elif role == 1:
return self.get_object(index).qsection
return None
class gPodderPodcastListModel(gPodderListModel):
def set_podcasts(self, db, podcasts):
views = [
model.EpisodeSubsetView(db, self, _('All episodes'), ''),
]
self.set_objects(views + podcasts)
def get_podcasts(self):
return filter(lambda podcast: isinstance(podcast, model.QPodcast),
self.get_objects())
def sort(self):
self._objects = sorted(self._objects, key=model.QPodcast.sort_key)
self.reset()
class gPodderEpisodeListModel(gPodderListModel):
def __init__(self, config):
gPodderListModel.__init__(self)
self._filter = config.ui.qml.state.episode_list_filter
self._filtered = []
self._config = config
config.add_observer(self._on_config_changed)
def _on_config_changed(self, name, old_value, new_value):
if name == 'ui.qml.state.episode_list_filter':
self._filter = new_value
self.sort()
def sort(self):
caption, eql = EPISODE_LIST_FILTERS[self._filter]
if eql is None:
self._filtered = self._objects
else:
eql = query.EQL(eql)
match = lambda episode: eql.match(episode._episode)
self._filtered = filter(match, self._objects)
self.reset()
def get_objects(self):
return self._filtered
def get_object(self, index):
return self._filtered[index.row()]
@Slot(int, result=QObject)
def get_object_by_index(self, index):
return self._filtered[int(index)]
@Slot(result=int)
def getFilter(self):
return self._filter
@Slot(int)
def setFilter(self, filter_index):
self._config.ui.qml.state.episode_list_filter = filter_index
def QML(filename):
for folder in gpodder.ui_folders:
filename = os.path.join(folder, filename)
if os.path.exists(filename):
return filename
class DeclarativeView(QDeclarativeView):
def __init__(self):
QDeclarativeView.__init__(self)
self.setAttribute(Qt.WA_OpaquePaintEvent)
self.setAttribute(Qt.WA_NoSystemBackground)
self.viewport().setAttribute(Qt.WA_OpaquePaintEvent)
self.viewport().setAttribute(Qt.WA_NoSystemBackground)
closing = Signal()
def closeEvent(self, event):
self.closing.emit()
event.ignore()
class qtPodder(QObject):
def __init__(self, args, gpodder_core, dbus_bus_name):
QObject.__init__(self)
self.dbus_bus_name = dbus_bus_name
# TODO: Expose the same D-Bus API as the Gtk UI D-Bus object (/gui)
# TODO: Create a gpodder.dbusproxy.DBusPodcastsProxy object (/podcasts)
# Enable OpenGL rendering without requiring QtOpenGL
# On Harmattan we let the system choose the best graphicssystem
if '-graphicssystem' not in args and not gpodder.ui.harmattan:
if gpodder.ui.fremantle:
args += ['-graphicssystem', 'opengl']
elif not gpodder.win32:
args += ['-graphicssystem', 'raster']
self.app = QApplication(args)
signal.signal(signal.SIGINT, signal.SIG_DFL)
self.quit.connect(self.on_quit)
self.core = gpodder_core
self.config = self.core.config
self.db = self.core.db
self.model = self.core.model
self.config_proxy = ConfigProxy(self.config)
# Initialize the gpodder.net client
self.mygpo_client = my.MygPoClient(self.config)
gpodder.user_extensions.on_ui_initialized(self.model,
self.extensions_podcast_update_cb,
self.extensions_episode_download_cb)
self.view = DeclarativeView()
self.view.closing.connect(self.on_quit)
self.view.setResizeMode(QDeclarativeView.SizeRootObjectToView)
self.controller = Controller(self)
self.media_buttons_handler = helper.MediaButtonsHandler()
self.tracker_miner_config = helper.TrackerMinerConfig()
self.podcast_model = gPodderPodcastListModel()
self.episode_model = gPodderEpisodeListModel(self.config)
self.last_episode = None
# A dictionary of episodes that are currently active
# in some way (i.e. playing back or downloading)
self.active_episode_wrappers = {}
engine = self.view.engine()
# Maemo 5: Experimental Qt Mobility packages are installed in /opt
if gpodder.ui.fremantle:
for path in ('/opt/qtm11/imports', '/opt/qtm12/imports'):
engine.addImportPath(path)
elif gpodder.win32:
for path in (r'C:\QtSDK\Desktop\Qt\4.7.4\msvc2008\imports',):
engine.addImportPath(path)
# Add the cover art image provider
self.cover_provider = images.LocalCachedImageProvider()
engine.addImageProvider('cover', self.cover_provider)
root_context = self.view.rootContext()
root_context.setContextProperty('controller', self.controller)
root_context.setContextProperty('configProxy', self.config_proxy)
root_context.setContextProperty('mediaButtonsHandler',
self.media_buttons_handler)
root_context.setContextProperty('trackerMinerConfig',
self.tracker_miner_config)
# Load the QML UI (this could take a while...)
self.view.setSource(QUrl.fromLocalFile(QML('main_default.qml')))
# Proxy to the "main" QML object for direct access to Qt Properties
self.main = helper.QObjectProxy(self.view.rootObject().property('main'))
self.main.podcastModel = self.podcast_model
self.main.episodeModel = self.episode_model
self.view.setWindowTitle('gPodder')
if gpodder.ui.harmattan:
self.view.showFullScreen()
elif gpodder.ui.fremantle:
self.view.setAttribute(Qt.WA_Maemo5AutoOrientation, True)
self.view.showFullScreen()
else:
# On the Desktop, scale to fit my small laptop screen..
desktop = self.app.desktop()
if desktop.height() < 1000:
FACTOR = .8
self.view.scale(FACTOR, FACTOR)
size = self.view.size()
size *= FACTOR
self.view.resize(size)
self.view.show()
self.do_start_progress.connect(self.on_start_progress)
self.do_end_progress.connect(self.on_end_progress)
self.do_show_message.connect(self.on_show_message)
self.load_podcasts()
def add_active_episode(self, episode):
self.active_episode_wrappers[episode.id] = episode
episode.episode_wrapper_refcount += 1
def remove_active_episode(self, episode):
episode.episode_wrapper_refcount -= 1
if episode.episode_wrapper_refcount == 0:
del self.active_episode_wrappers[episode.id]
def load_last_episode(self):
last_episode = None
last_podcast = None
for podcast in self.podcast_model.get_podcasts():
for episode in podcast.get_all_episodes():
if not episode.last_playback:
continue
if last_episode is None or \
episode.last_playback > last_episode.last_playback:
last_episode = episode
last_podcast = podcast
if last_episode is not None:
self.last_episode = self.wrap_episode(last_podcast, last_episode)
# FIXME: Send last episode to player
#self.select_episode(self.last_episode)
def on_episode_deleted(self, episode):
# Remove episode from play queue (if it's in there)
self.main.removeQueuedEpisode(episode)
# If the episode that has been deleted is currently
# being played back (or paused), stop playback now.
if self.main.currentEpisode == episode:
self.main.togglePlayback(None)
def enqueue_episode(self, episode):
self.main.enqueueEpisode(episode)
def run(self):
return self.app.exec_()
quit = Signal()
def on_quit(self):
# Make sure the audio playback is stopped immediately
self.main.togglePlayback(None)
self.save_pending_data()
self.view.hide()
self.core.shutdown()
self.app.quit()
do_show_message = Signal(unicode)
@Slot(unicode)
def on_show_message(self, message):
self.main.showMessage(message)
def show_message(self, message):
self.do_show_message.emit(message)
def show_input_dialog(self, message, value='', accept=_('OK'),
reject=_('Cancel'), is_text=True):
self.main.showInputDialog(message, value, accept, reject, is_text)
def open_context_menu(self, items):
self.main.openContextMenu(items)
do_start_progress = Signal(str)
@Slot(str)
def on_start_progress(self, text):
self.main.startProgress(text)
def start_progress(self, text=_('Please wait...')):
self.do_start_progress.emit(text)
do_end_progress = Signal()
@Slot()
def on_end_progress(self):
self.main.endProgress()
def end_progress(self):
self.do_end_progress.emit()
def resort_podcast_list(self):
self.podcast_model.sort()
def insert_podcast(self, podcast):
self.podcast_model.insert_object(podcast)
self.mygpo_client.on_subscribe([podcast.url])
self.mygpo_client.flush()
def remove_podcast(self, podcast):
# Remove queued episodes for this specific podcast
self.main.removeQueuedEpisodesForPodcast(podcast)
if self.main.currentEpisode is not None:
# If the currently-playing episode is in the podcast
# that is to be deleted, stop playback immediately.
if self.main.currentEpisode.qpodcast == podcast:
self.main.togglePlayback(None)
self.podcast_model.remove_object(podcast)
self.mygpo_client.on_unsubscribe([podcast.url])
self.mygpo_client.flush()
def load_podcasts(self):
podcasts = map(model.QPodcast, self.model.get_podcasts())
self.podcast_model.set_podcasts(self.db, podcasts)
def wrap_episode(self, podcast, episode):
try:
return self.active_episode_wrappers[episode.id]
except KeyError:
return model.QEpisode(self, podcast, episode)
def select_podcast(self, podcast):
if isinstance(podcast, model.QPodcast):
# Normal QPodcast instance
wrap = functools.partial(self.wrap_episode, podcast)
objects = podcast.get_all_episodes()
else:
# EpisodeSubsetView
wrap = lambda args: self.wrap_episode(*args)
objects = podcast.get_all_episodes_with_podcast()
self.episode_model.set_objects(map(wrap, objects))
self.main.state = 'episodes'
def save_pending_data(self):
current_ep = self.main.currentEpisode
if isinstance(current_ep, model.QEpisode):
current_ep.save()
def podcast_to_qpodcast(self, podcast):
podcasts = filter(lambda p: p._podcast == podcast,
self.podcast_model.get_podcasts())
assert len(podcasts) <= 1
if podcasts:
return podcasts[0]
return None
def extensions_podcast_update_cb(self, podcast):
logger.debug('extensions_podcast_update_cb(%s)', podcast)
try:
qpodcast = self.podcast_to_qpodcast(podcast)
if qpodcast is not None:
qpodcast.qupdate(
finished_callback=self.controller.update_subset_stats)
except Exception, e:
logger.exception('extensions_podcast_update_cb(%s): %s', podcast, e)
def extensions_episode_download_cb(self, episode):
logger.debug('extensions_episode_download_cb(%s)', episode)
try:
qpodcast = self.podcast_to_qpodcast(episode.channel)
qepisode = self.wrap_episode(qpodcast, episode)
self.controller.downloadEpisode(qepisode)
except Exception, e:
logger.exception('extensions_episode_download_cb(%s): %s', episode, e)
def main(args):
try:
dbus_main_loop = DBusGMainLoop(set_as_default=True)
gpodder.dbus_session_bus = dbus.SessionBus(dbus_main_loop)
bus_name = dbus.service.BusName(gpodder.dbus_bus_name,
bus=gpodder.dbus_session_bus)
except dbus.exceptions.DBusException, dbe:
logger.warn('Cannot get "on the bus".', exc_info=True)
bus_name = None
gui = qtPodder(args, core.Core(), bus_name)
return gui.run()
gpodder-3.1.2/src/gpodder/qmlui/helper.py 0000664 0001750 0001750 00000014007 11760760347 017763 0 ustar thp thp 0000000 0000000 # -*- coding: utf-8 -*-
#
# gPodder - A media aggregator and podcast client
# Copyright (c) 2005-2012 Thomas Perl and the gPodder Team
#
# gPodder is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# gPodder is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see 2009-03-31
#
import gtk
import gobject
import pango
import cgi
class SimpleMessageArea(gtk.HBox):
"""A simple, yellow message area. Inspired by gedit.
Original C source code:
http://svn.gnome.org/viewvc/gedit/trunk/gedit/gedit-message-area.c
"""
def __init__(self, message, buttons=()):
gtk.HBox.__init__(self, spacing=6)
self.set_border_width(6)
self.__in_style_set = False
self.connect('style-set', self.__style_set)
self.connect('expose-event', self.__expose_event)
self.__label = gtk.Label()
self.__label.set_alignment(0.0, 0.5)
self.__label.set_line_wrap(False)
self.__label.set_ellipsize(pango.ELLIPSIZE_END)
self.__label.set_markup('%s ' % cgi.escape(message))
self.pack_start(self.__label, expand=True, fill=True)
hbox = gtk.HBox()
for button in buttons:
hbox.pack_start(button, expand=True, fill=False)
self.pack_start(hbox, expand=False, fill=False)
def set_markup(self, markup, line_wrap=True, min_width=3, max_width=100):
# The longest line should determine the size of the label
width_chars = max(len(line) for line in markup.splitlines())
# Enforce upper and lower limits for the width
width_chars = max(min_width, min(max_width, width_chars))
self.__label.set_width_chars(width_chars)
self.__label.set_markup(markup)
self.__label.set_line_wrap(line_wrap)
def __style_set(self, widget, previous_style):
if self.__in_style_set:
return
w = gtk.Window(gtk.WINDOW_POPUP)
w.set_name('gtk-tooltip')
w.ensure_style()
style = w.get_style()
self.__in_style_set = True
self.set_style(style)
self.__label.set_style(style)
self.__in_style_set = False
w.destroy()
self.queue_draw()
def __expose_event(self, widget, event):
style = widget.get_style()
rect = widget.get_allocation()
style.paint_flat_box(widget.window, gtk.STATE_NORMAL,
gtk.SHADOW_OUT, None, widget, "tooltip",
rect.x, rect.y, rect.width, rect.height)
return False
class SpinningProgressIndicator(gtk.Image):
# Progress indicator loading inspired by glchess from gnome-games-clutter
def __init__(self, size=32):
gtk.Image.__init__(self)
self._frames = []
self._frame_id = 0
# Load the progress indicator
icon_theme = gtk.icon_theme_get_default()
try:
icon = icon_theme.load_icon('process-working', size, 0)
width, height = icon.get_width(), icon.get_height()
if width < size or height < size:
size = min(width, height)
for row in range(height/size):
for column in range(width/size):
frame = icon.subpixbuf(column*size, row*size, size, size)
self._frames.append(frame)
# Remove the first frame (the "idle" icon)
if self._frames:
self._frames.pop(0)
self.step_animation()
except:
# FIXME: This is not very beautiful :/
self.set_from_stock(gtk.STOCK_EXECUTE, gtk.ICON_SIZE_BUTTON)
def step_animation(self):
if len(self._frames) > 1:
self._frame_id += 1
if self._frame_id >= len(self._frames):
self._frame_id = 0
self.set_from_pixbuf(self._frames[self._frame_id])
gpodder-3.1.2/src/gpodder/gtkui/desktopfile.py 0000664 0001750 0001750 00000011573 11751103635 021005 0 ustar thp thp 0000000 0000000 # -*- coding: utf-8 -*-
#
# gPodder - A media aggregator and podcast client
# Copyright (c) 2005-2012 Thomas Perl and the gPodder Team
#
# gPodder is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# gPodder is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see 20060329
#
#
import glob
import os.path
import threading
from ConfigParser import RawConfigParser
import gobject
import gtk
import gtk.gdk
import gpodder
_ = gpodder.gettext
# where are the .desktop files located?
userappsdirs = [ '/usr/share/applications/', '/usr/local/share/applications/', '/usr/share/applications/kde/' ]
# the name of the section in the .desktop files
sect = 'Desktop Entry'
class PlayerListModel(gtk.ListStore):
C_ICON, C_NAME, C_COMMAND, C_CUSTOM = range(4)
def __init__(self):
gtk.ListStore.__init__(self, gtk.gdk.Pixbuf, str, str, bool)
def insert_app(self, pixbuf, name, command):
self.append((pixbuf, name, command, False))
def get_command(self, index):
return self[index][self.C_COMMAND]
def get_index(self, value):
for index, row in enumerate(self):
if value == row[self.C_COMMAND]:
return index
last_row = self[-1]
name = _('Command: %s') % value
if last_row[self.C_CUSTOM]:
last_row[self.C_COMMAND] = value
last_row[self.C_NAME] = name
else:
self.append((None, name, value, True))
return len(self)-1
@classmethod
def is_separator(cls, model, iter):
return model.get_value(iter, cls.C_COMMAND) == ''
class UserApplication(object):
def __init__(self, name, cmd, mime, icon):
self.name = name
self.cmd = cmd
self.icon = icon
self.mime = mime
def get_icon(self):
if self.icon is not None:
# Load it from an absolute filename
if os.path.exists(self.icon):
try:
return gtk.gdk.pixbuf_new_from_file_at_size(self.icon, 24, 24)
except gobject.GError, ge:
pass
# Load it from the current icon theme
(icon_name, extension) = os.path.splitext(os.path.basename(self.icon))
theme = gtk.IconTheme()
if theme.has_icon(icon_name):
return theme.load_icon(icon_name, 24, 0)
def is_mime(self, mimetype):
return self.mime.find(mimetype+'/') != -1
class UserAppsReader(object):
def __init__(self, mimetypes):
self.apps = []
self.mimetypes = mimetypes
self.__has_read = False
self.__finished = threading.Event()
self.__has_sep = False
self.apps.append(UserApplication(_('Default application'), 'default', ';'.join((mime+'/*' for mime in self.mimetypes)), gtk.STOCK_OPEN))
def add_separator(self):
self.apps.append(UserApplication('', '', ';'.join((mime+'/*' for mime in self.mimetypes)), ''))
self.__has_sep = True
def read( self):
if self.__has_read:
return
self.__has_read = True
for dir in userappsdirs:
if os.path.exists( dir):
for file in glob.glob(os.path.join(dir, '*.desktop')):
self.parse_and_append( file)
self.__finished.set()
def parse_and_append( self, filename):
try:
parser = RawConfigParser()
parser.read([filename])
if not parser.has_section(sect):
return
# Find out if we need it by comparing mime types
app_mime = parser.get(sect, 'MimeType')
for needed_type in self.mimetypes:
if app_mime.find(needed_type+'/') != -1:
app_name = parser.get(sect, 'Name')
app_cmd = parser.get(sect, 'Exec')
app_icon = parser.get(sect, 'Icon')
if not self.__has_sep:
self.add_separator()
self.apps.append(UserApplication(app_name, app_cmd, app_mime, app_icon))
return
except:
return
def get_model(self, mimetype):
self.__finished.wait()
model = PlayerListModel()
for app in self.apps:
if app.is_mime(mimetype):
model.insert_app(app.get_icon(), app.name, app.cmd)
return model
gpodder-3.1.2/src/gpodder/gtkui/services.py 0000664 0001750 0001750 00000011104 11751103635 020305 0 ustar thp thp 0000000 0000000 # -*- coding: utf-8 -*-
#
# gPodder - A media aggregator and podcast client
# Copyright (c) 2005-2012 Thomas Perl and the gPodder Team
#
# gPodder is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# gPodder is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see %s ' % (
cgi.escape(container.metadata.title),
cgi.escape(container.metadata.description))
self.extensions_model.append([container.enabled, label, container])
self.extensions_model.set_sort_column_id(self.C_LABEL, gtk.SORT_ASCENDING)
self.treeviewExtensions.set_model(self.extensions_model)
self.treeviewExtensions.columns_autosize()
def on_extensions_cell_toggled(self, cell, path):
model = self.treeviewExtensions.get_model()
it = model.get_iter(path)
container = model.get_value(it, self.C_EXTENSION)
enabled_extensions = list(self._config.extensions.enabled)
new_enabled = not model.get_value(it, self.C_TOGGLE)
if new_enabled and container.name not in enabled_extensions:
enabled_extensions.append(container.name)
elif not new_enabled and container.name in enabled_extensions:
enabled_extensions.remove(container.name)
self._config.extensions.enabled = enabled_extensions
now_enabled = (container.name in self._config.extensions.enabled)
if new_enabled == now_enabled:
model.set_value(it, self.C_TOGGLE, new_enabled)
elif container.error is not None:
self.show_message(container.error.message,
_('Extension cannot be activated'), important=True)
model.set_value(it, self.C_TOGGLE, False)
def on_extensions_row_activated(self, treeview, path, view_column):
model = treeview.get_model()
container = model.get_value(model.get_iter(path), self.C_EXTENSION)
# This is one ugly hack, but it displays the container's attributes
# and the attributes of the metadata object of the container..
info = '\n'.join('%s: %s' %
tuple(map(cgi.escape, map(str, (key, value))))
for key, value in sorted(container.__dict__.items() +
[('metadata.'+k, v)
for k, v in container.metadata.__dict__.items()]))
self.show_message(info, _('Extension module info'), important=True)
def on_dialog_destroy(self, widget):
# Re-enable mygpo sync if the user has selected it
self._config.mygpo.enabled = self._enable_mygpo
# Make sure the device is successfully created/updated
self.mygpo_client.create_device()
# Flush settings for mygpo client now
self.mygpo_client.flush(now=True)
def on_button_close_clicked(self, widget):
self.main_window.destroy()
def on_button_advanced_clicked(self, widget):
self.main_window.destroy()
gPodderConfigEditor(self.parent_window, _config=self._config)
def on_combo_audio_player_app_changed(self, widget):
index = self.combo_audio_player_app.get_active()
self._config.player = self.audio_player_model.get_command(index)
def on_combo_video_player_app_changed(self, widget):
index = self.combo_video_player_app.get_active()
self._config.videoplayer = self.video_player_model.get_command(index)
def on_button_audio_player_clicked(self, widget):
result = self.show_text_edit_dialog(_('Configure audio player'), \
_('Command:'), \
self._config.player)
if result:
self._config.player = result
index = self.audio_player_model.get_index(self._config.player)
self.combo_audio_player_app.set_active(index)
def on_button_video_player_clicked(self, widget):
result = self.show_text_edit_dialog(_('Configure video player'), \
_('Command:'), \
self._config.videoplayer)
if result:
self._config.videoplayer = result
index = self.video_player_model.get_index(self._config.videoplayer)
self.combo_video_player_app.set_active(index)
def format_update_interval_value(self, scale, value):
value = int(value)
if value == 0:
return _('manually')
elif value > 0 and len(self.update_interval_presets) > value:
return util.format_seconds_to_hour_min_sec(self.update_interval_presets[value]*60)
else:
return str(value)
def on_update_interval_value_changed(self, range):
value = int(range.get_value())
self._config.auto_update_feeds = (value > 0)
self._config.auto_update_frequency = self.update_interval_presets[value]
def on_combo_auto_download_changed(self, widget):
index = self.combo_auto_download.get_active()
self.auto_download_model.set_index(index)
def format_expiration_value(self, scale, value):
value = int(value)
if value == 0:
return _('manually')
else:
return N_('after %(count)d day', 'after %(count)d days', value) % {'count':value}
def on_expiration_value_changed(self, range):
value = int(range.get_value())
if value == 0:
self.checkbutton_expiration_unplayed.set_active(False)
self._config.auto_remove_played_episodes = False
self._config.auto_remove_unplayed_episodes = False
else:
self._config.auto_remove_played_episodes = True
self._config.episode_old_age = value
self.checkbutton_expiration_unplayed.set_sensitive(value > 0)
self.checkbutton_expiration_unfinished.set_sensitive(value > 0)
def on_enabled_toggled(self, widget):
# Only update indirectly (see on_dialog_destroy)
self._enable_mygpo = widget.get_active()
def on_username_changed(self, widget):
self._config.mygpo.username = widget.get_text()
def on_password_changed(self, widget):
self._config.mygpo.password = widget.get_text()
def on_device_caption_changed(self, widget):
self._config.mygpo.device.caption = widget.get_text()
def on_button_overwrite_clicked(self, button):
title = _('Replace subscription list on server')
message = _('Remote podcasts that have not been added locally will be removed on the server. Continue?')
if self.show_confirmation(message, title):
def thread_proc():
self._config.mygpo.enabled = True
self.on_send_full_subscriptions()
self._config.mygpo.enabled = False
threading.Thread(target=thread_proc).start()
gpodder-3.1.2/src/gpodder/gtkui/desktop/welcome.py 0000664 0001750 0001750 00000002601 11751103635 021570 0 ustar thp thp 0000000 0000000 # -*- coding: utf-8 -*-
#
# gPodder - A media aggregator and podcast client
# Copyright (c) 2005-2012 Thomas Perl and the gPodder Team
#
# gPodder is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# gPodder is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see %s
%s (%s)
%s
"""
class gPodderShownotes(gPodderShownotesBase):
def on_create_window(self):
self.textview.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse('#ffffff'))
if self._config.enable_html_shownotes:
try:
import webkit
webview_signals = gobject.signal_list_names(webkit.WebView)
if 'navigation-policy-decision-requested' in webview_signals:
setattr(self, 'have_webkit', True)
setattr(self, 'htmlview', webkit.WebView())
else:
logger.warn('Your WebKit is too old (gPodder bug 1001).')
setattr(self, 'have_webkit', False)
def navigation_policy_decision(wv, fr, req, action, decision):
REASON_LINK_CLICKED, REASON_OTHER = 0, 5
if action.get_reason() == REASON_LINK_CLICKED:
util.open_website(req.get_uri())
decision.ignore()
elif action.get_reason() == REASON_OTHER:
decision.use()
else:
decision.ignore()
self.htmlview.connect('navigation-policy-decision-requested', \
navigation_policy_decision)
self.scrolled_window.remove(self.scrolled_window.get_child())
self.scrolled_window.add(self.htmlview)
self.textview = None
self.htmlview.load_html_string('', '')
self.htmlview.show()
except ImportError:
setattr(self, 'have_webkit', False)
else:
setattr(self, 'have_webkit', False)
def on_scroll_down(self):
if not hasattr(self.scrolled_window, 'get_vscrollbar'):
return
vsb = self.scrolled_window.get_vscrollbar()
vadj = vsb.get_adjustment()
step = vadj.step_increment
vsb.set_value(vsb.get_value() + step)
def on_scroll_up(self):
if not hasattr(self.scrolled_window, 'get_vscrollbar'):
return
vsb = self.scrolled_window.get_vscrollbar()
vadj = vsb.get_adjustment()
step = vadj.step_increment
vsb.set_value(vsb.get_value() - step)
def on_show_window(self):
self.download_progress.set_fraction(0)
self.download_progress.set_text(_('Please wait...'))
self.main_window.set_title(self.episode.title)
if self.have_webkit:
self.htmlview.load_html_string('%s ' % _('Loading shownotes...'), '')
else:
self.b = gtk.TextBuffer()
self.textview.set_buffer(self.b)
def on_display_text(self):
# Now do the stuff that takes a bit longer...
heading = self.episode.title
subheading = _('from %s') % (self.episode.channel.title)
description = self.episode.description
if self.have_webkit:
global SHOWNOTES_HTML_TEMPLATE
# Get the description - if it looks like plaintext, replace the
# newline characters with line breaks for the HTML view
description = self.episode.description_html
args = (
cgi.escape(heading),
cgi.escape(subheading),
self.episode.get_play_info_string(),
description,
)
url = os.path.dirname(self.episode.channel.url)
self.htmlview.load_html_string(SHOWNOTES_HTML_TEMPLATE % args, url)
else:
self.b.create_tag('heading', scale=pango.SCALE_LARGE, weight=pango.WEIGHT_BOLD)
self.b.create_tag('subheading', scale=pango.SCALE_SMALL)
self.b.insert_with_tags_by_name(self.b.get_end_iter(), heading, 'heading')
self.b.insert_at_cursor('\n')
self.b.insert_with_tags_by_name(self.b.get_end_iter(), subheading, 'subheading')
self.b.insert_at_cursor('\n\n')
self.b.insert(self.b.get_end_iter(), util.remove_html_tags(description))
self.b.place_cursor(self.b.get_start_iter())
def on_hide_window(self):
self.episode = None
if self.have_webkit:
self.htmlview.load_html_string('', '')
else:
self.textview.get_buffer().set_text('')
def on_episode_status_changed(self):
if self.task:
self.download_progress.show()
self.btnCancel.set_property('visible', self.task.status not in \
(self.task.DONE, self.task.CANCELLED, self.task.FAILED))
self.btnDownload.set_property('visible', self.task.status in
(self.task.CANCELLED, self.task.FAILED, self.task.PAUSED))
self.btnPlay.set_property('visible', \
self.task.status == self.task.DONE)
else:
self.download_progress.hide()
self.btnCancel.hide()
if self.episode.was_downloaded(and_exists=True):
if self.episode.file_type() in ('audio', 'video'):
self.btnPlay.set_label(gtk.STOCK_MEDIA_PLAY)
else:
self.btnPlay.set_label(gtk.STOCK_OPEN)
self.btnPlay.set_use_stock(True)
self.btnPlay.show_all()
self.btnDownload.hide()
else:
self.btnPlay.show()
self.btnDownload.show()
def on_download_status_progress(self):
# We receive this from the main window every time the progress
# for our episode has changed (but only when this window is visible)
if self.task:
self.download_progress.set_fraction(self.task.progress)
self.download_progress.set_text('%s: %d%% (%s/s)' % ( \
self.task.STATUS_MESSAGE[self.task.status], \
100.*self.task.progress, \
util.format_filesize(self.task.speed)))
gpodder-3.1.2/src/gpodder/gtkui/desktop/channel.py 0000664 0001750 0001750 00000014756 11751103635 021563 0 ustar thp thp 0000000 0000000 # -*- coding: utf-8 -*-
#
# gPodder - A media aggregator and podcast client
# Copyright (c) 2005-2012 Thomas Perl and the gPodder Team
#
# gPodder is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# gPodder is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see %s ' % (cgi.escape(self.title),
cgi.escape(self.channel.title))
@property
def markup_new_episodes(self):
if self.file_size > 0:
length_str = '%s; ' % util.format_filesize(self.file_size)
else:
length_str = ''
return ('%s \n%s'+_('released %s')+ \
'; '+_('from %s')+' ') % (\
cgi.escape(re.sub('\s+', ' ', self.title)), \
cgi.escape(length_str), \
cgi.escape(self.pubdate_prop), \
cgi.escape(re.sub('\s+', ' ', self.channel.title)))
@property
def markup_delete_episodes(self):
if self.total_time and self.current_position:
played_string = self.get_play_info_string()
elif not self.is_new:
played_string = _('played')
else:
played_string = _('unplayed')
downloaded_string = self.get_age_string()
if not downloaded_string:
downloaded_string = _('today')
return ('%s \n%s; %s; '+_('downloaded %s')+ \
'; '+_('from %s')+' ') % (\
cgi.escape(self.title), \
cgi.escape(util.format_filesize(self.file_size)), \
cgi.escape(played_string), \
cgi.escape(downloaded_string), \
cgi.escape(self.channel.title))
class GPodcast(model.PodcastChannel):
__slots__ = ()
EpisodeClass = GEpisode
class Model(model.Model):
PodcastClass = GPodcast
# ----------------------------------------------------------
# Singleton indicator if a row is a section
class SeparatorMarker(object): pass
class SectionMarker(object): pass
class EpisodeListModel(gtk.ListStore):
C_URL, C_TITLE, C_FILESIZE_TEXT, C_EPISODE, C_STATUS_ICON, \
C_PUBLISHED_TEXT, C_DESCRIPTION, C_TOOLTIP, \
C_VIEW_SHOW_UNDELETED, C_VIEW_SHOW_DOWNLOADED, \
C_VIEW_SHOW_UNPLAYED, C_FILESIZE, C_PUBLISHED, \
C_TIME, C_TIME_VISIBLE, C_TOTAL_TIME, \
C_LOCKED = range(17)
VIEW_ALL, VIEW_UNDELETED, VIEW_DOWNLOADED, VIEW_UNPLAYED = range(4)
# In which steps the UI is updated for "loading" animations
_UI_UPDATE_STEP = .03
# Steps for the "downloading" icon progress
PROGRESS_STEPS = 20
def __init__(self, on_filter_changed=lambda has_episodes: None):
gtk.ListStore.__init__(self, str, str, str, object, \
str, str, str, str, bool, bool, bool, \
gobject.TYPE_INT64, int, str, bool, int, bool)
# Callback for when the filter / list changes, gets one parameter
# (has_episodes) that is True if the list has any episodes
self._on_filter_changed = on_filter_changed
# Filter to allow hiding some episodes
self._filter = self.filter_new()
self._sorter = gtk.TreeModelSort(self._filter)
self._view_mode = self.VIEW_ALL
self._search_term = None
self._search_term_eql = None
self._filter.set_visible_func(self._filter_visible_func)
# Are we currently showing the "all episodes" view?
self._all_episodes_view = False
self.ICON_AUDIO_FILE = 'audio-x-generic'
self.ICON_VIDEO_FILE = 'video-x-generic'
self.ICON_IMAGE_FILE = 'image-x-generic'
self.ICON_GENERIC_FILE = 'text-x-generic'
self.ICON_DOWNLOADING = gtk.STOCK_GO_DOWN
self.ICON_DELETED = gtk.STOCK_DELETE
if 'KDE_FULL_SESSION' in os.environ:
# Workaround until KDE adds all the freedesktop icons
# See https://bugs.kde.org/show_bug.cgi?id=233505 and
# http://gpodder.org/bug/553
self.ICON_DELETED = 'archive-remove'
def _format_filesize(self, episode):
if episode.file_size > 0:
return util.format_filesize(episode.file_size, digits=1)
else:
return None
def _filter_visible_func(self, model, iter):
# If searching is active, set visibility based on search text
if self._search_term is not None:
episode = model.get_value(iter, self.C_EPISODE)
if episode is None:
return False
try:
return self._search_term_eql.match(episode)
except Exception, e:
return True
if self._view_mode == self.VIEW_ALL:
return True
elif self._view_mode == self.VIEW_UNDELETED:
return model.get_value(iter, self.C_VIEW_SHOW_UNDELETED)
elif self._view_mode == self.VIEW_DOWNLOADED:
return model.get_value(iter, self.C_VIEW_SHOW_DOWNLOADED)
elif self._view_mode == self.VIEW_UNPLAYED:
return model.get_value(iter, self.C_VIEW_SHOW_UNPLAYED)
return True
def get_filtered_model(self):
"""Returns a filtered version of this episode model
The filtered version should be displayed in the UI,
as this model can have some filters set that should
be reflected in the UI.
"""
return self._sorter
def has_episodes(self):
"""Returns True if episodes are visible (filtered)
If episodes are visible with the current filter
applied, return True (otherwise return False).
"""
return bool(len(self._filter))
def set_view_mode(self, new_mode):
"""Sets a new view mode for this model
After setting the view mode, the filtered model
might be updated to reflect the new mode."""
if self._view_mode != new_mode:
self._view_mode = new_mode
self._filter.refilter()
self._on_filter_changed(self.has_episodes())
def get_view_mode(self):
"""Returns the currently-set view mode"""
return self._view_mode
def set_search_term(self, new_term):
if self._search_term != new_term:
self._search_term = new_term
self._search_term_eql = query.UserEQL(new_term)
self._filter.refilter()
self._on_filter_changed(self.has_episodes())
def get_search_term(self):
return self._search_term
def _format_description(self, episode, include_description=False):
title = episode.trimmed_title
a, b = '', ''
if episode.state != gpodder.STATE_DELETED and episode.is_new:
a, b = '', ' '
if include_description and self._all_episodes_view:
return '%s%s%s\n%s' % (a, cgi.escape(title), b,
_('from %s') % cgi.escape(episode.channel.title))
elif include_description:
description = episode.one_line_description()
if description.startswith(title):
description = description[len(title):].strip()
return '%s%s%s\n%s' % (a, cgi.escape(title), b,
cgi.escape(description))
else:
return ''.join((a, cgi.escape(title), b))
def replace_from_channel(self, channel, include_description=False,
treeview=None):
"""
Add episode from the given channel to this model.
Downloading should be a callback.
include_description should be a boolean value (True if description
is to be added to the episode row, or False if not)
"""
# Remove old episodes in the list store
self.clear()
if treeview is not None:
util.idle_add(treeview.queue_draw)
self._all_episodes_view = getattr(channel, 'ALL_EPISODES_PROXY', False)
# Avoid gPodder bug 1291
if channel is None:
episodes = []
else:
episodes = channel.get_all_episodes()
if not isinstance(episodes, list):
episodes = list(episodes)
count = len(episodes)
for position, episode in enumerate(episodes):
iter = self.append((episode.url, \
episode.title, \
self._format_filesize(episode), \
episode, \
None, \
episode.cute_pubdate(), \
'', \
'', \
True, \
True, \
True, \
episode.file_size, \
episode.published, \
episode.get_play_info_string(), \
bool(episode.total_time), \
episode.total_time, \
episode.archive))
self.update_by_iter(iter, include_description)
self._on_filter_changed(self.has_episodes())
def update_all(self, include_description=False):
for row in self:
self.update_by_iter(row.iter, include_description)
def update_by_urls(self, urls, include_description=False):
for row in self:
if row[self.C_URL] in urls:
self.update_by_iter(row.iter, include_description)
def update_by_filter_iter(self, iter, include_description=False):
# Convenience function for use by "outside" methods that use iters
# from the filtered episode list model (i.e. all UI things normally)
iter = self._sorter.convert_iter_to_child_iter(None, iter)
self.update_by_iter(self._filter.convert_iter_to_child_iter(iter),
include_description)
def update_by_iter(self, iter, include_description=False):
episode = self.get_value(iter, self.C_EPISODE)
show_bullet = False
show_padlock = False
show_missing = False
status_icon = None
tooltip = []
view_show_undeleted = True
view_show_downloaded = False
view_show_unplayed = False
icon_theme = gtk.icon_theme_get_default()
if episode.downloading:
tooltip.append('%s %d%%' % (_('Downloading'),
int(episode.download_task.progress*100)))
index = int(self.PROGRESS_STEPS*episode.download_task.progress)
status_icon = 'gpodder-progress-%d' % index
view_show_downloaded = True
view_show_unplayed = True
else:
if episode.state == gpodder.STATE_DELETED:
tooltip.append(_('Deleted'))
status_icon = self.ICON_DELETED
view_show_undeleted = False
elif episode.state == gpodder.STATE_NORMAL and \
episode.is_new:
tooltip.append(_('New episode'))
view_show_downloaded = True
view_show_unplayed = True
elif episode.state == gpodder.STATE_DOWNLOADED:
tooltip = []
view_show_downloaded = True
view_show_unplayed = episode.is_new
show_bullet = episode.is_new
show_padlock = episode.archive
show_missing = not episode.file_exists()
filename = episode.local_filename(create=False, check_only=True)
file_type = episode.file_type()
if file_type == 'audio':
tooltip.append(_('Downloaded episode'))
status_icon = self.ICON_AUDIO_FILE
elif file_type == 'video':
tooltip.append(_('Downloaded video episode'))
status_icon = self.ICON_VIDEO_FILE
elif file_type == 'image':
tooltip.append(_('Downloaded image'))
status_icon = self.ICON_IMAGE_FILE
else:
tooltip.append(_('Downloaded file'))
status_icon = self.ICON_GENERIC_FILE
# Try to find a themed icon for this file
if filename is not None and have_gio:
file = gio.File(filename)
if file.query_exists():
file_info = file.query_info('*')
icon = file_info.get_icon()
for icon_name in icon.get_names():
if icon_theme.has_icon(icon_name):
status_icon = icon_name
break
if show_missing:
tooltip.append(_('missing file'))
else:
if show_bullet:
if file_type == 'image':
tooltip.append(_('never displayed'))
elif file_type in ('audio', 'video'):
tooltip.append(_('never played'))
else:
tooltip.append(_('never opened'))
else:
if file_type == 'image':
tooltip.append(_('displayed'))
elif file_type in ('audio', 'video'):
tooltip.append(_('played'))
else:
tooltip.append(_('opened'))
if show_padlock:
tooltip.append(_('deletion prevented'))
if episode.total_time > 0 and episode.current_position:
tooltip.append('%d%%' % (100.*float(episode.current_position)/float(episode.total_time),))
if episode.total_time:
total_time = util.format_time(episode.total_time)
if total_time:
tooltip.append(total_time)
tooltip = ', '.join(tooltip)
description = self._format_description(episode, include_description)
self.set(iter, \
self.C_STATUS_ICON, status_icon, \
self.C_VIEW_SHOW_UNDELETED, view_show_undeleted, \
self.C_VIEW_SHOW_DOWNLOADED, view_show_downloaded, \
self.C_VIEW_SHOW_UNPLAYED, view_show_unplayed, \
self.C_DESCRIPTION, description, \
self.C_TOOLTIP, tooltip, \
self.C_TIME, episode.get_play_info_string(duration_only=True), \
self.C_TIME_VISIBLE, bool(episode.total_time), \
self.C_TOTAL_TIME, episode.total_time, \
self.C_LOCKED, episode.archive, \
self.C_FILESIZE_TEXT, self._format_filesize(episode), \
self.C_FILESIZE, episode.file_size)
class PodcastChannelProxy(object):
ALL_EPISODES_PROXY = True
def __init__(self, db, config, channels):
self._db = db
self._config = config
self.channels = channels
self.title = _('All episodes')
self.description = _('from all podcasts')
#self.parse_error = ''
self.url = ''
self.section = ''
self.id = None
self.cover_file = coverart.CoverDownloader.ALL_EPISODES_ID
self.cover_url = None
self.auth_username = None
self.auth_password = None
self.pause_subscription = False
self.auto_archive_episodes = False
def get_statistics(self):
# Get the total statistics for all channels from the database
return self._db.get_podcast_statistics()
def get_all_episodes(self):
"""Returns a generator that yields every episode"""
return Model.sort_episodes_by_pubdate((e for c in self.channels
for e in c.get_all_episodes()), True)
class PodcastListModel(gtk.ListStore):
C_URL, C_TITLE, C_DESCRIPTION, C_PILL, C_CHANNEL, \
C_COVER, C_ERROR, C_PILL_VISIBLE, \
C_VIEW_SHOW_UNDELETED, C_VIEW_SHOW_DOWNLOADED, \
C_VIEW_SHOW_UNPLAYED, C_HAS_EPISODES, C_SEPARATOR, \
C_DOWNLOADS, C_COVER_VISIBLE, C_SECTION = range(16)
SEARCH_COLUMNS = (C_TITLE, C_DESCRIPTION, C_SECTION)
@classmethod
def row_separator_func(cls, model, iter):
return model.get_value(iter, cls.C_SEPARATOR)
def __init__(self, cover_downloader):
gtk.ListStore.__init__(self, str, str, str, gtk.gdk.Pixbuf, \
object, gtk.gdk.Pixbuf, str, bool, bool, bool, bool, \
bool, bool, int, bool, str)
# Filter to allow hiding some episodes
self._filter = self.filter_new()
self._view_mode = -1
self._search_term = None
self._filter.set_visible_func(self._filter_visible_func)
self._cover_cache = {}
self._max_image_side = 40
self._cover_downloader = cover_downloader
self.ICON_DISABLED = 'gtk-media-pause'
def _filter_visible_func(self, model, iter):
# If searching is active, set visibility based on search text
if self._search_term is not None:
if model.get_value(iter, self.C_CHANNEL) == SectionMarker:
return True
key = self._search_term.lower()
columns = (model.get_value(iter, c) for c in self.SEARCH_COLUMNS)
return any((key in c.lower() for c in columns if c is not None))
if model.get_value(iter, self.C_SEPARATOR):
return True
elif self._view_mode == EpisodeListModel.VIEW_ALL:
return model.get_value(iter, self.C_HAS_EPISODES)
elif self._view_mode == EpisodeListModel.VIEW_UNDELETED:
return model.get_value(iter, self.C_VIEW_SHOW_UNDELETED)
elif self._view_mode == EpisodeListModel.VIEW_DOWNLOADED:
return model.get_value(iter, self.C_VIEW_SHOW_DOWNLOADED)
elif self._view_mode == EpisodeListModel.VIEW_UNPLAYED:
return model.get_value(iter, self.C_VIEW_SHOW_UNPLAYED)
return True
def get_filtered_model(self):
"""Returns a filtered version of this episode model
The filtered version should be displayed in the UI,
as this model can have some filters set that should
be reflected in the UI.
"""
return self._filter
def set_view_mode(self, new_mode):
"""Sets a new view mode for this model
After setting the view mode, the filtered model
might be updated to reflect the new mode."""
if self._view_mode != new_mode:
self._view_mode = new_mode
self._filter.refilter()
def get_view_mode(self):
"""Returns the currently-set view mode"""
return self._view_mode
def set_search_term(self, new_term):
if self._search_term != new_term:
self._search_term = new_term
self._filter.refilter()
def get_search_term(self):
return self._search_term
def enable_separators(self, channeltree):
channeltree.set_row_separator_func(self._show_row_separator)
def _show_row_separator(self, model, iter):
return model.get_value(iter, self.C_SEPARATOR)
def _resize_pixbuf_keep_ratio(self, url, pixbuf):
"""
Resizes a GTK Pixbuf but keeps its aspect ratio.
Returns None if the pixbuf does not need to be
resized or the newly resized pixbuf if it does.
"""
changed = False
result = None
if url in self._cover_cache:
return self._cover_cache[url]
# Resize if too wide
if pixbuf.get_width() > self._max_image_side:
f = float(self._max_image_side)/pixbuf.get_width()
(width, height) = (int(pixbuf.get_width()*f), int(pixbuf.get_height()*f))
pixbuf = pixbuf.scale_simple(width, height, gtk.gdk.INTERP_BILINEAR)
changed = True
# Resize if too high
if pixbuf.get_height() > self._max_image_side:
f = float(self._max_image_side)/pixbuf.get_height()
(width, height) = (int(pixbuf.get_width()*f), int(pixbuf.get_height()*f))
pixbuf = pixbuf.scale_simple(width, height, gtk.gdk.INTERP_BILINEAR)
changed = True
if changed:
self._cover_cache[url] = pixbuf
result = pixbuf
return result
def _resize_pixbuf(self, url, pixbuf):
if pixbuf is None:
return None
return self._resize_pixbuf_keep_ratio(url, pixbuf) or pixbuf
def _overlay_pixbuf(self, pixbuf, icon):
try:
icon_theme = gtk.icon_theme_get_default()
emblem = icon_theme.load_icon(icon, self._max_image_side/2, 0)
(width, height) = (emblem.get_width(), emblem.get_height())
xpos = pixbuf.get_width() - width
ypos = pixbuf.get_height() - height
if ypos < 0:
# need to resize overlay for none standard icon size
emblem = icon_theme.load_icon(icon, pixbuf.get_height() - 1, 0)
(width, height) = (emblem.get_width(), emblem.get_height())
xpos = pixbuf.get_width() - width
ypos = pixbuf.get_height() - height
emblem.composite(pixbuf, xpos, ypos, width, height, xpos, ypos, 1, 1, gtk.gdk.INTERP_BILINEAR, 255)
except:
pass
return pixbuf
def _get_cover_image(self, channel, add_overlay=False):
if self._cover_downloader is None:
return None
pixbuf = self._cover_downloader.get_cover(channel, avoid_downloading=True)
pixbuf_overlay = self._resize_pixbuf(channel.url, pixbuf)
if add_overlay and channel.pause_subscription:
pixbuf_overlay = self._overlay_pixbuf(pixbuf_overlay, self.ICON_DISABLED)
pixbuf_overlay.saturate_and_pixelate(pixbuf_overlay, 0.0, False)
return pixbuf_overlay
def _get_pill_image(self, channel, count_downloaded, count_unplayed):
if count_unplayed > 0 or count_downloaded > 0:
return draw.draw_pill_pixbuf(str(count_unplayed), str(count_downloaded))
else:
return None
def _format_description(self, channel, total, deleted, \
new, downloaded, unplayed):
title_markup = cgi.escape(channel.title)
if not channel.pause_subscription:
description_markup = cgi.escape(util.get_first_line(channel.description) or ' ')
else:
description_markup = cgi.escape(_('Subscription paused'))
d = []
if new:
d.append('')
d.append(title_markup)
if new:
d.append(' ')
if description_markup.strip():
return ''.join(d+['\n', '', description_markup, ' '])
else:
return ''.join(d)
def _format_error(self, channel):
#if channel.parse_error:
# return str(channel.parse_error)
#else:
# return None
return None
def set_channels(self, db, config, channels):
# Clear the model and update the list of podcasts
self.clear()
def channel_to_row(channel, add_overlay=False):
return (channel.url, '', '', None, channel,
self._get_cover_image(channel, add_overlay), '', True,
True, True, True, True, False, 0, True, '')
if config.podcast_list_view_all and channels:
all_episodes = PodcastChannelProxy(db, config, channels)
iter = self.append(channel_to_row(all_episodes))
self.update_by_iter(iter)
# Separator item
if not config.podcast_list_sections:
self.append(('', '', '', None, SeparatorMarker, None, '',
True, True, True, True, True, True, 0, False, ''))
def key_func(pair):
section, podcast = pair
return (section, model.Model.podcast_sort_key(podcast))
if config.podcast_list_sections:
def convert(channels):
for channel in channels:
yield (channel.group_by, channel)
else:
def convert(channels):
for channel in channels:
yield (None, channel)
added_sections = []
old_section = None
for section, channel in sorted(convert(channels), key=key_func):
if old_section != section:
it = self.append(('-', section, '', None, SectionMarker, None,
'', True, True, True, True, True, False, 0, False, section))
added_sections.append(it)
old_section = section
iter = self.append(channel_to_row(channel, True))
self.update_by_iter(iter)
# Update section header stats only after all podcasts
# have been added to the list to get the stats right
for it in added_sections:
self.update_by_iter(it)
def get_filter_path_from_url(self, url):
# Return the path of the filtered model for a given URL
child_path = self.get_path_from_url(url)
if child_path is None:
return None
else:
return self._filter.convert_child_path_to_path(child_path)
def get_path_from_url(self, url):
# Return the tree model path for a given URL
if url is None:
return None
for row in self:
if row[self.C_URL] == url:
return row.path
return None
def update_first_row(self):
# Update the first row in the model (for "all episodes" updates)
self.update_by_iter(self.get_iter_first())
def update_by_urls(self, urls):
# Given a list of URLs, update each matching row
for row in self:
if row[self.C_URL] in urls:
self.update_by_iter(row.iter)
def iter_is_first_row(self, iter):
iter = self._filter.convert_iter_to_child_iter(iter)
path = self.get_path(iter)
return (path == (0,))
def update_by_filter_iter(self, iter):
self.update_by_iter(self._filter.convert_iter_to_child_iter(iter))
def update_all(self):
for row in self:
self.update_by_iter(row.iter)
def update_sections(self):
for row in self:
if row[self.C_CHANNEL] is SectionMarker:
self.update_by_iter(row.iter)
def update_by_iter(self, iter):
if iter is None:
return
# Given a GtkTreeIter, update volatile information
channel = self.get_value(iter, self.C_CHANNEL)
if channel is SectionMarker:
section = self.get_value(iter, self.C_TITLE)
# This row is a section header - update its visibility flags
channels = [c for c in (row[self.C_CHANNEL] for row in self)
if isinstance(c, GPodcast) and c.section == section]
# Calculate the stats over all podcasts of this section
total, deleted, new, downloaded, unplayed = map(sum,
zip(*[c.get_statistics() for c in channels]))
# We could customized the section header here with the list
# of channels and their stats (i.e. add some "new" indicator)
description = ' %s ' % (
cgi.escape(section))
self.set(iter,
self.C_DESCRIPTION, description,
self.C_SECTION, section,
self.C_VIEW_SHOW_UNDELETED, total - deleted > 0,
self.C_VIEW_SHOW_DOWNLOADED, downloaded + new > 0,
self.C_VIEW_SHOW_UNPLAYED, unplayed + new > 0)
if (not isinstance(channel, GPodcast) and
not isinstance(channel, PodcastChannelProxy)):
return
total, deleted, new, downloaded, unplayed = channel.get_statistics()
description = self._format_description(channel, total, deleted, new, \
downloaded, unplayed)
pill_image = self._get_pill_image(channel, downloaded, unplayed)
self.set(iter, \
self.C_TITLE, channel.title, \
self.C_DESCRIPTION, description, \
self.C_SECTION, channel.section, \
self.C_ERROR, self._format_error(channel), \
self.C_PILL, pill_image, \
self.C_PILL_VISIBLE, pill_image != None, \
self.C_VIEW_SHOW_UNDELETED, total - deleted > 0, \
self.C_VIEW_SHOW_DOWNLOADED, downloaded + new > 0, \
self.C_VIEW_SHOW_UNPLAYED, unplayed + new > 0, \
self.C_HAS_EPISODES, total > 0, \
self.C_DOWNLOADS, downloaded)
def clear_cover_cache(self, podcast_url):
if podcast_url in self._cover_cache:
logger.info('Clearing cover from cache: %s', podcast_url)
del self._cover_cache[podcast_url]
def add_cover_by_channel(self, channel, pixbuf):
# Resize and add the new cover image
pixbuf = self._resize_pixbuf(channel.url, pixbuf)
if channel.pause_subscription:
pixbuf = self._overlay_pixbuf(pixbuf, self.ICON_DISABLED)
pixbuf.saturate_and_pixelate(pixbuf, 0.0, False)
for row in self:
if row[self.C_URL] == channel.url:
row[self.C_COVER] = pixbuf
break
gpodder-3.1.2/src/gpodder/gtkui/draw.py 0000664 0001750 0001750 00000025676 11751103635 017442 0 ustar thp thp 0000000 0000000 # -*- coding: utf-8 -*-
#
# gPodder - A media aggregator and podcast client
# Copyright (c) 2005-2012 Thomas Perl and the gPodder Team
#
# gPodder is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# gPodder is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see , 2007-11-25
#
import gpodder
import gtk
import pango
import pangocairo
import cairo
import StringIO
import math
class TextExtents(object):
def __init__(self, ctx, text):
tuple = ctx.text_extents(text)
(self.x_bearing, self.y_bearing, self.width, self.height, self.x_advance, self.y_advance) = tuple
EPISODE_LIST_ICON_SIZE = 16
RRECT_LEFT_SIDE = 1
RRECT_RIGHT_SIDE = 2
def draw_rounded_rectangle(ctx, x, y, w, h, r=10, left_side_width = None, sides_to_draw=0, close=False):
assert left_side_width is not None
x = int(x)
offset = 0
if close: offset = 0.5
if sides_to_draw & RRECT_LEFT_SIDE:
ctx.move_to(x+int(left_side_width)-offset, y+h)
ctx.line_to(x+r, y+h)
ctx.curve_to(x, y+h, x, y+h, x, y+h-r)
ctx.line_to(x, y+r)
ctx.curve_to(x, y, x, y, x+r, y)
ctx.line_to(x+int(left_side_width)-offset, y)
if close:
ctx.line_to(x+int(left_side_width)-offset, y+h)
if sides_to_draw & RRECT_RIGHT_SIDE:
ctx.move_to(x+int(left_side_width)+offset, y)
ctx.line_to(x+w-r, y)
ctx.curve_to(x+w, y, x+w, y, x+w, y+r)
ctx.line_to(x+w, y+h-r)
ctx.curve_to(x+w, y+h, x+w, y+h, x+w-r, y+h)
ctx.line_to(x+int(left_side_width)+offset, y+h)
if close:
ctx.line_to(x+int(left_side_width)+offset, y)
def rounded_rectangle(ctx, x, y, width, height, radius=4.):
"""Simple rounded rectangle algorithmn
http://www.cairographics.org/samples/rounded_rectangle/
"""
degrees = math.pi / 180.
ctx.new_sub_path()
if width > radius:
ctx.arc(x + width - radius, y + radius, radius, -90. * degrees, 0)
ctx.arc(x + width - radius, y + height - radius, radius, 0, 90. * degrees)
ctx.arc(x + radius, y + height - radius, radius, 90. * degrees, 180. * degrees)
ctx.arc(x + radius, y + radius, radius, 180. * degrees, 270. * degrees)
ctx.close_path()
def draw_text_box_centered(ctx, widget, w_width, w_height, text, font_desc=None, add_progress=None):
style = widget.rc_get_style()
text_color = style.text[gtk.STATE_PRELIGHT]
red, green, blue = text_color.red, text_color.green, text_color.blue
text_color = [float(x)/65535. for x in (red, green, blue)]
text_color.append(.5)
if font_desc is None:
font_desc = style.font_desc
font_desc.set_size(14*pango.SCALE)
pango_context = widget.create_pango_context()
layout = pango.Layout(pango_context)
layout.set_font_description(font_desc)
layout.set_text(text)
width, height = layout.get_pixel_size()
ctx.move_to(w_width/2-width/2, w_height/2-height/2)
ctx.set_source_rgba(*text_color)
ctx.show_layout(layout)
# Draw an optional progress bar below the text (same width)
if add_progress is not None:
bar_height = 10
ctx.set_source_rgba(*text_color)
ctx.set_line_width(1.)
rounded_rectangle(ctx, w_width/2-width/2-.5, w_height/2+height-.5, width+1, bar_height+1)
ctx.stroke()
rounded_rectangle(ctx, w_width/2-width/2, w_height/2+height, int(width*add_progress)+.5, bar_height)
ctx.fill()
def draw_cake(percentage, text=None, emblem=None, size=None):
# Download percentage bar icon - it turns out the cake is a lie (d'oh!)
# ..but the inital idea was to have a cake-style indicator, but that
# didn't work as well as the progress bar, but the name stuck..
if size is None:
size = EPISODE_LIST_ICON_SIZE
surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, size, size)
ctx = pangocairo.CairoContext(cairo.Context(surface))
widget = gtk.ProgressBar()
style = widget.rc_get_style()
bgc = style.bg[gtk.STATE_NORMAL]
fgc = style.bg[gtk.STATE_SELECTED]
txc = style.text[gtk.STATE_NORMAL]
border = 1.5
height = int(size*.4)
width = size - 2*border
y = (size - height) / 2 + .5
x = border
# Background
ctx.rectangle(x, y, width, height)
ctx.set_source_rgb(bgc.red_float, bgc.green_float, bgc.blue_float)
ctx.fill()
# Filling
if percentage > 0:
fill_width = max(1, min(width-2, (width-2)*percentage+.5))
ctx.rectangle(x+1, y+1, fill_width, height-2)
ctx.set_source_rgb(fgc.red_float, fgc.green_float, fgc.blue_float)
ctx.fill()
# Border
ctx.rectangle(x, y, width, height)
ctx.set_source_rgb(txc.red_float, txc.green_float, txc.blue_float)
ctx.set_line_width(1)
ctx.stroke()
del ctx
return surface
def draw_text_pill(left_text, right_text, x=0, y=0, border=2, radius=14, font_desc=None):
# Create temporary context to calculate the text size
ctx = cairo.Context(cairo.ImageSurface(cairo.FORMAT_ARGB32, 1, 1))
# Use GTK+ style of a normal Button
widget = gtk.Label()
style = widget.rc_get_style()
# Padding (in px) at the right edge of the image (for Ubuntu; bug 1533)
padding_right = 7
x_border = border*2
if font_desc is None:
font_desc = style.font_desc
font_desc.set_weight(pango.WEIGHT_BOLD)
pango_context = widget.create_pango_context()
layout_left = pango.Layout(pango_context)
layout_left.set_font_description(font_desc)
layout_left.set_text(left_text)
layout_right = pango.Layout(pango_context)
layout_right.set_font_description(font_desc)
layout_right.set_text(right_text)
width_left, height_left = layout_left.get_pixel_size()
width_right, height_right = layout_right.get_pixel_size()
text_height = max(height_left, height_right)
image_height = int(y+text_height+border*2)
image_width = int(x+width_left+width_right+x_border*4+padding_right)
surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, image_width, image_height)
ctx = pangocairo.CairoContext(cairo.Context(surface))
# Clip so as to not draw on the right padding (for Ubuntu; bug 1533)
ctx.rectangle(0, 0, image_width - padding_right, image_height)
ctx.clip()
if left_text == '0':
left_text = None
if right_text == '0':
right_text = None
left_side_width = width_left + x_border*2
right_side_width = width_right + x_border*2
rect_width = left_side_width + right_side_width
rect_height = text_height + border*2
if left_text is not None:
draw_rounded_rectangle(ctx,x,y,rect_width,rect_height,radius, left_side_width, RRECT_LEFT_SIDE, right_text is None)
linear = cairo.LinearGradient(x, y, x+left_side_width/2, y+rect_height/2)
linear.add_color_stop_rgba(0, .8, .8, .8, .5)
linear.add_color_stop_rgba(.4, .8, .8, .8, .7)
linear.add_color_stop_rgba(.6, .8, .8, .8, .6)
linear.add_color_stop_rgba(.9, .8, .8, .8, .8)
linear.add_color_stop_rgba(1, .8, .8, .8, .9)
ctx.set_source(linear)
ctx.fill()
xpos, ypos, width_left, height = x+1, y+1, left_side_width, rect_height-2
if right_text is None:
width_left -= 2
draw_rounded_rectangle(ctx, xpos, ypos, rect_width, height, radius, width_left, RRECT_LEFT_SIDE, right_text is None)
ctx.set_source_rgba(1., 1., 1., .3)
ctx.set_line_width(1)
ctx.stroke()
draw_rounded_rectangle(ctx,x,y,rect_width,rect_height,radius, left_side_width, RRECT_LEFT_SIDE, right_text is None)
ctx.set_source_rgba(.2, .2, .2, .6)
ctx.set_line_width(1)
ctx.stroke()
ctx.move_to(x+x_border, y+1+border)
ctx.set_source_rgba( 0, 0, 0, 1)
ctx.show_layout(layout_left)
ctx.move_to(x-1+x_border, y+border)
ctx.set_source_rgba( 1, 1, 1, 1)
ctx.show_layout(layout_left)
if right_text is not None:
draw_rounded_rectangle(ctx, x, y, rect_width, rect_height, radius, left_side_width, RRECT_RIGHT_SIDE, left_text is None)
linear = cairo.LinearGradient(x+left_side_width, y, x+left_side_width+right_side_width/2, y+rect_height)
linear.add_color_stop_rgba(0, .2, .2, .2, .9)
linear.add_color_stop_rgba(.4, .2, .2, .2, .8)
linear.add_color_stop_rgba(.6, .2, .2, .2, .6)
linear.add_color_stop_rgba(.9, .2, .2, .2, .7)
linear.add_color_stop_rgba(1, .2, .2, .2, .5)
ctx.set_source(linear)
ctx.fill()
xpos, ypos, width, height = x, y+1, rect_width-1, rect_height-2
if left_text is None:
xpos, width = x+1, rect_width-2
draw_rounded_rectangle(ctx, xpos, ypos, width, height, radius, left_side_width, RRECT_RIGHT_SIDE, left_text is None)
ctx.set_source_rgba(1., 1., 1., .3)
ctx.set_line_width(1)
ctx.stroke()
draw_rounded_rectangle(ctx, x, y, rect_width, rect_height, radius, left_side_width, RRECT_RIGHT_SIDE, left_text is None)
ctx.set_source_rgba(.1, .1, .1, .6)
ctx.set_line_width(1)
ctx.stroke()
ctx.move_to(x+left_side_width+x_border, y+1+border)
ctx.set_source_rgba( 0, 0, 0, 1)
ctx.show_layout(layout_right)
ctx.move_to(x-1+left_side_width+x_border, y+border)
ctx.set_source_rgba( 1, 1, 1, 1)
ctx.show_layout(layout_right)
return surface
def draw_cake_pixbuf(percentage, text=None, emblem=None):
return cairo_surface_to_pixbuf(draw_cake(percentage, text, emblem))
def draw_pill_pixbuf(left_text, right_text):
return cairo_surface_to_pixbuf(draw_text_pill(left_text, right_text))
def cairo_surface_to_pixbuf(s):
"""
Converts a Cairo surface to a Gtk Pixbuf by
encoding it as PNG and using the PixbufLoader.
"""
sio = StringIO.StringIO()
try:
s.write_to_png(sio)
except:
# Write an empty PNG file to the StringIO, so
# in case of an error we have "something" to
# load. This happens in PyCairo < 1.1.6, see:
# http://webcvs.cairographics.org/pycairo/NEWS?view=markup
# Thanks to Chris Arnold for reporting this bug
sio.write('iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAAAXNSR0IArs4c6QAAAAZiS0dEAP8A\n/wD/oL2nkwAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB9cMEQkqIyxn3RkAAAAZdEVYdENv\nbW1lbnQAQ3JlYXRlZCB3aXRoIEdJTVBXgQ4XAAAADUlEQVQI12NgYGBgAAAABQABXvMqOgAAAABJ\nRU5ErkJggg==\n'.decode('base64'))
pbl = gtk.gdk.PixbufLoader()
pbl.write(sio.getvalue())
pbl.close()
pixbuf = pbl.get_pixbuf()
return pixbuf
gpodder-3.1.2/src/gpodder/gtkui/__init__.py 0000664 0001750 0001750 00000001374 11751103635 020231 0 ustar thp thp 0000000 0000000 # -*- coding: utf-8 -*-
#
# gPodder - A media aggregator and podcast client
# Copyright (c) 2005-2012 Thomas Perl and the gPodder Team
#
# gPodder is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# gPodder is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see %s ' % error_str
table = gtk.Table(rows=3, columns=3)
table.set_row_spacings(5)
table.set_col_spacings(5)
table.set_border_width(5)
heading = gtk.Label()
heading.set_alignment(0, 1)
heading.set_markup('%s %s ' % (cgi.escape(channel.title), cgi.escape(channel.url)))
table.attach(heading, 0, 1, 0, 1)
table.attach(gtk.HSeparator(), 0, 3, 1, 2)
if len(channel.description) < 500:
description = channel.description
else:
pos = channel.description.find('\n\n')
if pos == -1 or pos > 500:
description = channel.description[:498]+'[...]'
else:
description = channel.description[:pos]
description = gtk.Label(description)
if error_str:
description.set_markup(error_str)
description.set_alignment(0, 0)
description.set_line_wrap(True)
table.attach(description, 0, 3, 2, 3)
table.show_all()
tooltip.set_custom(table)
return True
setattr(treeview, TreeViewHelper.LAST_TOOLTIP, None)
return False
def treeview_allow_tooltips(self, treeview, allow):
setattr(treeview, TreeViewHelper.CAN_TOOLTIP, allow)
def treeview_handle_context_menu_click(self, treeview, event):
if event is None:
selection = treeview.get_selection()
return selection.get_selected_rows()
x, y = int(event.x), int(event.y)
path, column, rx, ry = treeview.get_path_at_pos(x, y) or (None,)*4
selection = treeview.get_selection()
model, paths = selection.get_selected_rows()
if path is None or (path not in paths and \
event.button == 3):
# We have right-clicked, but not into the selection,
# assume we don't want to operate on the selection
paths = []
if path is not None and not paths and \
event.button == 3:
# No selection or clicked outside selection;
# select the single item where we clicked
treeview.grab_focus()
treeview.set_cursor(path, column, 0)
paths = [path]
if not paths:
# Unselect any remaining items (clicked elsewhere)
if hasattr(treeview, 'is_rubber_banding_active'):
if not treeview.is_rubber_banding_active():
selection.unselect_all()
else:
selection.unselect_all()
return model, paths
def downloads_list_get_selection(self, model=None, paths=None):
if model is None and paths is None:
selection = self.treeDownloads.get_selection()
model, paths = selection.get_selected_rows()
can_queue, can_cancel, can_pause, can_remove, can_force = (True,)*5
selected_tasks = [(gtk.TreeRowReference(model, path), \
model.get_value(model.get_iter(path), \
DownloadStatusModel.C_TASK)) for path in paths]
for row_reference, task in selected_tasks:
if task.status != download.DownloadTask.QUEUED:
can_force = False
if task.status not in (download.DownloadTask.PAUSED, \
download.DownloadTask.FAILED, \
download.DownloadTask.CANCELLED):
can_queue = False
if task.status not in (download.DownloadTask.PAUSED, \
download.DownloadTask.QUEUED, \
download.DownloadTask.DOWNLOADING, \
download.DownloadTask.FAILED):
can_cancel = False
if task.status not in (download.DownloadTask.QUEUED, \
download.DownloadTask.DOWNLOADING):
can_pause = False
if task.status not in (download.DownloadTask.CANCELLED, \
download.DownloadTask.FAILED, \
download.DownloadTask.DONE):
can_remove = False
return selected_tasks, can_queue, can_cancel, can_pause, can_remove, can_force
def downloads_finished(self, download_tasks_seen):
finished_downloads = [str(task) for task in download_tasks_seen if task.notify_as_finished()]
failed_downloads = [str(task)+' ('+task.error_message+')' for task in download_tasks_seen if task.notify_as_failed()]
if finished_downloads and failed_downloads:
message = self.format_episode_list(finished_downloads, 5)
message += '\n\n%s \n' % _('These downloads failed:')
message += self.format_episode_list(failed_downloads, 5)
self.show_message(message, _('Downloads finished'), True, widget=self.labelDownloads)
elif finished_downloads:
message = self.format_episode_list(finished_downloads)
self.show_message(message, _('Downloads finished'), widget=self.labelDownloads)
elif failed_downloads:
message = self.format_episode_list(failed_downloads)
self.show_message(message, _('Downloads failed'), True, widget=self.labelDownloads)
def format_episode_list(self, episode_list, max_episodes=10):
"""
Format a list of episode names for notifications
Will truncate long episode names and limit the amount of
episodes displayed (max_episodes=10).
The episode_list parameter should be a list of strings.
"""
MAX_TITLE_LENGTH = 100
result = []
for title in episode_list[:min(len(episode_list), max_episodes)]:
if len(title) > MAX_TITLE_LENGTH:
middle = (MAX_TITLE_LENGTH/2)-2
title = '%s...%s' % (title[0:middle], title[-middle:])
result.append(cgi.escape(title))
result.append('\n')
more_episodes = len(episode_list) - max_episodes
if more_episodes > 0:
result.append('(...')
result.append(N_('%(count)d more episode', '%(count)d more episodes', more_episodes) % {'count':more_episodes})
result.append('...)')
return (''.join(result)).strip()
def _for_each_task_set_status(self, tasks, status, force_start=False):
episode_urls = set()
model = self.treeDownloads.get_model()
for row_reference, task in tasks:
if status == download.DownloadTask.QUEUED:
# Only queue task when its paused/failed/cancelled (or forced)
if task.status in (task.PAUSED, task.FAILED, task.CANCELLED) or force_start:
self.download_queue_manager.add_task(task, force_start)
self.enable_download_list_update()
elif status == download.DownloadTask.CANCELLED:
# Cancelling a download allowed when downloading/queued
if task.status in (task.QUEUED, task.DOWNLOADING):
task.status = status
# Cancelling paused/failed downloads requires a call to .run()
elif task.status in (task.PAUSED, task.FAILED):
task.status = status
# Call run, so the partial file gets deleted
task.run()
elif status == download.DownloadTask.PAUSED:
# Pausing a download only when queued/downloading
if task.status in (task.DOWNLOADING, task.QUEUED):
task.status = status
elif status is None:
# Remove the selected task - cancel downloading/queued tasks
if task.status in (task.QUEUED, task.DOWNLOADING):
task.status = task.CANCELLED
model.remove(model.get_iter(row_reference.get_path()))
# Remember the URL, so we can tell the UI to update
try:
# We don't "see" this task anymore - remove it;
# this is needed, so update_episode_list_icons()
# below gets the correct list of "seen" tasks
self.download_tasks_seen.remove(task)
except KeyError, key_error:
pass
episode_urls.add(task.url)
# Tell the task that it has been removed (so it can clean up)
task.removed_from_list()
else:
# We can (hopefully) simply set the task status here
task.status = status
# Tell the podcasts tab to update icons for our removed podcasts
self.update_episode_list_icons(episode_urls)
# Update the tab title and downloads list
self.update_downloads_list()
def treeview_downloads_show_context_menu(self, treeview, event=None):
model, paths = self.treeview_handle_context_menu_click(treeview, event)
if not paths:
if not hasattr(treeview, 'is_rubber_banding_active'):
return True
else:
return not treeview.is_rubber_banding_active()
if event is None or event.button == 3:
selected_tasks, can_queue, can_cancel, can_pause, can_remove, can_force = \
self.downloads_list_get_selection(model, paths)
def make_menu_item(label, stock_id, tasks, status, sensitive, force_start=False):
# This creates a menu item for selection-wide actions
item = gtk.ImageMenuItem(label)
item.set_image(gtk.image_new_from_stock(stock_id, gtk.ICON_SIZE_MENU))
item.connect('activate', lambda item: self._for_each_task_set_status(tasks, status, force_start))
item.set_sensitive(sensitive)
return item
menu = gtk.Menu()
item = gtk.ImageMenuItem(_('Episode details'))
item.set_image(gtk.image_new_from_stock(gtk.STOCK_INFO, gtk.ICON_SIZE_MENU))
if len(selected_tasks) == 1:
row_reference, task = selected_tasks[0]
episode = task.episode
item.connect('activate', lambda item: self.show_episode_shownotes(episode))
else:
item.set_sensitive(False)
menu.append(item)
menu.append(gtk.SeparatorMenuItem())
if can_force:
menu.append(make_menu_item(_('Start download now'), gtk.STOCK_GO_DOWN, selected_tasks, download.DownloadTask.QUEUED, True, True))
else:
menu.append(make_menu_item(_('Download'), gtk.STOCK_GO_DOWN, selected_tasks, download.DownloadTask.QUEUED, can_queue, False))
menu.append(make_menu_item(_('Cancel'), gtk.STOCK_CANCEL, selected_tasks, download.DownloadTask.CANCELLED, can_cancel))
menu.append(make_menu_item(_('Pause'), gtk.STOCK_MEDIA_PAUSE, selected_tasks, download.DownloadTask.PAUSED, can_pause))
menu.append(gtk.SeparatorMenuItem())
menu.append(make_menu_item(_('Remove from list'), gtk.STOCK_REMOVE, selected_tasks, None, can_remove))
menu.show_all()
if event is None:
func = TreeViewHelper.make_popup_position_func(treeview)
menu.popup(None, None, func, 3, 0)
else:
menu.popup(None, None, None, event.button, event.time)
return True
def on_mark_episodes_as_old(self, item):
assert self.active_channel is not None
for episode in self.active_channel.get_all_episodes():
if not episode.was_downloaded(and_exists=True):
episode.mark(is_played=True)
self.update_podcast_list_model(selected=True)
self.update_episode_list_icons(all=True)
def on_open_download_folder(self, item):
assert self.active_channel is not None
util.gui_open(self.active_channel.save_dir)
def treeview_channels_show_context_menu(self, treeview, event=None):
model, paths = self.treeview_handle_context_menu_click(treeview, event)
if not paths:
return True
# Check for valid channel id, if there's no id then
# assume that it is a proxy channel or equivalent
# and cannot be operated with right click
if self.active_channel.id is None:
return True
if event is None or event.button == 3:
menu = gtk.Menu()
item = gtk.ImageMenuItem( _('Update podcast'))
item.set_image(gtk.image_new_from_stock(gtk.STOCK_REFRESH, gtk.ICON_SIZE_MENU))
item.connect('activate', self.on_itemUpdateChannel_activate)
menu.append(item)
menu.append(gtk.SeparatorMenuItem())
item = gtk.MenuItem(_('Open download folder'))
item.connect('activate', self.on_open_download_folder)
menu.append(item)
menu.append(gtk.SeparatorMenuItem())
item = gtk.MenuItem(_('Mark episodes as old'))
item.connect('activate', self.on_mark_episodes_as_old)
menu.append(item)
item = gtk.CheckMenuItem(_('Archive'))
item.set_active(self.active_channel.auto_archive_episodes)
item.connect('activate', self.on_channel_toggle_lock_activate)
menu.append(item)
item = gtk.ImageMenuItem(_('Remove podcast'))
item.set_image(gtk.image_new_from_stock(gtk.STOCK_DELETE, gtk.ICON_SIZE_MENU))
item.connect( 'activate', self.on_itemRemoveChannel_activate)
menu.append( item)
menu.append( gtk.SeparatorMenuItem())
item = gtk.ImageMenuItem(_('Podcast settings'))
item.set_image(gtk.image_new_from_stock(gtk.STOCK_INFO, gtk.ICON_SIZE_MENU))
item.connect('activate', self.on_itemEditChannel_activate)
menu.append(item)
menu.show_all()
# Disable tooltips while we are showing the menu, so
# the tooltip will not appear over the menu
self.treeview_allow_tooltips(self.treeChannels, False)
menu.connect('deactivate', lambda menushell: self.treeview_allow_tooltips(self.treeChannels, True))
if event is None:
func = TreeViewHelper.make_popup_position_func(treeview)
menu.popup(None, None, func, 3, 0)
else:
menu.popup(None, None, None, event.button, event.time)
return True
def cover_download_finished(self, channel, pixbuf):
"""
The Cover Downloader calls this when it has finished
downloading (or registering, if already downloaded)
a new channel cover, which is ready for displaying.
"""
util.idle_add(self.podcast_list_model.add_cover_by_channel,
channel, pixbuf)
def save_episodes_as_file(self, episodes):
for episode in episodes:
self.save_episode_as_file(episode)
def save_episode_as_file(self, episode):
PRIVATE_FOLDER_ATTRIBUTE = '_save_episodes_as_file_folder'
if episode.was_downloaded(and_exists=True):
folder = getattr(self, PRIVATE_FOLDER_ATTRIBUTE, None)
copy_from = episode.local_filename(create=False)
assert copy_from is not None
copy_to = util.sanitize_filename(episode.sync_filename())
(result, folder) = self.show_copy_dialog(src_filename=copy_from, dst_filename=copy_to, dst_directory=folder)
setattr(self, PRIVATE_FOLDER_ATTRIBUTE, folder)
def copy_episodes_bluetooth(self, episodes):
episodes_to_copy = [e for e in episodes if e.was_downloaded(and_exists=True)]
def convert_and_send_thread(episode):
for episode in episodes:
filename = episode.local_filename(create=False)
assert filename is not None
destfile = os.path.join(tempfile.gettempdir(), \
util.sanitize_filename(episode.sync_filename()))
(base, ext) = os.path.splitext(filename)
if not destfile.endswith(ext):
destfile += ext
try:
shutil.copyfile(filename, destfile)
util.bluetooth_send_file(destfile)
except:
logger.error('Cannot copy "%s" to "%s".', filename, destfile)
self.notification(_('Error converting file.'), _('Bluetooth file transfer'), important=True)
util.delete_file(destfile)
threading.Thread(target=convert_and_send_thread, args=[episodes_to_copy]).start()
def treeview_available_show_context_menu(self, treeview, event=None):
model, paths = self.treeview_handle_context_menu_click(treeview, event)
if not paths:
if not hasattr(treeview, 'is_rubber_banding_active'):
return True
else:
return not treeview.is_rubber_banding_active()
if event is None or event.button == 3:
episodes = self.get_selected_episodes()
any_locked = any(e.archive for e in episodes)
any_new = any(e.is_new for e in episodes)
downloaded = all(e.was_downloaded(and_exists=True) for e in episodes)
downloading = any(e.downloading for e in episodes)
menu = gtk.Menu()
(can_play, can_download, can_cancel, can_delete, open_instead_of_play) = self.play_or_download()
if open_instead_of_play:
item = gtk.ImageMenuItem(gtk.STOCK_OPEN)
elif downloaded:
item = gtk.ImageMenuItem(gtk.STOCK_MEDIA_PLAY)
else:
if downloading:
item = gtk.ImageMenuItem(_('Preview'))
else:
item = gtk.ImageMenuItem(_('Stream'))
item.set_image(gtk.image_new_from_stock(gtk.STOCK_MEDIA_PLAY, gtk.ICON_SIZE_MENU))
item.set_sensitive(can_play)
item.connect('activate', self.on_playback_selected_episodes)
menu.append(item)
if not can_cancel:
item = gtk.ImageMenuItem(_('Download'))
item.set_image(gtk.image_new_from_stock(gtk.STOCK_GO_DOWN, gtk.ICON_SIZE_MENU))
item.set_sensitive(can_download)
item.connect('activate', self.on_download_selected_episodes)
menu.append(item)
else:
item = gtk.ImageMenuItem(gtk.STOCK_CANCEL)
item.connect('activate', self.on_item_cancel_download_activate)
menu.append(item)
item = gtk.ImageMenuItem(gtk.STOCK_DELETE)
item.set_sensitive(can_delete)
item.connect('activate', self.on_btnDownloadedDelete_clicked)
menu.append(item)
result = gpodder.user_extensions.on_episodes_context_menu(episodes)
if result:
menu.append(gtk.SeparatorMenuItem())
for label, callback in result:
item = gtk.MenuItem(label)
item.connect('activate', lambda item, callback:
callback(episodes), callback)
menu.append(item)
# Ok, this probably makes sense to only display for downloaded files
if downloaded:
menu.append(gtk.SeparatorMenuItem())
share_item = gtk.MenuItem(_('Send to'))
menu.append(share_item)
share_menu = gtk.Menu()
item = gtk.ImageMenuItem(_('Local folder'))
item.set_image(gtk.image_new_from_stock(gtk.STOCK_DIRECTORY, gtk.ICON_SIZE_MENU))
item.connect('button-press-event', lambda w, ee: self.save_episodes_as_file(episodes))
share_menu.append(item)
if self.bluetooth_available:
item = gtk.ImageMenuItem(_('Bluetooth device'))
item.set_image(gtk.image_new_from_icon_name('bluetooth', gtk.ICON_SIZE_MENU))
item.connect('button-press-event', lambda w, ee: self.copy_episodes_bluetooth(episodes))
share_menu.append(item)
share_item.set_submenu(share_menu)
menu.append(gtk.SeparatorMenuItem())
item = gtk.CheckMenuItem(_('New'))
item.set_active(any_new)
if any_new:
item.connect('activate', lambda w: self.mark_selected_episodes_old())
else:
item.connect('activate', lambda w: self.mark_selected_episodes_new())
menu.append(item)
if downloaded:
item = gtk.CheckMenuItem(_('Archive'))
item.set_active(any_locked)
item.connect('activate', lambda w: self.on_item_toggle_lock_activate( w, False, not any_locked))
menu.append(item)
menu.append(gtk.SeparatorMenuItem())
# Single item, add episode information menu item
item = gtk.ImageMenuItem(_('Episode details'))
item.set_image(gtk.image_new_from_stock( gtk.STOCK_INFO, gtk.ICON_SIZE_MENU))
item.connect('activate', lambda w: self.show_episode_shownotes(episodes[0]))
menu.append(item)
menu.show_all()
# Disable tooltips while we are showing the menu, so
# the tooltip will not appear over the menu
self.treeview_allow_tooltips(self.treeAvailable, False)
menu.connect('deactivate', lambda menushell: self.treeview_allow_tooltips(self.treeAvailable, True))
if event is None:
func = TreeViewHelper.make_popup_position_func(treeview)
menu.popup(None, None, func, 3, 0)
else:
menu.popup(None, None, None, event.button, event.time)
return True
def set_title(self, new_title):
self.default_title = new_title
self.gPodder.set_title(new_title)
def update_episode_list_icons(self, urls=None, selected=False, all=False):
"""
Updates the status icons in the episode list.
If urls is given, it should be a list of URLs
of episodes that should be updated.
If urls is None, set ONE OF selected, all to
True (the former updates just the selected
episodes and the latter updates all episodes).
"""
descriptions = self.config.episode_list_descriptions
if urls is not None:
# We have a list of URLs to walk through
self.episode_list_model.update_by_urls(urls, descriptions)
elif selected and not all:
# We should update all selected episodes
selection = self.treeAvailable.get_selection()
model, paths = selection.get_selected_rows()
for path in reversed(paths):
iter = model.get_iter(path)
self.episode_list_model.update_by_filter_iter(iter, descriptions)
elif all and not selected:
# We update all (even the filter-hidden) episodes
self.episode_list_model.update_all(descriptions)
else:
# Wrong/invalid call - have to specify at least one parameter
raise ValueError('Invalid call to update_episode_list_icons')
def episode_list_status_changed(self, episodes):
self.update_episode_list_icons(set(e.url for e in episodes))
self.update_podcast_list_model(set(e.channel.url for e in episodes))
self.db.commit()
def clean_up_downloads(self, delete_partial=False):
# Clean up temporary files left behind by old gPodder versions
temporary_files = glob.glob('%s/*/.tmp-*' % gpodder.downloads)
if delete_partial:
temporary_files += glob.glob('%s/*/*.partial' % gpodder.downloads)
for tempfile in temporary_files:
util.delete_file(tempfile)
def streaming_possible(self):
# User has to have a media player set on the Desktop, or else we
# would probably open the browser when giving a URL to xdg-open..
return (self.config.player and self.config.player != 'default')
def playback_episodes_for_real(self, episodes):
groups = collections.defaultdict(list)
for episode in episodes:
file_type = episode.file_type()
if file_type == 'video' and self.config.videoplayer and \
self.config.videoplayer != 'default':
player = self.config.videoplayer
elif file_type == 'audio' and self.config.player and \
self.config.player != 'default':
player = self.config.player
else:
player = 'default'
# Mark episode as played in the database
episode.playback_mark()
self.mygpo_client.on_playback([episode])
fmt_id = self.config.youtube_preferred_fmt_id
allow_partial = (player != 'default')
filename = episode.get_playback_url(fmt_id, allow_partial)
# Determine the playback resume position - if the file
# was played 100%, we simply start from the beginning
resume_position = episode.current_position
if resume_position == episode.total_time:
resume_position = 0
# If Panucci is configured, use D-Bus on Maemo to call it
if player == 'panucci':
try:
PANUCCI_NAME = 'org.panucci.panucciInterface'
PANUCCI_PATH = '/panucciInterface'
PANUCCI_INTF = 'org.panucci.panucciInterface'
o = gpodder.dbus_session_bus.get_object(PANUCCI_NAME, PANUCCI_PATH)
i = dbus.Interface(o, PANUCCI_INTF)
def on_reply(*args):
pass
def error_handler(filename, err):
logger.error('Exception in D-Bus call: %s', str(err))
# Fallback: use the command line client
for command in util.format_desktop_command('panucci', \
[filename]):
logger.info('Executing: %s', repr(command))
subprocess.Popen(command)
on_error = lambda err: error_handler(filename, err)
# This method only exists in Panucci > 0.9 ('new Panucci')
i.playback_from(filename, resume_position, \
reply_handler=on_reply, error_handler=on_error)
continue # This file was handled by the D-Bus call
except Exception, e:
logger.error('Calling Panucci using D-Bus', exc_info=True)
groups[player].append(filename)
# Open episodes with system default player
if 'default' in groups:
# Special-casing for a single episode when the object is a PDF
# file - this is needed on Maemo 5, so we only use gui_open()
# for single PDF files, but still use the built-in media player
# with an M3U file for single audio/video files. (The Maemo 5
# media player behaves differently when opening a single-file
# M3U playlist compared to opening the single file directly.)
if len(groups['default']) == 1:
fn = groups['default'][0]
# The list of extensions is taken from gui_open in util.py
# where all special-cases of Maemo apps are listed
for extension in ('.pdf', '.jpg', '.jpeg', '.png'):
if fn.lower().endswith(extension):
util.gui_open(fn)
groups['default'] = []
break
for filename in groups['default']:
logger.debug('Opening with system default: %s', filename)
util.gui_open(filename)
del groups['default']
# For each type now, go and create play commands
for group in groups:
for command in util.format_desktop_command(group, groups[group], resume_position):
logger.debug('Executing: %s', repr(command))
subprocess.Popen(command)
# Persist episode status changes to the database
self.db.commit()
# Flush updated episode status
self.mygpo_client.flush()
def playback_episodes(self, episodes):
# We need to create a list, because we run through it more than once
episodes = list(Model.sort_episodes_by_pubdate(e for e in episodes if \
e.was_downloaded(and_exists=True) or self.streaming_possible()))
try:
self.playback_episodes_for_real(episodes)
except Exception, e:
logger.error('Error in playback!', exc_info=True)
self.show_message(_('Please check your media player settings in the preferences dialog.'), \
_('Error opening player'), widget=self.toolPreferences)
channel_urls = set()
episode_urls = set()
for episode in episodes:
channel_urls.add(episode.channel.url)
episode_urls.add(episode.url)
self.update_episode_list_icons(episode_urls)
self.update_podcast_list_model(channel_urls)
def play_or_download(self):
if self.wNotebook.get_current_page() > 0:
self.toolCancel.set_sensitive(True)
return
if self.currently_updating:
return (False, False, False, False, False, False)
( can_play, can_download, can_cancel, can_delete ) = (False,)*4
( is_played, is_locked ) = (False,)*2
open_instead_of_play = False
selection = self.treeAvailable.get_selection()
if selection.count_selected_rows() > 0:
(model, paths) = selection.get_selected_rows()
for path in paths:
try:
episode = model.get_value(model.get_iter(path), EpisodeListModel.C_EPISODE)
except TypeError, te:
logger.error('Invalid episode at path %s', str(path))
continue
if episode.file_type() not in ('audio', 'video'):
open_instead_of_play = True
if episode.was_downloaded():
can_play = episode.was_downloaded(and_exists=True)
is_played = not episode.is_new
is_locked = episode.archive
if not can_play:
can_download = True
else:
if episode.downloading:
can_cancel = True
else:
can_download = True
can_download = can_download and not can_cancel
can_play = self.streaming_possible() or (can_play and not can_cancel and not can_download)
can_delete = not can_cancel
if open_instead_of_play:
self.toolPlay.set_stock_id(gtk.STOCK_OPEN)
else:
self.toolPlay.set_stock_id(gtk.STOCK_MEDIA_PLAY)
self.toolPlay.set_sensitive( can_play)
self.toolDownload.set_sensitive( can_download)
self.toolCancel.set_sensitive( can_cancel)
self.item_cancel_download.set_sensitive(can_cancel)
self.itemDownloadSelected.set_sensitive(can_download)
self.itemOpenSelected.set_sensitive(can_play)
self.itemPlaySelected.set_sensitive(can_play)
self.itemDeleteSelected.set_sensitive(can_delete)
self.item_toggle_played.set_sensitive(can_play)
self.item_toggle_lock.set_sensitive(can_play)
self.itemOpenSelected.set_visible(open_instead_of_play)
self.itemPlaySelected.set_visible(not open_instead_of_play)
return (can_play, can_download, can_cancel, can_delete, open_instead_of_play)
def on_cbMaxDownloads_toggled(self, widget, *args):
self.spinMaxDownloads.set_sensitive(self.cbMaxDownloads.get_active())
def on_cbLimitDownloads_toggled(self, widget, *args):
self.spinLimitDownloads.set_sensitive(self.cbLimitDownloads.get_active())
def episode_new_status_changed(self, urls):
self.update_podcast_list_model()
self.update_episode_list_icons(urls)
def update_podcast_list_model(self, urls=None, selected=False, select_url=None,
sections_changed=False):
"""Update the podcast list treeview model
If urls is given, it should list the URLs of each
podcast that has to be updated in the list.
If selected is True, only update the model contents
for the currently-selected podcast - nothing more.
The caller can optionally specify "select_url",
which is the URL of the podcast that is to be
selected in the list after the update is complete.
This only works if the podcast list has to be
reloaded; i.e. something has been added or removed
since the last update of the podcast list).
"""
selection = self.treeChannels.get_selection()
model, iter = selection.get_selected()
is_section = lambda r: r[PodcastListModel.C_URL] == '-'
is_separator = lambda r: r[PodcastListModel.C_SEPARATOR]
sections_active = any(is_section(x) for x in self.podcast_list_model)
if self.config.podcast_list_view_all:
# Update "all episodes" view in any case (if enabled)
self.podcast_list_model.update_first_row()
# List model length minus 1, because of "All"
list_model_length = len(self.podcast_list_model) - 1
else:
list_model_length = len(self.podcast_list_model)
force_update = (sections_active != self.config.podcast_list_sections or
sections_changed)
# Filter items in the list model that are not podcasts, so we get the
# correct podcast list count (ignore section headers and separators)
is_not_podcast = lambda r: is_section(r) or is_separator(r)
list_model_length -= len(filter(is_not_podcast, self.podcast_list_model))
if selected and not force_update:
# very cheap! only update selected channel
if iter is not None:
# If we have selected the "all episodes" view, we have
# to update all channels for selected episodes:
if self.config.podcast_list_view_all and \
self.podcast_list_model.iter_is_first_row(iter):
urls = self.get_podcast_urls_from_selected_episodes()
self.podcast_list_model.update_by_urls(urls)
else:
# Otherwise just update the selected row (a podcast)
self.podcast_list_model.update_by_filter_iter(iter)
if self.config.podcast_list_sections:
self.podcast_list_model.update_sections()
elif list_model_length == len(self.channels) and not force_update:
# we can keep the model, but have to update some
if urls is None:
# still cheaper than reloading the whole list
self.podcast_list_model.update_all()
else:
# ok, we got a bunch of urls to update
self.podcast_list_model.update_by_urls(urls)
if self.config.podcast_list_sections:
self.podcast_list_model.update_sections()
else:
if model and iter and select_url is None:
# Get the URL of the currently-selected podcast
select_url = model.get_value(iter, PodcastListModel.C_URL)
# Update the podcast list model with new channels
self.podcast_list_model.set_channels(self.db, self.config, self.channels)
try:
selected_iter = model.get_iter_first()
# Find the previously-selected URL in the new
# model if we have an URL (else select first)
if select_url is not None:
pos = model.get_iter_first()
while pos is not None:
url = model.get_value(pos, PodcastListModel.C_URL)
if url == select_url:
selected_iter = pos
break
pos = model.iter_next(pos)
if selected_iter is not None:
selection.select_iter(selected_iter)
self.on_treeChannels_cursor_changed(self.treeChannels)
except:
logger.error('Cannot select podcast in list', exc_info=True)
def on_episode_list_filter_changed(self, has_episodes):
pass # XXX: Remove?
def update_episode_list_model(self):
if self.channels and self.active_channel is not None:
self.currently_updating = True
self.episode_list_model.clear()
def update():
descriptions = self.config.episode_list_descriptions
self.episode_list_model.replace_from_channel(self.active_channel, descriptions)
self.treeAvailable.get_selection().unselect_all()
self.treeAvailable.scroll_to_point(0, 0)
self.currently_updating = False
self.play_or_download()
util.idle_add(update)
else:
self.episode_list_model.clear()
@dbus.service.method(gpodder.dbus_interface)
def offer_new_episodes(self, channels=None):
new_episodes = self.get_new_episodes(channels)
if new_episodes:
self.new_episodes_show(new_episodes)
return True
return False
def add_podcast_list(self, urls, auth_tokens=None):
"""Subscribe to a list of podcast given their URLs
If auth_tokens is given, it should be a dictionary
mapping URLs to (username, password) tuples."""
if auth_tokens is None:
auth_tokens = {}
existing_urls = set(podcast.url for podcast in self.channels)
# Sort and split the URL list into five buckets
queued, failed, existing, worked, authreq = [], [], [], [], []
for input_url in urls:
url = util.normalize_feed_url(input_url)
if url is None:
# Fail this one because the URL is not valid
failed.append(input_url)
elif url in existing_urls:
# A podcast already exists in the list for this URL
existing.append(url)
else:
# This URL has survived the first round - queue for add
queued.append(url)
if url != input_url and input_url in auth_tokens:
auth_tokens[url] = auth_tokens[input_url]
error_messages = {}
redirections = {}
progress = ProgressIndicator(_('Adding podcasts'), \
_('Please wait while episode information is downloaded.'), \
parent=self.get_dialog_parent())
def on_after_update():
progress.on_finished()
# Report already-existing subscriptions to the user
if existing:
title = _('Existing subscriptions skipped')
message = _('You are already subscribed to these podcasts:') \
+ '\n\n' + '\n'.join(cgi.escape(url) for url in existing)
self.show_message(message, title, widget=self.treeChannels)
# Report subscriptions that require authentication
retry_podcasts = {}
if authreq:
for url in authreq:
title = _('Podcast requires authentication')
message = _('Please login to %s:') % (cgi.escape(url),)
success, auth_tokens = self.show_login_dialog(title, message)
if success:
retry_podcasts[url] = auth_tokens
else:
# Stop asking the user for more login data
retry_podcasts = {}
for url in authreq:
error_messages[url] = _('Authentication failed')
failed.append(url)
break
# Report website redirections
for url in redirections:
title = _('Website redirection detected')
message = _('The URL %(url)s redirects to %(target)s.') \
+ '\n\n' + _('Do you want to visit the website now?')
message = message % {'url': url, 'target': redirections[url]}
if self.show_confirmation(message, title):
util.open_website(url)
else:
break
# Report failed subscriptions to the user
if failed:
title = _('Could not add some podcasts')
message = _('Some podcasts could not be added to your list:') \
+ '\n\n' + '\n'.join(cgi.escape('%s: %s' % (url, \
error_messages.get(url, _('Unknown')))) for url in failed)
self.show_message(message, title, important=True)
# Upload subscription changes to gpodder.net
self.mygpo_client.on_subscribe(worked)
# Fix URLs if mygpo has rewritten them
self.rewrite_urls_mygpo()
# If only one podcast was added, select it after the update
if len(worked) == 1:
url = worked[0]
else:
url = None
# Update the list of subscribed podcasts
self.update_podcast_list_model(select_url=url)
# If we have authentication data to retry, do so here
if retry_podcasts:
self.add_podcast_list(retry_podcasts.keys(), retry_podcasts)
# This will NOT show new episodes for podcasts that have
# been added ("worked"), but it will prevent problems with
# multiple dialogs being open at the same time ;)
return
# Offer to download new episodes
episodes = []
for podcast in self.channels:
if podcast.url in worked:
episodes.extend(podcast.get_all_episodes())
if episodes:
episodes = list(Model.sort_episodes_by_pubdate(episodes, \
reverse=True))
self.new_episodes_show(episodes, \
selected=[e.check_is_new() for e in episodes])
def thread_proc():
# After the initial sorting and splitting, try all queued podcasts
length = len(queued)
for index, url in enumerate(queued):
progress.on_progress(float(index)/float(length))
progress.on_message(url)
try:
# The URL is valid and does not exist already - subscribe!
channel = self.model.load_podcast(url=url, create=True, \
authentication_tokens=auth_tokens.get(url, None), \
max_episodes=self.config.max_episodes_per_feed)
try:
username, password = util.username_password_from_url(url)
except ValueError, ve:
username, password = (None, None)
if username is not None and channel.auth_username is None and \
password is not None and channel.auth_password is None:
channel.auth_username = username
channel.auth_password = password
channel.save()
self._update_cover(channel)
except feedcore.AuthenticationRequired:
if url in auth_tokens:
# Fail for wrong authentication data
error_messages[url] = _('Authentication failed')
failed.append(url)
else:
# Queue for login dialog later
authreq.append(url)
continue
except feedcore.WifiLogin, error:
redirections[url] = error.data
failed.append(url)
error_messages[url] = _('Redirection detected')
continue
except Exception, e:
logger.error('Subscription error: %s', e, exc_info=True)
error_messages[url] = str(e)
failed.append(url)
continue
assert channel is not None
worked.append(channel.url)
util.idle_add(on_after_update)
threading.Thread(target=thread_proc).start()
def find_episode(self, podcast_url, episode_url):
"""Find an episode given its podcast and episode URL
The function will return a PodcastEpisode object if
the episode is found, or None if it's not found.
"""
for podcast in self.channels:
if podcast_url == podcast.url:
for episode in podcast.get_all_episodes():
if episode_url == episode.url:
return episode
return None
def process_received_episode_actions(self):
"""Process/merge episode actions from gpodder.net
This function will merge all changes received from
the server to the local database and update the
status of the affected episodes as necessary.
"""
indicator = ProgressIndicator(_('Merging episode actions'), \
_('Episode actions from gpodder.net are merged.'), \
False, self.get_dialog_parent())
while gtk.events_pending():
gtk.main_iteration(False)
self.mygpo_client.process_episode_actions(self.find_episode)
indicator.on_finished()
self.db.commit()
def _update_cover(self, channel):
if channel is not None:
self.cover_downloader.request_cover(channel)
def show_update_feeds_buttons(self):
# Make sure that the buttons for updating feeds
# appear - this should happen after a feed update
self.hboxUpdateFeeds.hide()
self.btnUpdateFeeds.show()
self.itemUpdate.set_sensitive(True)
self.itemUpdateChannel.set_sensitive(True)
def on_btnCancelFeedUpdate_clicked(self, widget):
if not self.feed_cache_update_cancelled:
self.pbFeedUpdate.set_text(_('Cancelling...'))
self.feed_cache_update_cancelled = True
self.btnCancelFeedUpdate.set_sensitive(False)
else:
self.show_update_feeds_buttons()
def update_feed_cache(self, channels=None,
show_new_episodes_dialog=True):
# Fix URLs if mygpo has rewritten them
self.rewrite_urls_mygpo()
if channels is None:
# Only update podcasts for which updates are enabled
channels = [c for c in self.channels if not c.pause_subscription]
self.itemUpdate.set_sensitive(False)
self.itemUpdateChannel.set_sensitive(False)
self.feed_cache_update_cancelled = False
self.btnCancelFeedUpdate.show()
self.btnCancelFeedUpdate.set_sensitive(True)
self.btnCancelFeedUpdate.set_image(gtk.image_new_from_stock(gtk.STOCK_STOP, gtk.ICON_SIZE_BUTTON))
self.hboxUpdateFeeds.show_all()
self.btnUpdateFeeds.hide()
count = len(channels)
text = N_('Updating %(count)d feed...', 'Updating %(count)d feeds...', count) % {'count':count}
self.pbFeedUpdate.set_text(text)
self.pbFeedUpdate.set_fraction(0)
def update_feed_cache_proc():
updated_channels = []
for updated, channel in enumerate(channels):
if self.feed_cache_update_cancelled:
break
try:
channel.update(max_episodes=self.config.max_episodes_per_feed)
self._update_cover(channel)
except Exception, e:
d = {'url': cgi.escape(channel.url), 'message': cgi.escape(str(e))}
if d['message']:
message = _('Error while updating %(url)s: %(message)s')
else:
message = _('The feed at %(url)s could not be updated.')
self.notification(message % d, _('Error while updating feed'), widget=self.treeChannels)
logger.error('Error: %s', str(e), exc_info=True)
updated_channels.append(channel)
def update_progress(channel):
self.update_podcast_list_model([channel.url])
# If the currently-viewed podcast is updated, reload episodes
if self.active_channel is not None and \
self.active_channel == channel:
logger.debug('Updated channel is active, updating UI')
self.update_episode_list_model()
d = {'podcast': channel.title, 'position': updated+1, 'total': count}
progression = _('Updated %(podcast)s (%(position)d/%(total)d)') % d
self.pbFeedUpdate.set_text(progression)
self.pbFeedUpdate.set_fraction(float(updated+1)/float(count))
util.idle_add(update_progress, channel)
def update_feed_cache_finish_callback():
# Process received episode actions for all updated URLs
self.process_received_episode_actions()
# If we are currently viewing "All episodes", update its episode list now
if self.active_channel is not None and \
getattr(self.active_channel, 'ALL_EPISODES_PROXY', False):
self.update_episode_list_model()
if self.feed_cache_update_cancelled:
# The user decided to abort the feed update
self.show_update_feeds_buttons()
# Only search for new episodes in podcasts that have been
# updated, not in other podcasts (for single-feed updates)
episodes = self.get_new_episodes([c for c in updated_channels])
if not episodes:
# Nothing new here - but inform the user
self.pbFeedUpdate.set_fraction(1.0)
self.pbFeedUpdate.set_text(_('No new episodes'))
self.feed_cache_update_cancelled = True
self.btnCancelFeedUpdate.show()
self.btnCancelFeedUpdate.set_sensitive(True)
self.itemUpdate.set_sensitive(True)
self.btnCancelFeedUpdate.set_image(gtk.image_new_from_stock(gtk.STOCK_APPLY, gtk.ICON_SIZE_BUTTON))
else:
count = len(episodes)
# New episodes are available
self.pbFeedUpdate.set_fraction(1.0)
if self.config.auto_download == 'download':
self.download_episode_list(episodes)
title = N_('Downloading %(count)d new episode.', 'Downloading %(count)d new episodes.', count) % {'count':count}
self.show_message(title, _('New episodes available'), widget=self.labelDownloads)
elif self.config.auto_download == 'queue':
self.download_episode_list_paused(episodes)
title = N_('%(count)d new episode added to download list.', '%(count)d new episodes added to download list.', count) % {'count':count}
self.show_message(title, _('New episodes available'), widget=self.labelDownloads)
else:
if (show_new_episodes_dialog and
self.config.auto_download == 'show'):
self.new_episodes_show(episodes, notification=True)
else: # !show_new_episodes_dialog or auto_download == 'ignore'
message = N_('%(count)d new episode available', '%(count)d new episodes available', count) % {'count':count}
self.pbFeedUpdate.set_text(message)
self.show_update_feeds_buttons()
util.idle_add(update_feed_cache_finish_callback)
threading.Thread(target=update_feed_cache_proc).start()
def on_gPodder_delete_event(self, widget, *args):
"""Called when the GUI wants to close the window
Displays a confirmation dialog (and closes/hides gPodder)
"""
downloading = self.download_status_model.are_downloads_in_progress()
if downloading:
dialog = gtk.MessageDialog(self.gPodder, gtk.DIALOG_MODAL, gtk.MESSAGE_QUESTION, gtk.BUTTONS_NONE)
dialog.add_button(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL)
quit_button = dialog.add_button(gtk.STOCK_QUIT, gtk.RESPONSE_CLOSE)
title = _('Quit gPodder')
message = _('You are downloading episodes. You can resume downloads the next time you start gPodder. Do you want to quit now?')
dialog.set_title(title)
dialog.set_markup('%s \n\n%s'%(title, message))
quit_button.grab_focus()
result = dialog.run()
dialog.destroy()
if result == gtk.RESPONSE_CLOSE:
self.close_gpodder()
else:
self.close_gpodder()
return True
def quit_cb(self, macapp):
"""Called when OSX wants to quit the app (Cmd-Q or gPodder > Quit)
"""
# Event can't really be cancelled - don't even try
self.close_gpodder()
return False
def close_gpodder(self):
""" clean everything and exit properly
"""
self.gPodder.hide()
# Notify all tasks to to carry out any clean-up actions
self.download_status_model.tell_all_tasks_to_quit()
while gtk.events_pending():
gtk.main_iteration(False)
self.core.shutdown()
self.quit()
if macapp is None:
sys.exit(0)
def get_expired_episodes(self):
# XXX: Move out of gtkui and into a generic module (gpodder.model)?
# Only expire episodes if the age in days is positive
if self.config.episode_old_age < 1:
return
for channel in self.channels:
for episode in channel.get_downloaded_episodes():
# Never consider archived episodes as old
if episode.archive:
continue
# Never consider fresh episodes as old
if episode.age_in_days() < self.config.episode_old_age:
continue
# Do not delete played episodes (except if configured)
if not episode.is_new:
if not self.config.auto_remove_played_episodes:
continue
# Do not delete unfinished episodes (except if configured)
if not episode.is_finished():
if not self.config.auto_remove_unfinished_episodes:
continue
# Do not delete unplayed episodes (except if configured)
if episode.is_new:
if not self.config.auto_remove_unplayed_episodes:
continue
yield episode
def delete_episode_list(self, episodes, confirm=True, skip_locked=True):
if not episodes:
return False
if skip_locked:
episodes = [e for e in episodes if not e.archive]
if not episodes:
title = _('Episodes are locked')
message = _('The selected episodes are locked. Please unlock the episodes that you want to delete before trying to delete them.')
self.notification(message, title, widget=self.treeAvailable)
return False
count = len(episodes)
title = N_('Delete %(count)d episode?', 'Delete %(count)d episodes?', count) % {'count':count}
message = _('Deleting episodes removes downloaded files.')
if confirm and not self.show_confirmation(message, title):
return False
progress = ProgressIndicator(_('Deleting episodes'), \
_('Please wait while episodes are deleted'), \
parent=self.get_dialog_parent())
def finish_deletion(episode_urls, channel_urls):
progress.on_finished()
# Episodes have been deleted - persist the database
self.db.commit()
self.update_episode_list_icons(episode_urls)
self.update_podcast_list_model(channel_urls)
self.play_or_download()
def thread_proc():
episode_urls = set()
channel_urls = set()
episodes_status_update = []
for idx, episode in enumerate(episodes):
progress.on_progress(float(idx)/float(len(episodes)))
if not episode.archive or not skip_locked:
progress.on_message(episode.title)
episode.delete_from_disk()
episode_urls.add(episode.url)
channel_urls.add(episode.channel.url)
episodes_status_update.append(episode)
# Tell the shownotes window that we have removed the episode
if self.episode_shownotes_window is not None and \
self.episode_shownotes_window.episode is not None and \
self.episode_shownotes_window.episode.url == episode.url:
util.idle_add(self.episode_shownotes_window._download_status_changed, None)
# Notify the web service about the status update + upload
self.mygpo_client.on_delete(episodes_status_update)
self.mygpo_client.flush()
util.idle_add(finish_deletion, episode_urls, channel_urls)
threading.Thread(target=thread_proc).start()
return True
def on_itemRemoveOldEpisodes_activate(self, widget):
self.show_delete_episodes_window()
def show_delete_episodes_window(self, channel=None):
"""Offer deletion of episodes
If channel is None, offer deletion of all episodes.
Otherwise only offer deletion of episodes in the channel.
"""
columns = (
('markup_delete_episodes', None, None, _('Episode')),
)
msg_older_than = N_('Select older than %(count)d day', 'Select older than %(count)d days', self.config.episode_old_age)
selection_buttons = {
_('Select played'): lambda episode: not episode.is_new,
_('Select finished'): lambda episode: episode.is_finished(),
msg_older_than % {'count':self.config.episode_old_age}: lambda episode: episode.age_in_days() > self.config.episode_old_age,
}
instructions = _('Select the episodes you want to delete:')
if channel is None:
channels = self.channels
else:
channels = [channel]
episodes = []
for channel in channels:
for episode in channel.get_downloaded_episodes():
# Disallow deletion of locked episodes that still exist
if not episode.archive or not episode.file_exists():
episodes.append(episode)
selected = [not e.is_new or not e.file_exists() for e in episodes]
gPodderEpisodeSelector(self.gPodder, title = _('Delete episodes'), instructions = instructions, \
episodes = episodes, selected = selected, columns = columns, \
stock_ok_button = gtk.STOCK_DELETE, callback = self.delete_episode_list, \
selection_buttons = selection_buttons, _config=self.config, \
show_episode_shownotes=self.show_episode_shownotes)
def on_selected_episodes_status_changed(self):
# The order of the updates here is important! When "All episodes" is
# selected, the update of the podcast list model depends on the episode
# list selection to determine which podcasts are affected. Updating
# the episode list could remove the selection if a filter is active.
self.update_podcast_list_model(selected=True)
self.update_episode_list_icons(selected=True)
self.db.commit()
def mark_selected_episodes_new(self):
for episode in self.get_selected_episodes():
episode.mark_new()
self.on_selected_episodes_status_changed()
def mark_selected_episodes_old(self):
for episode in self.get_selected_episodes():
episode.mark_old()
self.on_selected_episodes_status_changed()
def on_item_toggle_played_activate( self, widget, toggle = True, new_value = False):
for episode in self.get_selected_episodes():
if toggle:
episode.mark(is_played=episode.is_new)
else:
episode.mark(is_played=new_value)
self.on_selected_episodes_status_changed()
def on_item_toggle_lock_activate(self, widget, toggle=True, new_value=False):
for episode in self.get_selected_episodes():
if toggle:
episode.mark(is_locked=not episode.archive)
else:
episode.mark(is_locked=new_value)
self.on_selected_episodes_status_changed()
def on_channel_toggle_lock_activate(self, widget, toggle=True, new_value=False):
if self.active_channel is None:
return
self.active_channel.auto_archive_episodes = not self.active_channel.auto_archive_episodes
self.active_channel.save()
for episode in self.active_channel.get_all_episodes():
episode.mark(is_locked=self.active_channel.auto_archive_episodes)
self.update_podcast_list_model(selected=True)
self.update_episode_list_icons(all=True)
def on_itemUpdateChannel_activate(self, widget=None):
if self.active_channel is None:
title = _('No podcast selected')
message = _('Please select a podcast in the podcasts list to update.')
self.show_message( message, title, widget=self.treeChannels)
return
# Dirty hack to check for "All episodes" (see gpodder.gtkui.model)
if getattr(self.active_channel, 'ALL_EPISODES_PROXY', False):
self.update_feed_cache()
else:
self.update_feed_cache(channels=[self.active_channel])
def on_itemUpdate_activate(self, widget=None):
# Check if we have outstanding subscribe/unsubscribe actions
self.on_add_remove_podcasts_mygpo()
if self.channels:
self.update_feed_cache()
else:
def show_welcome_window():
def on_show_example_podcasts(widget):
welcome_window.main_window.response(gtk.RESPONSE_CANCEL)
self.on_itemImportChannels_activate(None)
def on_add_podcast_via_url(widget):
welcome_window.main_window.response(gtk.RESPONSE_CANCEL)
self.on_itemAddChannel_activate(None)
def on_setup_my_gpodder(widget):
welcome_window.main_window.response(gtk.RESPONSE_CANCEL)
self.on_download_subscriptions_from_mygpo(None)
welcome_window = gPodderWelcome(self.main_window,
center_on_widget=self.main_window,
on_show_example_podcasts=on_show_example_podcasts,
on_add_podcast_via_url=on_add_podcast_via_url,
on_setup_my_gpodder=on_setup_my_gpodder)
welcome_window.main_window.run()
welcome_window.main_window.destroy()
util.idle_add(show_welcome_window)
def download_episode_list_paused(self, episodes):
self.download_episode_list(episodes, True)
def download_episode_list(self, episodes, add_paused=False, force_start=False):
enable_update = False
for episode in episodes:
logger.debug('Downloading episode: %s', episode.title)
if not episode.was_downloaded(and_exists=True):
task_exists = False
for task in self.download_tasks_seen:
if episode.url == task.url and task.status not in (task.DOWNLOADING, task.QUEUED):
self.download_queue_manager.add_task(task, force_start)
enable_update = True
task_exists = True
continue
if task_exists:
continue
try:
task = download.DownloadTask(episode, self.config)
except Exception, e:
d = {'episode': episode.title, 'message': str(e)}
message = _('Download error while downloading %(episode)s: %(message)s')
self.show_message(message % d, _('Download error'), important=True)
logger.error('While downloading %s', episode.title, exc_info=True)
continue
if add_paused:
task.status = task.PAUSED
else:
self.mygpo_client.on_download([task.episode])
self.download_queue_manager.add_task(task, force_start)
self.download_status_model.register_task(task)
enable_update = True
if enable_update:
self.enable_download_list_update()
# Flush updated episode status
self.mygpo_client.flush()
def cancel_task_list(self, tasks):
if not tasks:
return
for task in tasks:
if task.status in (task.QUEUED, task.DOWNLOADING):
task.status = task.CANCELLED
elif task.status == task.PAUSED:
task.status = task.CANCELLED
# Call run, so the partial file gets deleted
task.run()
self.update_episode_list_icons([task.url for task in tasks])
self.play_or_download()
# Update the tab title and downloads list
self.update_downloads_list()
def new_episodes_show(self, episodes, notification=False, selected=None):
columns = (
('markup_new_episodes', None, None, _('Episode')),
)
instructions = _('Select the episodes you want to download:')
if self.new_episodes_window is not None:
self.new_episodes_window.main_window.destroy()
self.new_episodes_window = None
def download_episodes_callback(episodes):
self.new_episodes_window = None
self.download_episode_list(episodes)
if selected is None:
# Select all by default
selected = [True]*len(episodes)
self.new_episodes_window = gPodderEpisodeSelector(self.gPodder, \
title=_('New episodes available'), \
instructions=instructions, \
episodes=episodes, \
columns=columns, \
selected=selected, \
stock_ok_button = 'gpodder-download', \
callback=download_episodes_callback, \
remove_callback=lambda e: e.mark_old(), \
remove_action=_('Mark as old'), \
remove_finished=self.episode_new_status_changed, \
_config=self.config, \
show_notification=False, \
show_episode_shownotes=self.show_episode_shownotes)
def on_itemDownloadAllNew_activate(self, widget, *args):
if not self.offer_new_episodes():
self.show_message(_('Please check for new episodes later.'), \
_('No new episodes available'), widget=self.btnUpdateFeeds)
def get_new_episodes(self, channels=None):
return [e for c in channels or self.channels for e in
filter(lambda e: e.check_is_new(), c.get_all_episodes())]
def commit_changes_to_database(self):
"""This will be called after the sync process is finished"""
self.db.commit()
def on_itemShowAllEpisodes_activate(self, widget):
self.config.podcast_list_view_all = widget.get_active()
def on_itemShowToolbar_activate(self, widget):
self.config.show_toolbar = self.itemShowToolbar.get_active()
def on_itemShowDescription_activate(self, widget):
self.config.episode_list_descriptions = self.itemShowDescription.get_active()
def on_item_view_hide_boring_podcasts_toggled(self, toggleaction):
self.config.podcast_list_hide_boring = toggleaction.get_active()
if self.config.podcast_list_hide_boring:
self.podcast_list_model.set_view_mode(self.config.episode_list_view_mode)
else:
self.podcast_list_model.set_view_mode(-1)
def on_item_view_episodes_changed(self, radioaction, current):
if current == self.item_view_episodes_all:
self.config.episode_list_view_mode = EpisodeListModel.VIEW_ALL
elif current == self.item_view_episodes_undeleted:
self.config.episode_list_view_mode = EpisodeListModel.VIEW_UNDELETED
elif current == self.item_view_episodes_downloaded:
self.config.episode_list_view_mode = EpisodeListModel.VIEW_DOWNLOADED
elif current == self.item_view_episodes_unplayed:
self.config.episode_list_view_mode = EpisodeListModel.VIEW_UNPLAYED
self.episode_list_model.set_view_mode(self.config.episode_list_view_mode)
if self.config.podcast_list_hide_boring:
self.podcast_list_model.set_view_mode(self.config.episode_list_view_mode)
def on_itemPreferences_activate(self, widget, *args):
gPodderPreferences(self.main_window, \
_config=self.config, \
user_apps_reader=self.user_apps_reader, \
parent_window=self.main_window, \
mygpo_client=self.mygpo_client, \
on_send_full_subscriptions=self.on_send_full_subscriptions, \
on_itemExportChannels_activate=self.on_itemExportChannels_activate)
def on_goto_mygpo(self, widget):
self.mygpo_client.open_website()
def on_download_subscriptions_from_mygpo(self, action=None):
title = _('Login to gpodder.net')
message = _('Please login to download your subscriptions.')
def on_register_button_clicked():
util.open_website('http://gpodder.net/register/')
success, (username, password) = self.show_login_dialog(title, message,
self.config.mygpo.username, self.config.mygpo.password,
register_callback=on_register_button_clicked)
if not success:
return
self.config.mygpo.username = username
self.config.mygpo.password = password
dir = gPodderPodcastDirectory(self.gPodder, _config=self.config, \
custom_title=_('Subscriptions on gpodder.net'), \
add_urls_callback=self.add_podcast_list, \
hide_url_entry=True)
# TODO: Refactor this into "gpodder.my" or mygpoclient, so that
# we do not have to hardcode the URL here
OPML_URL = 'http://gpodder.net/subscriptions/%s.opml' % self.config.mygpo.username
url = util.url_add_authentication(OPML_URL, \
self.config.mygpo.username, \
self.config.mygpo.password)
dir.download_opml_file(url)
def on_itemAddChannel_activate(self, widget=None):
gPodderAddPodcast(self.gPodder, \
add_urls_callback=self.add_podcast_list)
def on_itemEditChannel_activate(self, widget, *args):
if self.active_channel is None:
title = _('No podcast selected')
message = _('Please select a podcast in the podcasts list to edit.')
self.show_message( message, title, widget=self.treeChannels)
return
gPodderChannel(self.main_window,
channel=self.active_channel,
update_podcast_list_model=self.update_podcast_list_model,
cover_downloader=self.cover_downloader,
sections=set(c.section for c in self.channels),
clear_cover_cache=self.podcast_list_model.clear_cover_cache)
def on_itemMassUnsubscribe_activate(self, item=None):
columns = (
('title', None, None, _('Podcast')),
)
# We're abusing the Episode Selector for selecting Podcasts here,
# but it works and looks good, so why not? -- thp
gPodderEpisodeSelector(self.main_window, \
title=_('Remove podcasts'), \
instructions=_('Select the podcast you want to remove.'), \
episodes=self.channels, \
columns=columns, \
size_attribute=None, \
stock_ok_button=_('Remove'), \
callback=self.remove_podcast_list, \
_config=self.config)
def remove_podcast_list(self, channels, confirm=True):
if not channels:
return
if len(channels) == 1:
title = _('Removing podcast')
info = _('Please wait while the podcast is removed')
message = _('Do you really want to remove this podcast and its episodes?')
else:
title = _('Removing podcasts')
info = _('Please wait while the podcasts are removed')
message = _('Do you really want to remove the selected podcasts and their episodes?')
if confirm and not self.show_confirmation(message, title):
return
progress = ProgressIndicator(title, info, parent=self.get_dialog_parent())
def finish_deletion(select_url):
# Upload subscription list changes to the web service
self.mygpo_client.on_unsubscribe([c.url for c in channels])
# Re-load the channels and select the desired new channel
self.update_podcast_list_model(select_url=select_url)
progress.on_finished()
def thread_proc():
select_url = None
for idx, channel in enumerate(channels):
# Update the UI for correct status messages
progress.on_progress(float(idx)/float(len(channels)))
progress.on_message(channel.title)
# Delete downloaded episodes
channel.remove_downloaded()
# cancel any active downloads from this channel
for episode in channel.get_all_episodes():
if episode.downloading:
episode.download_task.cancel()
if len(channels) == 1:
# get the URL of the podcast we want to select next
if channel in self.channels:
position = self.channels.index(channel)
else:
position = -1
if position == len(self.channels)-1:
# this is the last podcast, so select the URL
# of the item before this one (i.e. the "new last")
select_url = self.channels[position-1].url
else:
# there is a podcast after the deleted one, so
# we simply select the one that comes after it
select_url = self.channels[position+1].url
# Remove the channel and clean the database entries
channel.delete()
# Clean up downloads and download directories
self.clean_up_downloads()
# The remaining stuff is to be done in the GTK main thread
util.idle_add(finish_deletion, select_url)
threading.Thread(target=thread_proc).start()
def on_itemRemoveChannel_activate(self, widget, *args):
if self.active_channel is None:
title = _('No podcast selected')
message = _('Please select a podcast in the podcasts list to remove.')
self.show_message( message, title, widget=self.treeChannels)
return
self.remove_podcast_list([self.active_channel])
def get_opml_filter(self):
filter = gtk.FileFilter()
filter.add_pattern('*.opml')
filter.add_pattern('*.xml')
filter.set_name(_('OPML files')+' (*.opml, *.xml)')
return filter
def on_item_import_from_file_activate(self, widget, filename=None):
if filename is None:
dlg = gtk.FileChooserDialog(title=_('Import from OPML'),
parent=self.main_window,
action=gtk.FILE_CHOOSER_ACTION_OPEN)
dlg.add_button(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL)
dlg.add_button(gtk.STOCK_OPEN, gtk.RESPONSE_OK)
dlg.set_filter(self.get_opml_filter())
response = dlg.run()
filename = None
if response == gtk.RESPONSE_OK:
filename = dlg.get_filename()
dlg.destroy()
if filename is not None:
dir = gPodderPodcastDirectory(self.gPodder, _config=self.config, \
custom_title=_('Import podcasts from OPML file'), \
add_urls_callback=self.add_podcast_list, \
hide_url_entry=True)
dir.download_opml_file(filename)
def on_itemExportChannels_activate(self, widget, *args):
if not self.channels:
title = _('Nothing to export')
message = _('Your list of podcast subscriptions is empty. Please subscribe to some podcasts first before trying to export your subscription list.')
self.show_message(message, title, widget=self.treeChannels)
return
dlg = gtk.FileChooserDialog(title=_('Export to OPML'), parent=self.gPodder, action=gtk.FILE_CHOOSER_ACTION_SAVE)
dlg.add_button(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL)
dlg.add_button(gtk.STOCK_SAVE, gtk.RESPONSE_OK)
dlg.set_filter(self.get_opml_filter())
response = dlg.run()
if response == gtk.RESPONSE_OK:
filename = dlg.get_filename()
dlg.destroy()
exporter = opml.Exporter( filename)
if filename is not None and exporter.write(self.channels):
count = len(self.channels)
title = N_('%(count)d subscription exported', '%(count)d subscriptions exported', count) % {'count':count}
self.show_message(_('Your podcast list has been successfully exported.'), title, widget=self.treeChannels)
else:
self.show_message( _('Could not export OPML to file. Please check your permissions.'), _('OPML export failed'), important=True)
else:
dlg.destroy()
def on_itemImportChannels_activate(self, widget, *args):
dir = gPodderPodcastDirectory(self.main_window, _config=self.config, \
add_urls_callback=self.add_podcast_list)
util.idle_add(dir.download_opml_file, my.EXAMPLES_OPML)
def on_homepage_activate(self, widget, *args):
util.open_website(gpodder.__url__)
def on_wiki_activate(self, widget, *args):
util.open_website('http://gpodder.org/wiki/User_Manual')
def on_check_for_updates_activate(self, widget):
self.check_for_updates(silent=False)
def check_for_updates(self, silent):
"""Check for updates and (optionally) show a message
If silent=False, a message will be shown even if no updates are
available (set silent=False when the check is manually triggered).
"""
up_to_date, version, released, days = util.get_update_info()
if up_to_date and not silent:
title = _('No updates available')
message = _('You have the latest version of gPodder.')
self.show_message(message, title, important=True)
if not up_to_date:
title = _('New version available')
message = '\n'.join([
_('Installed version: %s') % gpodder.__version__,
_('Newest version: %s') % version,
_('Release date: %s') % released,
'',
_('Download the latest version from gpodder.org?'),
])
if self.show_confirmation(message, title):
util.open_website('http://gpodder.org/downloads')
def on_bug_tracker_activate(self, widget, *args):
util.open_website('https://bugs.gpodder.org/enter_bug.cgi?product=gPodder&component=Application&version=%s' % gpodder.__version__)
def on_item_support_activate(self, widget):
util.open_website('http://gpodder.org/donate')
def on_itemAbout_activate(self, widget, *args):
dlg = gtk.Dialog(_('About gPodder'), self.main_window, \
gtk.DIALOG_MODAL)
dlg.add_button(gtk.STOCK_CLOSE, gtk.RESPONSE_OK).show()
dlg.set_resizable(False)
bg = gtk.HBox(spacing=10)
bg.pack_start(gtk.image_new_from_file(gpodder.icon_file), expand=False)
vb = gtk.VBox()
vb.set_spacing(6)
label = gtk.Label()
label.set_alignment(0, 1)
label.set_markup('gPodder %s%s %s \n%s' % (title, description)
gpodder-3.1.2/src/gpodder/gtkui/download.py 0000664 0001750 0001750 00000013467 11751103635 020307 0 ustar thp thp 0000000 0000000 # -*- coding: utf-8 -*-
#
# gPodder - A media aggregator and podcast client
# Copyright (c) 2005-2012 Thomas Perl and the gPodder Team
#
# gPodder is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# gPodder is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see %s - %s ' % (episode, message, podcast)
def request_update(self, iter, task=None):
if task is None:
# Ongoing update request from UI - get task from model
task = self.get_value(iter, self.C_TASK)
else:
# Initial update request - update non-changing fields
self.set(iter,
self.C_TASK, task,
self.C_URL, task.url)
if task.status == task.FAILED:
status_message = '%s: %s' % (\
task.STATUS_MESSAGE[task.status], \
task.error_message)
elif task.status == task.DOWNLOADING:
status_message = '%s (%.0f%%, %s/s)' % (\
task.STATUS_MESSAGE[task.status], \
task.progress*100, \
util.format_filesize(task.speed))
else:
status_message = task.STATUS_MESSAGE[task.status]
if task.progress > 0 and task.progress < 1:
current = util.format_filesize(task.progress*task.total_size, digits=1)
total = util.format_filesize(task.total_size, digits=1)
# Remove unit from current if same as in total
# (does: "12 MiB / 24 MiB" => "12 / 24 MiB")
current = current.split()
if current[-1] == total.split()[-1]:
current.pop()
current = ' '.join(current)
progress_message = ' / '.join((current, total))
elif task.total_size > 0:
progress_message = util.format_filesize(task.total_size, \
digits=1)
else:
progress_message = ('unknown size')
self.set(iter,
self.C_NAME, self._format_message(task.episode.title,
status_message, task.episode.channel.title),
self.C_PROGRESS, 100.*task.progress, \
self.C_PROGRESS_TEXT, progress_message, \
self.C_ICON_NAME, self._status_ids[task.status])
def __add_new_task(self, task):
iter = self.append()
self.request_update(iter, task)
def register_task(self, task):
util.idle_add(self.__add_new_task, task)
def tell_all_tasks_to_quit(self):
for row in self:
task = row[DownloadStatusModel.C_TASK]
if task is not None:
# Pause currently-running (and queued) downloads
if task.status in (task.QUEUED, task.DOWNLOADING):
task.status = task.PAUSED
# Delete cancelled and failed downloads
if task.status in (task.CANCELLED, task.FAILED):
task.removed_from_list()
def are_downloads_in_progress(self):
"""
Returns True if there are any downloads in the
QUEUED or DOWNLOADING status, False otherwise.
"""
for row in self:
task = row[DownloadStatusModel.C_TASK]
if task is not None and \
task.status in (task.DOWNLOADING, \
task.QUEUED):
return True
return False
class DownloadTaskMonitor(object):
"""A helper class that abstracts download events"""
def __init__(self, episode, on_can_resume, on_can_pause, on_finished):
self.episode = episode
self._status = None
self._on_can_resume = on_can_resume
self._on_can_pause = on_can_pause
self._on_finished = on_finished
def task_updated(self, task):
if self.episode.url == task.episode.url and self._status != task.status:
if task.status in (task.DONE, task.FAILED, task.CANCELLED):
self._on_finished()
elif task.status == task.PAUSED:
self._on_can_resume()
elif task.status in (task.QUEUED, task.DOWNLOADING):
self._on_can_pause()
self._status = task.status
gpodder-3.1.2/src/gpodder/gtkui/interface/ 0000775 0001750 0001750 00000000000 11760761026 020057 5 ustar thp thp 0000000 0000000 gpodder-3.1.2/src/gpodder/gtkui/interface/configeditor.py 0000664 0001750 0001750 00000010065 11751103635 023103 0 ustar thp thp 0000000 0000000 # -*- coding: utf-8 -*-
#
# gPodder - A media aggregator and podcast client
# Copyright (c) 2005-2012 Thomas Perl and the gPodder Team
#
# gPodder is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# gPodder is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see %s \n\n%s' % (title, message))
else:
dlg.set_markup('%s ' % (message))
dlg.run()
dlg.destroy()
else:
gpodder.user_extensions.on_notification_show(title, message)
def show_confirmation(self, message, title=None):
dlg = gtk.MessageDialog(self.main_window, gtk.DIALOG_MODAL, gtk.MESSAGE_QUESTION, gtk.BUTTONS_YES_NO)
if title:
dlg.set_title(str(title))
dlg.set_markup('%s \n\n%s' % (title, message))
else:
dlg.set_markup('%s ' % (message))
response = dlg.run()
dlg.destroy()
return response == gtk.RESPONSE_YES
def show_text_edit_dialog(self, title, prompt, text=None, empty=False, \
is_url=False, affirmative_text=gtk.STOCK_OK):
dialog = gtk.Dialog(title, self.get_dialog_parent(), \
gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT)
dialog.add_button(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL)
dialog.add_button(affirmative_text, gtk.RESPONSE_OK)
dialog.set_has_separator(False)
dialog.set_default_size(300, -1)
dialog.set_default_response(gtk.RESPONSE_OK)
text_entry = gtk.Entry()
text_entry.set_activates_default(True)
if text is not None:
text_entry.set_text(text)
text_entry.select_region(0, -1)
if not empty:
def on_text_changed(editable):
can_confirm = (editable.get_text() != '')
dialog.set_response_sensitive(gtk.RESPONSE_OK, can_confirm)
text_entry.connect('changed', on_text_changed)
if text is None:
dialog.set_response_sensitive(gtk.RESPONSE_OK, False)
hbox = gtk.HBox()
hbox.set_border_width(10)
hbox.set_spacing(10)
hbox.pack_start(gtk.Label(prompt), False, False)
hbox.pack_start(text_entry, True, True)
dialog.vbox.pack_start(hbox, True, True)
dialog.show_all()
response = dialog.run()
result = text_entry.get_text()
dialog.destroy()
if response == gtk.RESPONSE_OK:
return result
else:
return None
def show_login_dialog(self, title, message, username=None, password=None,
username_prompt=None, register_callback=None, register_text=None):
if username_prompt is None:
username_prompt = _('Username')
if register_text is None:
register_text = _('New user')
dialog = gtk.MessageDialog(
self.main_window,
gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
gtk.MESSAGE_QUESTION,
gtk.BUTTONS_CANCEL)
dialog.add_button(_('Login'), gtk.RESPONSE_OK)
dialog.set_image(gtk.image_new_from_stock(gtk.STOCK_DIALOG_AUTHENTICATION, gtk.ICON_SIZE_DIALOG))
dialog.set_title(_('Authentication required'))
dialog.set_markup('' + title + ' ')
dialog.format_secondary_markup(message)
dialog.set_default_response(gtk.RESPONSE_OK)
if register_callback is not None:
dialog.add_button(register_text, gtk.RESPONSE_HELP)
username_entry = gtk.Entry()
password_entry = gtk.Entry()
username_entry.connect('activate', lambda w: password_entry.grab_focus())
password_entry.set_visibility(False)
password_entry.set_activates_default(True)
if username is not None:
username_entry.set_text(username)
if password is not None:
password_entry.set_text(password)
table = gtk.Table(2, 2)
table.set_row_spacings(6)
table.set_col_spacings(6)
username_label = gtk.Label()
username_label.set_markup('' + username_prompt + ': ')
username_label.set_alignment(0.0, 0.5)
table.attach(username_label, 0, 1, 0, 1, gtk.FILL, 0)
table.attach(username_entry, 1, 2, 0, 1)
password_label = gtk.Label()
password_label.set_markup('' + _('Password') + ': ')
password_label.set_alignment(0.0, 0.5)
table.attach(password_label, 0, 1, 1, 2, gtk.FILL, 0)
table.attach(password_entry, 1, 2, 1, 2)
dialog.vbox.pack_end(table, True, True, 0)
dialog.show_all()
response = dialog.run()
while response == gtk.RESPONSE_HELP:
register_callback()
response = dialog.run()
password_entry.set_visibility(True)
username = username_entry.get_text()
password = password_entry.get_text()
success = (response == gtk.RESPONSE_OK)
dialog.destroy()
return (success, (username, password))
def show_copy_dialog(self, src_filename, dst_filename=None, dst_directory=None, title=_('Select destination')):
if dst_filename is None:
dst_filename = src_filename
if dst_directory is None:
dst_directory = os.path.expanduser('~')
base, extension = os.path.splitext(src_filename)
if not dst_filename.endswith(extension):
dst_filename += extension
dlg = gtk.FileChooserDialog(title=title, parent=self.main_window, action=gtk.FILE_CHOOSER_ACTION_SAVE)
dlg.add_button(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL)
dlg.add_button(gtk.STOCK_SAVE, gtk.RESPONSE_OK)
dlg.set_do_overwrite_confirmation(True)
dlg.set_current_name(os.path.basename(dst_filename))
dlg.set_current_folder(dst_directory)
result = False
folder = dst_directory
if dlg.run() == gtk.RESPONSE_OK:
result = True
dst_filename = dlg.get_filename()
folder = dlg.get_current_folder()
if not dst_filename.endswith(extension):
dst_filename += extension
shutil.copyfile(src_filename, dst_filename)
dlg.destroy()
return (result, folder)
class TreeViewHelper(object):
"""Container for gPodder-specific TreeView attributes."""
LAST_TOOLTIP = '_gpodder_last_tooltip'
CAN_TOOLTIP = '_gpodder_can_tooltip'
ROLE = '_gpodder_role'
COLUMNS = '_gpodder_columns'
# Enum for the role attribute
ROLE_PODCASTS, ROLE_EPISODES, ROLE_DOWNLOADS = range(3)
@classmethod
def set(cls, treeview, role):
setattr(treeview, cls.LAST_TOOLTIP, None)
setattr(treeview, cls.CAN_TOOLTIP, True)
setattr(treeview, cls.ROLE, role)
@staticmethod
def make_search_equal_func(gpodder_model):
def func(model, column, key, iter):
if model is None:
return True
key = key.lower()
for column in gpodder_model.SEARCH_COLUMNS:
if key in model.get_value(iter, column).lower():
return False
return True
return func
@classmethod
def register_column(cls, treeview, column):
if not hasattr(treeview, cls.COLUMNS):
setattr(treeview, cls.COLUMNS, [])
columns = getattr(treeview, cls.COLUMNS)
columns.append(column)
@classmethod
def get_columns(cls, treeview):
return getattr(treeview, cls.COLUMNS, [])
@staticmethod
def make_popup_position_func(widget):
def position_func(menu):
x, y = widget.window.get_origin()
return (x, y, True)
return position_func
gpodder-3.1.2/src/gpodder/gtkui/interface/addpodcast.py 0000664 0001750 0001750 00000006340 11751103635 022536 0 ustar thp thp 0000000 0000000 # -*- coding: utf-8 -*-
#
# gPodder - A media aggregator and podcast client
# Copyright (c) 2005-2012 Thomas Perl and the gPodder Team
#
# gPodder is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# gPodder is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see
import doctest
import unittest
import sys
try:
# Unused here locally, but we import it to be able to give an early
# warning about this missing dependency in order to avoid bogus errors.
import minimock
except ImportError, e:
print >>sys.stderr, """
Error: Unit tests require the "minimock" module (python-minimock).
Please install it before running the unit tests.
"""
sys.exit(2)
# Which package and which modules in the package should be tested?
package = 'gpodder'
modules = ['util', 'jsonconfig']
coverage_modules = []
suite = unittest.TestSuite()
for module in modules:
m = __import__('.'.join((package, module)), fromlist=[module])
coverage_modules.append(m)
suite.addTest(doctest.DocTestSuite(m))
runner = unittest.TextTestRunner(verbosity=2)
try:
import coverage
except ImportError:
coverage = None
if __name__ == '__main__':
if coverage is not None:
coverage.erase()
coverage.start()
result = runner.run(suite)
if not result.wasSuccessful():
sys.exit(1)
if coverage is not None:
coverage.stop()
coverage.report(coverage_modules)
coverage.erase()
else:
print >>sys.stderr, """
No coverage reporting done (Python module "coverage" is missing)
Please install the python-coverage package to get coverage reporting.
"""
gpodder-3.1.2/src/gpodder/services.py 0000664 0001750 0001750 00000003504 11751103635 017167 0 ustar thp thp 0000000 0000000 # -*- coding: utf-8 -*-
#
# gPodder - A media aggregator and podcast client
# Copyright (c) 2005-2012 Thomas Perl and the gPodder Team
#
# gPodder is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# gPodder is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see 2007-08-24
#
#
import gpodder
_ = gpodder.gettext
from gpodder import util
class ObservableService(object):
def __init__(self, signal_names=[]):
self.observers = {}
for signal in signal_names:
self.observers[signal] = []
def register(self, signal_name, observer):
if signal_name in self.observers:
if not observer in self.observers[signal_name]:
self.observers[signal_name].append(observer)
return True
return False
def unregister(self, signal_name, observer):
if signal_name in self.observers:
if observer in self.observers[signal_name]:
self.observers[signal_name].remove(observer)
return True
return False
def notify(self, signal_name, *args):
if signal_name in self.observers:
for observer in self.observers[signal_name]:
util.idle_add(observer, *args)
return True
return False
gpodder-3.1.2/src/gpodder/minidb.py 0000664 0001750 0001750 00000016445 11751103635 016616 0 ustar thp thp 0000000 0000000 #!/usr/bin/python
# -*- coding: utf-8 -*-
#
# gPodder - A media aggregator and podcast client
# Copyright (c) 2005-2012 Thomas Perl and the gPodder Team
#
# gPodder is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# gPodder is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see ' % (self.username, self.id)
m = Store()
m.save(Person('User %d' % x, x*20) for x in range(50))
p = m.get(Person, id=200)
print p
m.remove(p)
p = m.get(Person, id=200)
# Remove some persons again (deletion by value!)
m.remove(Person('User %d' % x, x*20) for x in range(40))
class Person(object):
__slots__ = {'username': str, 'id': int, 'mail': str}
def __init__(self, username, id, mail):
self.username = username
self.id = id
self.mail = mail
def __repr__(self):
return '' % (self.username, self.mail)
# A schema update takes place here
m.save(Person('User %d' % x, x*20, 'user@home.com') for x in range(50))
print m.load(Person)
gpodder-3.1.2/src/gpodder/vimeo.py 0000664 0001750 0001750 00000004757 11751103635 016476 0 ustar thp thp 0000000 0000000 # -*- coding: utf-8 -*-
#
# gPodder - A media aggregator and podcast client
# Copyright (c) 2005-2012 Thomas Perl and the gPodder Team
#
# gPodder is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# gPodder is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see ; 2012-01-03
#
import gpodder
from gpodder import util
import logging
logger = logging.getLogger(__name__)
import re
VIMEOCOM_RE = re.compile(r'http://vimeo\.com/(\d+)$', re.IGNORECASE)
MOOGALOOP_RE = re.compile(r'http://vimeo\.com/moogaloop\.swf\?clip_id=(\d+)$', re.IGNORECASE)
SIGNATURE_RE = re.compile(r'"signature":"([^"]+)","timestamp":(\d+)')
class VimeoError(BaseException): pass
def get_real_download_url(url):
quality = 'sd'
codecs = 'H264,VP8,VP6'
video_id = get_vimeo_id(url)
if video_id is None:
return url
web_url = 'http://vimeo.com/%s' % video_id
web_data = util.urlopen(web_url).read()
sig_pair = SIGNATURE_RE.search(web_data)
if sig_pair is None:
raise VimeoError('Cannot get signature pair from Vimeo')
signature, timestamp = sig_pair.groups()
params = '&'.join('%s=%s' % i for i in [
('clip_id', video_id),
('sig', signature),
('time', timestamp),
('quality', quality),
('codecs', codecs),
('type', 'moogaloop_local'),
('embed_location', ''),
])
player_url = 'http://player.vimeo.com/play_redirect?%s' % params
return player_url
def get_vimeo_id(url):
result = MOOGALOOP_RE.match(url)
if result is not None:
return result.group(1)
result = VIMEOCOM_RE.match(url)
if result is not None:
return result.group(1)
return None
def is_video_link(url):
return (get_vimeo_id(url) is not None)
def get_real_channel_url(url):
result = VIMEOCOM_RE.match(url)
if result is not None:
return 'http://vimeo.com/%s/videos/rss' % result.group(1)
return url
def get_real_cover(url):
return None
gpodder-3.1.2/src/gpodder/config.py 0000664 0001750 0001750 00000026116 11760704165 016622 0 ustar thp thp 0000000 0000000 # -*- coding: utf-8 -*-
#
# gPodder - A media aggregator and podcast client
# Copyright (c) 2005-2012 Thomas Perl and the gPodder Team
#
# gPodder is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# gPodder is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see 2007-11-02
#
import gpodder
from gpodder import util
from gpodder import jsonconfig
import atexit
import os
import shutil
import time
import threading
import logging
_ = gpodder.gettext
defaults = {
# External applications used for playback
'player': {
'audio': 'default',
'video': 'default',
},
# gpodder.net settings
'mygpo': {
'enabled': False,
'server': 'gpodder.net',
'username': '',
'password': '',
'device': {
'uid': util.get_hostname(),
'type': 'desktop',
'caption': _('gPodder on %s') % util.get_hostname(),
},
},
# Various limits (downloading, updating, etc..)
'limit': {
'bandwidth': {
'enabled': False,
'kbps': 500.0, # maximum kB/s per download
},
'downloads': {
'enabled': True,
'concurrent': 1,
},
'episodes': 200, # max episodes per feed
},
# Automatic feed updates, download removal and retry on download timeout
'auto': {
'update': {
'enabled': False,
'frequency': 20, # minutes
},
'cleanup': {
'days': 7,
'played': False,
'unplayed': False,
'unfinished': True,
},
'retries': 3, # number of retries when downloads time out
},
# Software updates from gpodder.org (primary audience: Windows users)
'software_update': {
'check_on_startup': gpodder.win32, # check for updates on start
'last_check': 0, # unix timestamp of last update check
'interval': 5, # interval (in days) to check for updates
},
'ui': {
# Settings for the Command-Line Interface
'cli': {
'colors': True,
},
# Settings for the QML UI (MeeGo Harmattan / N9)
'qml': {
'state': {
'episode_list_filter': 0,
},
'autorotate': False,
},
# Settings for the Gtk UI
'gtk': {
'state': {
'main_window': {
'width': 700,
'height': 500,
'x': -1, 'y': -1, 'maximized': False,
'paned_position': 200,
},
'episode_selector': {
'width': 600,
'height': 400,
'x': -1, 'y': -1, 'maximized': False,
},
'episode_window': {
'width': 500,
'height': 400,
'x': -1, 'y': -1, 'maximized': False,
},
},
'toolbar': False,
'html_shownotes': True,
'new_episodes': 'show', # ignore, show, queue, download
'live_search_delay': 200,
'podcast_list': {
'all_episodes': True,
'sections': True,
'view_mode': 1,
'hide_empty': False,
},
'episode_list': {
'descriptions': True,
'view_mode': 1,
'columns': int('101', 2), # bitfield of visible columns
},
'download_list': {
'remove_finished': True,
},
},
},
'youtube': {
'preferred_fmt_id': 18,
},
'extensions': {
'enabled': [],
},
}
# The sooner this goes away, the better
gPodderSettings_LegacySupport = {
'player': 'player.audio',
'videoplayer': 'player.video',
'limit_rate': 'limit.bandwidth.enabled',
'limit_rate_value': 'limit.bandwidth.kbps',
'max_downloads_enabled': 'limit.downloads.enabled',
'max_downloads': 'limit.downloads.concurrent',
'episode_old_age': 'auto.cleanup.days',
'auto_remove_played_episodes': 'auto.cleanup.played',
'auto_remove_unfinished_episodes': 'auto.cleanup.unfinished',
'auto_remove_unplayed_episodes': 'auto.cleanup.unplayed',
'max_episodes_per_feed': 'limit.episodes',
'show_toolbar': 'ui.gtk.toolbar',
'paned_position': 'ui.gtk.state.main_window.paned_position',
'episode_list_descriptions': 'ui.gtk.episode_list.descriptions',
'podcast_list_view_all': 'ui.gtk.podcast_list.all_episodes',
'podcast_list_sections': 'ui.gtk.podcast_list.sections',
'enable_html_shownotes': 'ui.gtk.html_shownotes',
'episode_list_view_mode': 'ui.gtk.episode_list.view_mode',
'podcast_list_view_mode': 'ui.gtk.podcast_list.view_mode',
'podcast_list_hide_boring': 'ui.gtk.podcast_list.hide_empty',
'youtube_preferred_fmt_id': 'youtube.preferred_fmt_id',
'episode_list_columns': 'ui.gtk.episode_list.columns',
'auto_cleanup_downloads': 'ui.gtk.download_list.remove_finished',
'auto_update_feeds': 'auto.update.enabled',
'auto_update_frequency': 'auto.update.frequency',
'auto_download': 'ui.gtk.new_episodes',
}
logger = logging.getLogger(__name__)
def config_value_to_string(config_value):
config_type = type(config_value)
if config_type == list:
return ','.join(map(config_value_to_string, config_value))
elif config_type in (str, unicode):
return config_value
else:
return str(config_value)
def string_to_config_value(new_value, old_value):
config_type = type(old_value)
if config_type == list:
return filter(None, [x.strip() for x in new_value.split(',')])
elif config_type == bool:
return (new_value.strip().lower() in ('1', 'true'))
else:
return config_type(new_value)
class Config(object):
# Number of seconds after which settings are auto-saved
WRITE_TO_DISK_TIMEOUT = 60
def __init__(self, filename='gpodder.json'):
self.__json_config = jsonconfig.JsonConfig(default=defaults,
on_key_changed=self._on_key_changed)
self.__save_thread = None
self.__filename = filename
self.__observers = []
self.load()
# If there is no configuration file, we create one here (bug 1511)
if not os.path.exists(self.__filename):
self.save()
atexit.register(self.__atexit)
def register_defaults(self, defaults):
"""
Register default configuration options (e.g. for extensions)
This function takes a dictionary that will be merged into the
current configuration if the keys don't yet exist. This can
be used to add a default configuration for extension modules.
"""
self.__json_config._merge_keys(defaults)
def add_observer(self, callback):
"""
Add a callback function as observer. This callback
will be called when a setting changes. It should
have this signature:
observer(name, old_value, new_value)
The "name" is the setting name, the "old_value" is
the value that has been overwritten with "new_value".
"""
if callback not in self.__observers:
self.__observers.append(callback)
else:
logger.warn('Observer already added: %s', repr(callback))
def remove_observer(self, callback):
"""
Remove an observer previously added to this object.
"""
if callback in self.__observers:
self.__observers.remove(callback)
else:
logger.warn('Observer not added: %s', repr(callback))
def all_keys(self):
return self.__json_config._keys_iter()
def schedule_save(self):
if self.__save_thread is None:
self.__save_thread = threading.Thread(target=self.save_thread_proc)
self.__save_thread.setDaemon(True)
self.__save_thread.start()
def save_thread_proc(self):
time.sleep(self.WRITE_TO_DISK_TIMEOUT)
if self.__save_thread is not None:
self.save()
def __atexit(self):
if self.__save_thread is not None:
self.save()
def save(self, filename=None):
if filename is None:
filename = self.__filename
logger.info('Flushing settings to disk')
try:
fp = open(filename+'.tmp', 'wt')
fp.write(repr(self.__json_config))
fp.close()
util.atomic_rename(filename+'.tmp', filename)
except:
logger.error('Cannot write settings to %s', filename)
util.delete_file(filename+'.tmp')
raise
self.__save_thread = None
def load(self, filename=None):
if filename is not None:
self.__filename = filename
if os.path.exists(self.__filename):
try:
data = open(self.__filename, 'rt').read()
new_keys_added = self.__json_config._restore(data)
except:
logger.warn('Cannot parse config file: %s',
self.__filename, exc_info=True)
new_keys_added = False
if new_keys_added:
logger.info('New default keys added - saving config.')
self.save()
def toggle_flag(self, name):
setattr(self, name, not getattr(self, name))
def update_field(self, name, new_value):
"""Update a config field, converting strings to the right types"""
old_value = self._lookup(name)
new_value = string_to_config_value(new_value, old_value)
setattr(self, name, new_value)
return True
def _on_key_changed(self, name, old_value, value):
if 'ui.gtk.state' not in name:
# Only log non-UI state changes
logger.debug('%s: %s -> %s', name, old_value, value)
for observer in self.__observers:
try:
observer(name, old_value, value)
except Exception, exception:
logger.error('Error while calling observer %r: %s',
observer, exception, exc_info=True)
self.schedule_save()
def __getattr__(self, name):
if name in gPodderSettings_LegacySupport:
name = gPodderSettings_LegacySupport[name]
return getattr(self.__json_config, name)
def __setattr__(self, name, value):
if name.startswith('_'):
object.__setattr__(self, name, value)
return
if name in gPodderSettings_LegacySupport:
name = gPodderSettings_LegacySupport[name]
setattr(self.__json_config, name, value)
gpodder-3.1.2/src/gpodder/youtube.py 0000664 0001750 0001750 00000016530 11751103635 017043 0 ustar thp thp 0000000 0000000 # -*- coding: utf-8 -*-
#
# gPodder - A media aggregator and podcast client
# Copyright (c) 2005-2012 Thomas Perl and the gPodder Team
#
# gPodder is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# gPodder is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see 2008-10-13
#
import gpodder
from gpodder import util
import logging
logger = logging.getLogger(__name__)
try:
import simplejson as json
except ImportError:
import json
import re
import urllib
# See http://en.wikipedia.org/wiki/YouTube#Quality_and_codecs
# Currently missing: 3GP profile
supported_formats = [
(37, '37/1920x1080/9/0/115', '1920x1080 (HD)'),
(22, '22/1280x720/9/0/115', '1280x720 (HD)'),
(35, '35/854x480/9/0/115', '854x480'),
(34, '34/640x360/9/0/115', '640x360'),
(18, '18/640x360/9/0/115', '640x360 (iPod)'),
(18, '18/480x360/9/0/115', '480x360 (iPod)'),
(5, '5/320x240/7/0/0', '320x240 (FLV)'),
# WebM formats have lower priority, because "most" players are still less
# compatible with WebM than their equivalent MP4 formats above (bug 1336)
# If you really want WebM files, set the preferred fmt_id to any of these:
(45, '45/1280x720/99/0/0', 'WebM 720p'),
(44, '44/854x480/99/0/0', 'WebM 480p'),
(43, '43/640x360/99/0/0', 'WebM 360p'),
]
class YouTubeError(Exception): pass
def get_real_download_url(url, preferred_fmt_id=None):
# Default fmt_id when none preferred
if preferred_fmt_id is None:
preferred_fmt_id = 18
# For Maemo 5, we force fmt_id 5 for performance reasons
if gpodder.ui.fremantle:
preferred_fmt_id = 5
vid = get_youtube_id(url)
if vid is not None:
page = None
url = 'http://www.youtube.com/watch?v=' + vid
while page is None:
req = util.http_request(url, method='GET')
if 'location' in req.msg:
url = req.msg['location']
else:
page = req.read()
# Try to find the best video format available for this video
# (http://forum.videohelp.com/topic336882-1800.html#1912972)
def find_urls(page):
r4 = re.search('.*"url_encoded_fmt_stream_map"\:\s+"([^"]+)".*', page)
if r4 is not None:
fmt_url_map = r4.group(1)
for fmt_url_encoded in fmt_url_map.split(','):
video_info = dict(map(urllib.unquote, x.split('=', 1))
for x in fmt_url_encoded.split('\\u0026'))
yield int(video_info['itag']), video_info['url']
fmt_id_url_map = sorted(find_urls(page), reverse=True)
# Default to the highest fmt_id if we don't find a match below
if fmt_id_url_map:
default_fmt_id, default_url = fmt_id_url_map[0]
else:
raise YouTubeError('fmt_url_map not found for video ID "%s"' % vid)
formats_available = set(fmt_id for fmt_id, url in fmt_id_url_map)
fmt_id_url_map = dict(fmt_id_url_map)
if gpodder.ui.fremantle or gpodder.ui.harmattan:
# This provides good quality video, seems to be always available
# and is playable fluently in Media Player
if preferred_fmt_id == 5:
fmt_id = 5
else:
fmt_id = 18
else:
# As a fallback, use fmt_id 18 (seems to be always available)
fmt_id = 18
# This will be set to True if the search below has already "seen"
# our preferred format, but has not yet found a suitable available
# format for the given video.
seen_preferred = False
for id, wanted, description in supported_formats:
# If we see our preferred format, accept formats below
if id == preferred_fmt_id:
seen_preferred = True
# If the format is available and preferred (or lower),
# use the given format for our fmt_id
if id in formats_available and seen_preferred:
logger.info('Found YouTube format: %s (fmt_id=%d)',
description, id)
fmt_id = id
break
url = fmt_id_url_map.get(fmt_id, None)
if url is None:
url = default_url
return url
def get_youtube_id(url):
r = re.compile('http://(?:[a-z]+\.)?youtube\.com/v/(.*)\.swf', re.IGNORECASE).match(url)
if r is not None:
return r.group(1)
r = re.compile('http://(?:[a-z]+\.)?youtube\.com/watch\?v=([^&]*)', re.IGNORECASE).match(url)
if r is not None:
return r.group(1)
r = re.compile('http://(?:[a-z]+\.)?youtube\.com/v/(.*)[?]', re.IGNORECASE).match(url)
if r is not None:
return r.group(1)
return None
def is_video_link(url):
return (get_youtube_id(url) is not None)
def is_youtube_guid(guid):
return guid.startswith('tag:youtube.com,2008:video:')
def get_real_channel_url(url):
r = re.compile('http://(?:[a-z]+\.)?youtube\.com/user/([a-z0-9]+)', re.IGNORECASE)
m = r.match(url)
if m is not None:
next = 'http://www.youtube.com/rss/user/'+ m.group(1) +'/videos.rss'
logger.debug('YouTube link resolved: %s => %s', url, next)
return next
r = re.compile('http://(?:[a-z]+\.)?youtube\.com/profile?user=([a-z0-9]+)', re.IGNORECASE)
m = r.match(url)
if m is not None:
next = 'http://www.youtube.com/rss/user/'+ m.group(1) +'/videos.rss'
logger.debug('YouTube link resolved: %s => %s', url, next)
return next
return url
def get_real_cover(url):
r = re.compile('http://www\.youtube\.com/rss/user/([^/]+)/videos\.rss', \
re.IGNORECASE)
m = r.match(url)
if m is not None:
username = m.group(1)
api_url = 'http://gdata.youtube.com/feeds/api/users/%s?v=2' % username
data = util.urlopen(api_url).read()
match = re.search('', data)
if match is not None:
logger.debug('YouTube userpic for %s is: %s', url, match.group(1))
return match.group(1)
return None
def find_youtube_channels(string):
url = 'http://gdata.youtube.com/feeds/api/videos?alt=json&q=%s' % urllib.quote(string, '')
data = json.load(util.urlopen(url))
class FakeImporter(object):
def __init__(self):
self.items = []
result = FakeImporter()
seen_users = set()
for entry in data['feed']['entry']:
user = entry['author'][0]['name']['$t']
title = entry['title']['$t']
url = 'http://www.youtube.com/rss/user/%s/videos.rss' % user
if user not in seen_users:
result.items.append({
'title': user,
'url': url,
'description': title
})
seen_users.add(user)
return result
gpodder-3.1.2/src/gpodder/schema.py 0000664 0001750 0001750 00000016557 11751103635 016620 0 ustar thp thp 0000000 0000000 # -*- coding: utf-8 -*-
#
# gPodder - A media aggregator and podcast client
# Copyright (c) 2005-2012 Thomas Perl and the gPodder Team
#
# gPodder is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# gPodder is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see ; 2011-02-01
from sqlite3 import dbapi2 as sqlite
import time
import shutil
EpisodeColumns = (
'podcast_id',
'title',
'description',
'url',
'published',
'guid',
'link',
'file_size',
'mime_type',
'state',
'is_new',
'archive',
'download_filename',
'total_time',
'current_position',
'current_position_updated',
'last_playback',
)
PodcastColumns = (
'title',
'url',
'link',
'description',
'cover_url',
'auth_username',
'auth_password',
'http_last_modified',
'http_etag',
'auto_archive_episodes',
'download_folder',
'pause_subscription',
'section',
)
CURRENT_VERSION = 2
def initialize_database(db):
# Create table for podcasts
db.execute("""
CREATE TABLE podcast (
id INTEGER PRIMARY KEY NOT NULL,
title TEXT NOT NULL DEFAULT '',
url TEXT NOT NULL DEFAULT '',
link TEXT NOT NULL DEFAULT '',
description TEXT NOT NULL DEFAULT '',
cover_url TEXT NULL DEFAULT NULL,
auth_username TEXT NULL DEFAULT NULL,
auth_password TEXT NULL DEFAULT NULL,
http_last_modified TEXT NULL DEFAULT NULL,
http_etag TEXT NULL DEFAULT NULL,
auto_archive_episodes INTEGER NOT NULL DEFAULT 0,
download_folder TEXT NOT NULL DEFAULT '',
pause_subscription INTEGER NOT NULL DEFAULT 0,
section TEXT NOT NULL DEFAULT ''
)
""")
INDEX_SQL = """
CREATE UNIQUE INDEX idx_podcast_url ON podcast (url)
CREATE UNIQUE INDEX idx_podcast_download_folder ON podcast (download_folder)
"""
for sql in INDEX_SQL.strip().split('\n'):
db.execute(sql)
# Create table for episodes
db.execute("""
CREATE TABLE episode (
id INTEGER PRIMARY KEY NOT NULL,
podcast_id INTEGER NOT NULL,
title TEXT NOT NULL DEFAULT '',
description TEXT NOT NULL DEFAULT '',
url TEXT NOT NULL,
published INTEGER NOT NULL DEFAULT 0,
guid TEXT NOT NULL,
link TEXT NOT NULL DEFAULT '',
file_size INTEGER NOT NULL DEFAULT 0,
mime_type TEXT NOT NULL DEFAULT 'application/octet-stream',
state INTEGER NOT NULL DEFAULT 0,
is_new INTEGER NOT NULL DEFAULT 0,
archive INTEGER NOT NULL DEFAULT 0,
download_filename TEXT NULL DEFAULT NULL,
total_time INTEGER NOT NULL DEFAULT 0,
current_position INTEGER NOT NULL DEFAULT 0,
current_position_updated INTEGER NOT NULL DEFAULT 0,
last_playback INTEGER NOT NULL DEFAULT 0
)
""")
INDEX_SQL = """
CREATE INDEX idx_episode_podcast_id ON episode (podcast_id)
CREATE UNIQUE INDEX idx_episode_download_filename ON episode (podcast_id, download_filename)
CREATE UNIQUE INDEX idx_episode_guid ON episode (podcast_id, guid)
CREATE INDEX idx_episode_state ON episode (state)
CREATE INDEX idx_episode_is_new ON episode (is_new)
CREATE INDEX idx_episode_archive ON episode (archive)
CREATE INDEX idx_episode_published ON episode (published)
"""
for sql in INDEX_SQL.strip().split('\n'):
db.execute(sql)
# Create table for version info / metadata + insert initial data
db.execute("""CREATE TABLE version (version integer)""")
db.execute("INSERT INTO version (version) VALUES (%d)" % CURRENT_VERSION)
db.commit()
def upgrade(db, filename):
if not list(db.execute('PRAGMA table_info(version)')):
initialize_database(db)
return
version = db.execute('SELECT version FROM version').fetchone()[0]
if version == CURRENT_VERSION:
return
# We are trying an upgrade - save the current version of the DB
backup = '%s_upgraded-v%d_%d' % (filename, int(version), int(time.time()))
try:
shutil.copy(filename, backup)
except Exception, e:
raise Exception('Cannot create DB backup before upgrade: ' + e)
db.execute("DELETE FROM version")
if version == 1:
UPGRADE_V1_TO_V2 = """
ALTER TABLE podcast ADD COLUMN section TEXT NOT NULL DEFAULT ''
"""
for sql in UPGRADE_V1_TO_V2.strip().split('\n'):
db.execute(sql)
version = 2
db.execute("INSERT INTO version (version) VALUES (%d)" % version)
db.commit()
if version != CURRENT_VERSION:
raise Exception('Database schema version unknown')
def convert_gpodder2_db(old_db, new_db):
"""Convert gPodder 2.x databases to the new format
Both arguments should be SQLite3 connections to the
corresponding databases.
"""
old_db = sqlite.connect(old_db)
new_db_filename = new_db
new_db = sqlite.connect(new_db)
upgrade(new_db, new_db_filename)
# Copy data for podcasts
old_cur = old_db.cursor()
columns = [x[1] for x in old_cur.execute('PRAGMA table_info(channels)')]
for row in old_cur.execute('SELECT * FROM channels'):
row = dict(zip(columns, row))
values = (
row['id'],
row['override_title'] or row['title'],
row['url'],
row['link'],
row['description'],
row['image'],
row['username'] or None,
row['password'] or None,
row['last_modified'] or None,
row['etag'] or None,
row['channel_is_locked'],
row['foldername'],
not row['feed_update_enabled'],
'',
)
new_db.execute("""
INSERT INTO podcast VALUES (%s)
""" % ', '.join('?'*len(values)), values)
old_cur.close()
# Copy data for episodes
old_cur = old_db.cursor()
columns = [x[1] for x in old_cur.execute('PRAGMA table_info(episodes)')]
for row in old_cur.execute('SELECT * FROM episodes'):
row = dict(zip(columns, row))
values = (
row['id'],
row['channel_id'],
row['title'],
row['description'],
row['url'],
row['pubDate'],
row['guid'],
row['link'],
row['length'],
row['mimetype'],
row['state'],
not row['played'],
row['locked'],
row['filename'],
row['total_time'],
row['current_position'],
row['current_position_updated'],
0,
)
new_db.execute("""
INSERT INTO episode VALUES (%s)
""" % ', '.join('?'*len(values)), values)
old_cur.close()
old_db.close()
new_db.commit()
new_db.close()
gpodder-3.1.2/src/gpodder/model.py 0000664 0001750 0001750 00000146447 11760704165 016467 0 ustar thp thp 0000000 0000000 # -*- coding: utf-8 -*-
#
# gPodder - A media aggregator and podcast client
# Copyright (c) 2005-2012 Thomas Perl and the gPodder Team
# Copyright (c) 2011 Neal H. Walfield
#
# gPodder is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# gPodder is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see : ..." -> ": ..."
r'^%s (\d+: .*)' % re.escape(self.parent.title),
# "Episode : ..." -> ": ..."
r'Episode (\d+:.*)',
]
for pattern in regex_patterns:
if re.match(pattern, self.title):
title = re.sub(pattern, r'\1', self.title)
if len(title) > LEFTOVER_MIN:
return title
# "#001: Title" -> "001: Title"
if (not self.parent._common_prefix and re.match('^#\d+: ',
self.title) and len(self.title)-1 > LEFTOVER_MIN):
return self.title[1:]
if (self.parent._common_prefix is not None and
self.title.startswith(self.parent._common_prefix) and
len(self.title)-len(self.parent._common_prefix) > LEFTOVER_MIN):
return self.title[len(self.parent._common_prefix):]
return self.title
def _set_download_task(self, download_task):
self.children = (download_task, self.children[1])
def _get_download_task(self):
return self.children[0]
download_task = property(_get_download_task, _set_download_task)
@property
def downloading(self):
task = self.download_task
if task is None:
return False
return task.status in (task.DOWNLOADING, task.QUEUED, task.PAUSED)
def check_is_new(self):
return (self.state == gpodder.STATE_NORMAL and self.is_new and
not self.downloading)
def save(self):
gpodder.user_extensions.on_episode_save(self)
self._clear_changes()
self.db.save_episode(self)
def on_downloaded(self, filename):
self.state = gpodder.STATE_DOWNLOADED
self.is_new = True
self.file_size = os.path.getsize(filename)
self.save()
def set_state(self, state):
self.state = state
self.save()
def playback_mark(self):
self.is_new = False
self.last_playback = int(time.time())
self.save()
def mark(self, state=None, is_played=None, is_locked=None):
if state is not None:
self.state = state
if is_played is not None:
self.is_new = not is_played
# "Mark as new" must "undelete" the episode
if self.is_new and self.state == gpodder.STATE_DELETED:
self.state = gpodder.STATE_NORMAL
if is_locked is not None:
self.archive = is_locked
self.save()
def age_in_days(self):
return util.file_age_in_days(self.local_filename(create=False, \
check_only=True))
age_int_prop = property(fget=age_in_days)
def get_age_string(self):
return util.file_age_to_string(self.age_in_days())
age_prop = property(fget=get_age_string)
@property
def description_html(self):
# XXX: That's not a very well-informed heuristic to check
# if the description already contains HTML. Better ideas?
if '<' in self.description:
return self.description
return self.description.replace('\n', '
# See also: http://gpodder.org/bug/699
import gpodder
from gpodder import util
import dbus
import dbus.service
def safe_str(txt):
if txt:
return txt.encode()
else:
return ''
def safe_first_line(txt):
txt = safe_str(txt)
lines = util.remove_html_tags(txt).strip().splitlines()
if not lines or lines[0] == '':
return ''
else:
return lines[0]
class DBusPodcastsProxy(dbus.service.Object):
""" Implements API accessible through D-Bus
Methods on DBusPodcastsProxy can be called by D-Bus clients. They implement
safe-guards to work safely over D-Bus while having type signatures applied
for parameter and return values.
"""
#DBusPodcastsProxy(lambda: self.channels, self.on_itemUpdate_activate(), self.playback_episodes, self.download_episode_list, bus_name)
def __init__(self, get_podcast_list, \
check_for_updates, playback_episodes, \
download_episodes, episode_from_uri, \
bus_name):
self._get_podcasts = get_podcast_list
self._on_check_for_updates = check_for_updates
self._playback_episodes = playback_episodes
self._download_episodes = download_episodes
self._episode_from_uri = episode_from_uri
dbus.service.Object.__init__(self, \
object_path=gpodder.dbus_podcasts_object_path, \
bus_name=bus_name)
def _get_episode_refs(self, urls):
"""Get Episode instances associated with URLs"""
episodes = []
for p in self._get_podcasts():
for e in p.get_all_episodes():
if e.url in urls:
episodes.append(e)
return episodes
@dbus.service.method(dbus_interface=gpodder.dbus_podcasts, in_signature='', out_signature='a(ssss)')
def get_podcasts(self):
"""Get all podcasts in gPodder's subscription list"""
def podcast_to_tuple(podcast):
title = safe_str(podcast.title)
url = safe_str(podcast.url)
description = safe_first_line(podcast.description)
cover_file = ''
return (title, url, description, cover_file)
return [podcast_to_tuple(p) for p in self._get_podcasts()]
@dbus.service.method(dbus_interface=gpodder.dbus_podcasts, in_signature='s', out_signature='ss')
def get_episode_title(self, url):
episode = self._episode_from_uri(url)
if episode is not None:
return episode.title, episode.channel.title
return ('', '')
@dbus.service.method(dbus_interface=gpodder.dbus_podcasts, in_signature='s', out_signature='a(sssssbbb)')
def get_episodes(self, url):
"""Return all episodes of the podcast with the given URL"""
podcast = None
for channel in self._get_podcasts():
if channel.url == url:
podcast = channel
break
if podcast is None:
return []
def episode_to_tuple(episode):
title = safe_str(episode.title)
url = safe_str(episode.url)
description = safe_first_line(episode.description)
filename = safe_str(episode.download_filename)
file_type = safe_str(episode.file_type())
is_new = (episode.state == gpodder.STATE_NORMAL and episode.is_new)
is_downloaded = episode.was_downloaded(and_exists=True)
is_deleted = (episode.state == gpodder.STATE_DELETED)
return (title, url, description, filename, file_type, is_new, is_downloaded, is_deleted)
return [episode_to_tuple(e) for e in podcast.get_all_episodes()]
@dbus.service.method(dbus_interface=gpodder.dbus_podcasts, in_signature='as', out_signature='(bs)')
def play_or_download_episode(self, urls):
"""Play (or download) a list of episodes given by URL"""
episodes = self._get_episode_refs(urls)
if not episodes:
return (0, 'No episodes found')
to_playback = [e for e in episodes if e.was_downloaded(and_exists=True)]
to_download = [e for e in episodes if e not in to_playback]
if to_playback:
self._playback_episodes(to_playback)
if to_download:
self._download_episodes(to_download)
return (1, 'Success')
@dbus.service.method(dbus_interface=gpodder.dbus_podcasts, in_signature='', out_signature='')
def check_for_updates(self):
"""Check for new episodes or offer subscriptions"""
self._on_check_for_updates()
gpodder-3.1.2/src/gpodder/feedservice.py 0000664 0001750 0001750 00000005323 11751103635 017631 0 ustar thp thp 0000000 0000000 # -*- coding: utf-8 -*-
#
# gPodder - A media aggregator and podcast client
# Copyright (c) 2005-2012 Thomas Perl and the gPodder Team
#
# gPodder is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# gPodder is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see 2007-08-04
#
"""Miscellaneous helper functions for gPodder
This module provides helper and utility functions for gPodder that
are not tied to any specific part of gPodder.
"""
import gpodder
import logging
logger = logging.getLogger(__name__)
import os
import os.path
import platform
import glob
import stat
import shlex
import shutil
import socket
import sys
import string
import re
import subprocess
from htmlentitydefs import entitydefs
import time
import gzip
import datetime
import threading
import urlparse
import urllib
import urllib2
import httplib
import webbrowser
import mimetypes
import itertools
import feedparser
import StringIO
import xml.dom.minidom
_ = gpodder.gettext
N_ = gpodder.ngettext
import locale
try:
locale.setlocale(locale.LC_ALL, '')
except Exception, e:
logger.warn('Cannot set locale (%s)', e, exc_info=True)
# Native filesystem encoding detection
encoding = sys.getfilesystemencoding()
if encoding is None:
if 'LANG' in os.environ and '.' in os.environ['LANG']:
lang = os.environ['LANG']
(language, encoding) = lang.rsplit('.', 1)
logger.info('Detected encoding: %s', encoding)
elif gpodder.ui.fremantle or gpodder.ui.harmattan:
encoding = 'utf-8'
elif gpodder.win32:
# To quote http://docs.python.org/howto/unicode.html:
# ,,on Windows, Python uses the name "mbcs" to refer
# to whatever the currently configured encoding is``
encoding = 'mbcs'
else:
encoding = 'iso-8859-15'
logger.info('Assuming encoding: ISO-8859-15 ($LANG not set).')
# Filename / folder name sanitization
def _sanitize_char(c):
if c in string.whitespace:
return ' '
elif c in ',-.()':
return c
elif c in string.punctuation or ord(c) <= 31:
return '_'
return c
SANITIZATION_TABLE = ''.join(map(_sanitize_char, map(chr, range(256))))
del _sanitize_char
_MIME_TYPE_LIST = [
('.aac', 'audio/aac'),
('.axa', 'audio/annodex'),
('.flac', 'audio/flac'),
('.m4b', 'audio/m4b'),
('.m4a', 'audio/mp4'),
('.mp3', 'audio/mpeg'),
('.spx', 'audio/ogg'),
('.oga', 'audio/ogg'),
('.ogg', 'audio/ogg'),
('.wma', 'audio/x-ms-wma'),
('.3gp', 'video/3gpp'),
('.axv', 'video/annodex'),
('.divx', 'video/divx'),
('.m4v', 'video/m4v'),
('.mp4', 'video/mp4'),
('.ogv', 'video/ogg'),
('.mov', 'video/quicktime'),
('.flv', 'video/x-flv'),
('.mkv', 'video/x-matroska'),
('.wmv', 'video/x-ms-wmv'),
]
_MIME_TYPES = dict((k, v) for v, k in _MIME_TYPE_LIST)
_MIME_TYPES_EXT = dict(_MIME_TYPE_LIST)
def make_directory( path):
"""
Tries to create a directory if it does not exist already.
Returns True if the directory exists after the function
call, False otherwise.
"""
if os.path.isdir( path):
return True
try:
os.makedirs( path)
except:
logger.warn('Could not create directory: %s', path)
return False
return True
def normalize_feed_url(url):
"""
Converts any URL to http:// or ftp:// so that it can be
used with "wget". If the URL cannot be converted (invalid
or unknown scheme), "None" is returned.
This will also normalize feed:// and itpc:// to http://.
>>> normalize_feed_url('itpc://example.org/podcast.rss')
'http://example.org/podcast.rss'
If no URL scheme is defined (e.g. "curry.com"), we will
simply assume the user intends to add a http:// feed.
>>> normalize_feed_url('curry.com')
'http://curry.com/'
There are even some more shortcuts for advanced users
and lazy typists (see the source for details).
>>> normalize_feed_url('fb:43FPodcast')
'http://feeds.feedburner.com/43FPodcast'
It will also take care of converting the domain name to
all-lowercase (because domains are not case sensitive):
>>> normalize_feed_url('http://Example.COM/')
'http://example.com/'
Some other minimalistic changes are also taken care of,
e.g. a ? with an empty query is removed:
>>> normalize_feed_url('http://example.org/test?')
'http://example.org/test'
"""
if not url or len(url) < 8:
return None
# This is a list of prefixes that you can use to minimize the amount of
# keystrokes that you have to use.
# Feel free to suggest other useful prefixes, and I'll add them here.
PREFIXES = {
'fb:': 'http://feeds.feedburner.com/%s',
'yt:': 'http://www.youtube.com/rss/user/%s/videos.rss',
'sc:': 'http://soundcloud.com/%s',
'fm4od:': 'http://onapp1.orf.at/webcam/fm4/fod/%s.xspf',
# YouTube playlists. To get a list of playlists per-user, use:
# https://gdata.youtube.com/feeds/api/users//playlists
'ytpl:': 'http://gdata.youtube.com/feeds/api/playlists/%s',
}
for prefix, expansion in PREFIXES.iteritems():
if url.startswith(prefix):
url = expansion % (url[len(prefix):],)
break
# Assume HTTP for URLs without scheme
if not '://' in url:
url = 'http://' + url
scheme, netloc, path, query, fragment = urlparse.urlsplit(url)
# Schemes and domain names are case insensitive
scheme, netloc = scheme.lower(), netloc.lower()
# Normalize empty paths to "/"
if path == '':
path = '/'
# feed://, itpc:// and itms:// are really http://
if scheme in ('feed', 'itpc', 'itms'):
scheme = 'http'
if scheme not in ('http', 'https', 'ftp', 'file'):
return None
# urlunsplit might return "a slighty different, but equivalent URL"
return urlparse.urlunsplit((scheme, netloc, path, query, fragment))
def username_password_from_url(url):
r"""
Returns a tuple (username,password) containing authentication
data from the specified URL or (None,None) if no authentication
data can be found in the URL.
See Section 3.1 of RFC 1738 (http://www.ietf.org/rfc/rfc1738.txt)
>>> username_password_from_url('https://@host.com/')
('', None)
>>> username_password_from_url('telnet://host.com/')
(None, None)
>>> username_password_from_url('ftp://foo:@host.com/')
('foo', '')
>>> username_password_from_url('http://a:b@host.com/')
('a', 'b')
>>> username_password_from_url(1)
Traceback (most recent call last):
...
ValueError: URL has to be a string or unicode object.
>>> username_password_from_url(None)
Traceback (most recent call last):
...
ValueError: URL has to be a string or unicode object.
>>> username_password_from_url('http://a@b:c@host.com/')
('a@b', 'c')
>>> username_password_from_url('ftp://a:b:c@host.com/')
('a', 'b:c')
>>> username_password_from_url('http://i%2Fo:P%40ss%3A@host.com/')
('i/o', 'P@ss:')
>>> username_password_from_url('ftp://%C3%B6sterreich@host.com/')
('\xc3\xb6sterreich', None)
>>> username_password_from_url('http://w%20x:y%20z@example.org/')
('w x', 'y z')
>>> username_password_from_url('http://example.com/x@y:z@test.com/')
(None, None)
"""
if type(url) not in (str, unicode):
raise ValueError('URL has to be a string or unicode object.')
(username, password) = (None, None)
(scheme, netloc, path, params, query, fragment) = urlparse.urlparse(url)
if '@' in netloc:
(authentication, netloc) = netloc.rsplit('@', 1)
if ':' in authentication:
(username, password) = authentication.split(':', 1)
# RFC1738 dictates that we should not allow ['/', '@', ':']
# characters in the username and password field (Section 3.1):
#
# 1. The "/" can't be in there at this point because of the way
# urlparse (which we use above) works.
# 2. Due to gPodder bug 1521, we allow "@" in the username and
# password field. We use netloc.rsplit('@', 1), which will
# make sure that we split it at the last '@' in netloc.
# 3. The colon must be excluded (RFC2617, Section 2) in the
# username, but is apparently allowed in the password. This
# is handled by the authentication.split(':', 1) above, and
# will cause any extraneous ':'s to be part of the password.
username = urllib.unquote(username)
password = urllib.unquote(password)
else:
username = urllib.unquote(authentication)
return (username, password)
def calculate_size( path):
"""
Tries to calculate the size of a directory, including any
subdirectories found. The returned value might not be
correct if the user doesn't have appropriate permissions
to list all subdirectories of the given path.
"""
if path is None:
return 0L
if os.path.dirname( path) == '/':
return 0L
if os.path.isfile( path):
return os.path.getsize( path)
if os.path.isdir( path) and not os.path.islink( path):
sum = os.path.getsize( path)
try:
for item in os.listdir(path):
try:
sum += calculate_size(os.path.join(path, item))
except:
logger.warn('Cannot get size for %s', path, exc_info=True)
except:
logger.warn('Cannot access %s', path, exc_info=True)
return sum
return 0L
def file_modification_datetime(filename):
"""
Returns the modification date of the specified file
as a datetime.datetime object or None if the modification
date cannot be determined.
"""
if filename is None:
return None
if not os.access(filename, os.R_OK):
return None
try:
s = os.stat(filename)
timestamp = s[stat.ST_MTIME]
return datetime.datetime.fromtimestamp(timestamp)
except:
logger.warn('Cannot get mtime for %s', filename, exc_info=True)
return None
def file_age_in_days(filename):
"""
Returns the age of the specified filename in days or
zero if the modification date cannot be determined.
"""
dt = file_modification_datetime(filename)
if dt is None:
return 0
else:
return (datetime.datetime.now()-dt).days
def file_age_to_string(days):
"""
Converts a "number of days" value to a string that
can be used in the UI to display the file age.
>>> file_age_to_string(0)
''
>>> file_age_to_string(1)
u'1 day ago'
>>> file_age_to_string(2)
u'2 days ago'
"""
if days < 1:
return ''
else:
return N_('%(count)d day ago', '%(count)d days ago', days) % {'count':days}
def get_free_disk_space_win32(path):
"""
Win32-specific code to determine the free disk space remaining
for a given path. Uses code from:
http://mail.python.org/pipermail/python-list/2003-May/203223.html
"""
drive, tail = os.path.splitdrive(path)
try:
import win32file
userFree, userTotal, freeOnDisk = win32file.GetDiskFreeSpaceEx(drive)
return userFree
except ImportError:
logger.warn('Running on Win32 but win32api/win32file not installed.')
# Cannot determine free disk space
return 0
def get_free_disk_space(path):
"""
Calculates the free disk space available to the current user
on the file system that contains the given path.
If the path (or its parent folder) does not yet exist, this
function returns zero.
"""
if not os.path.exists(path):
return 0
if gpodder.win32:
return get_free_disk_space_win32(path)
s = os.statvfs(path)
return s.f_bavail * s.f_bsize
def format_date(timestamp):
"""
Converts a UNIX timestamp to a date representation. This
function returns "Today", "Yesterday", a weekday name or
the date in %x format, which (according to the Python docs)
is the "Locale's appropriate date representation".
Returns None if there has been an error converting the
timestamp to a string representation.
"""
if timestamp is None:
return None
seconds_in_a_day = 60*60*24
today = time.localtime()[:3]
yesterday = time.localtime(time.time() - seconds_in_a_day)[:3]
try:
timestamp_date = time.localtime(timestamp)[:3]
except ValueError, ve:
logger.warn('Cannot convert timestamp', exc_info=True)
return None
if timestamp_date == today:
return _('Today')
elif timestamp_date == yesterday:
return _('Yesterday')
try:
diff = int( (time.time() - timestamp)/seconds_in_a_day )
except:
logger.warn('Cannot convert "%s" to date.', timestamp, exc_info=True)
return None
try:
timestamp = datetime.datetime.fromtimestamp(timestamp)
except:
return None
if diff < 7:
# Weekday name
return str(timestamp.strftime('%A').decode(encoding))
else:
# Locale's appropriate date representation
return str(timestamp.strftime('%x'))
def format_filesize(bytesize, use_si_units=False, digits=2):
"""
Formats the given size in bytes to be human-readable,
Returns a localized "(unknown)" string when the bytesize
has a negative value.
"""
si_units = (
( 'kB', 10**3 ),
( 'MB', 10**6 ),
( 'GB', 10**9 ),
)
binary_units = (
( 'KiB', 2**10 ),
( 'MiB', 2**20 ),
( 'GiB', 2**30 ),
)
try:
bytesize = float( bytesize)
except:
return _('(unknown)')
if bytesize < 0:
return _('(unknown)')
if use_si_units:
units = si_units
else:
units = binary_units
( used_unit, used_value ) = ( 'B', bytesize )
for ( unit, value ) in units:
if bytesize >= value:
used_value = bytesize / float(value)
used_unit = unit
return ('%.'+str(digits)+'f %s') % (used_value, used_unit)
def delete_file(filename):
"""Delete a file from the filesystem
Errors (permissions errors or file not found)
are silently ignored.
"""
try:
os.remove(filename)
except:
pass
def remove_html_tags(html):
"""
Remove HTML tags from a string and replace numeric and
named entities with the corresponding character, so the
HTML text can be displayed in a simple text view.
"""
if html is None:
return None
# If we would want more speed, we could make these global
re_strip_tags = re.compile('<[^>]*>')
re_unicode_entities = re.compile('&#(\d{2,4});')
re_html_entities = re.compile('&(.{2,8});')
re_newline_tags = re.compile('(]*>|<[/]?ul[^>]*>|)', re.I)
re_listing_tags = re.compile(']*>', re.I)
result = html
# Convert common HTML elements to their text equivalent
result = re_newline_tags.sub('\n', result)
result = re_listing_tags.sub('\n * ', result)
result = re.sub('<[Pp]>', '\n\n', result)
# Remove all HTML/XML tags from the string
result = re_strip_tags.sub('', result)
# Convert numeric XML entities to their unicode character
result = re_unicode_entities.sub(lambda x: unichr(int(x.group(1))), result)
# Convert named HTML entities to their unicode character
result = re_html_entities.sub(lambda x: unicode(entitydefs.get(x.group(1),''), 'iso-8859-1'), result)
# Convert more than two newlines to two newlines
result = re.sub('([\r\n]{2})([\r\n])+', '\\1', result)
return result.strip()
def wrong_extension(extension):
"""
Determine if a given extension looks like it's
wrong (e.g. empty, extremely long or spaces)
Returns True if the extension most likely is a
wrong one and should be replaced.
>>> wrong_extension('.mp3')
False
>>> wrong_extension('.divx')
False
>>> wrong_extension('mp3')
True
>>> wrong_extension('')
True
>>> wrong_extension('.12 - Everybody')
True
>>> wrong_extension('.mp3 ')
True
>>> wrong_extension('.')
True
>>> wrong_extension('.42')
True
"""
if not extension:
return True
elif len(extension) > 5:
return True
elif ' ' in extension:
return True
elif extension == '.':
return True
elif not extension.startswith('.'):
return True
else:
try:
# "." is an invalid extension
float(extension)
return True
except:
pass
return False
def extension_from_mimetype(mimetype):
"""
Simply guesses what the file extension should be from the mimetype
>>> extension_from_mimetype('audio/mp4')
'.m4a'
>>> extension_from_mimetype('audio/ogg')
'.ogg'
>>> extension_from_mimetype('audio/mpeg')
'.mp3'
>>> extension_from_mimetype('video/x-matroska')
'.mkv'
>>> extension_from_mimetype('wrong-mimetype')
''
"""
if mimetype in _MIME_TYPES:
return _MIME_TYPES[mimetype]
return mimetypes.guess_extension(mimetype) or ''
def mimetype_from_extension(extension):
"""
Simply guesses what the mimetype should be from the file extension
>>> mimetype_from_extension('.m4a')
'audio/mp4'
>>> mimetype_from_extension('.ogg')
'audio/ogg'
>>> mimetype_from_extension('.mp3')
'audio/mpeg'
>>> mimetype_from_extension('.mkv')
'video/x-matroska'
>>> mimetype_from_extension('.abc')
''
"""
if extension in _MIME_TYPES_EXT:
return _MIME_TYPES_EXT[extension]
# Need to prepend something to the extension, so guess_type works
type, encoding = mimetypes.guess_type('file'+extension)
return type or ''
def extension_correct_for_mimetype(extension, mimetype):
"""
Check if the given filename extension (e.g. ".ogg") is a possible
extension for a given mimetype (e.g. "application/ogg") and return
a boolean value (True if it's possible, False if not). Also do
>>> extension_correct_for_mimetype('.ogg', 'application/ogg')
True
>>> extension_correct_for_mimetype('.ogv', 'video/ogg')
True
>>> extension_correct_for_mimetype('.ogg', 'audio/mpeg')
False
>>> extension_correct_for_mimetype('.m4a', 'audio/mp4')
True
>>> extension_correct_for_mimetype('mp3', 'audio/mpeg')
Traceback (most recent call last):
...
ValueError: "mp3" is not an extension (missing .)
>>> extension_correct_for_mimetype('.mp3', 'audio mpeg')
Traceback (most recent call last):
...
ValueError: "audio mpeg" is not a mimetype (missing /)
"""
if not '/' in mimetype:
raise ValueError('"%s" is not a mimetype (missing /)' % mimetype)
if not extension.startswith('.'):
raise ValueError('"%s" is not an extension (missing .)' % extension)
if (extension, mimetype) in _MIME_TYPE_LIST:
return True
# Create a "default" extension from the mimetype, e.g. "application/ogg"
# becomes ".ogg", "audio/mpeg" becomes ".mpeg", etc...
default = ['.'+mimetype.split('/')[-1]]
return extension in default+mimetypes.guess_all_extensions(mimetype)
def filename_from_url(url):
"""
Extracts the filename and (lowercase) extension (with dot)
from a URL, e.g. http://server.com/file.MP3?download=yes
will result in the string ("file", ".mp3") being returned.
This function will also try to best-guess the "real"
extension for a media file (audio, video) by
trying to match an extension to these types and recurse
into the query string to find better matches, if the
original extension does not resolve to a known type.
http://my.net/redirect.php?my.net/file.ogg => ("file", ".ogg")
http://server/get.jsp?file=/episode0815.MOV => ("episode0815", ".mov")
http://s/redirect.mp4?http://serv2/test.mp4 => ("test", ".mp4")
"""
(scheme, netloc, path, para, query, fragid) = urlparse.urlparse(url)
(filename, extension) = os.path.splitext(os.path.basename( urllib.unquote(path)))
if file_type_by_extension(extension) is not None and not \
query.startswith(scheme+'://'):
# We have found a valid extension (audio, video)
# and the query string doesn't look like a URL
return ( filename, extension.lower() )
# If the query string looks like a possible URL, try that first
if len(query.strip()) > 0 and query.find('/') != -1:
query_url = '://'.join((scheme, urllib.unquote(query)))
(query_filename, query_extension) = filename_from_url(query_url)
if file_type_by_extension(query_extension) is not None:
return os.path.splitext(os.path.basename(query_url))
# No exact match found, simply return the original filename & extension
return ( filename, extension.lower() )
def file_type_by_extension(extension):
"""
Tries to guess the file type by looking up the filename
extension from a table of known file types. Will return
"audio", "video" or None.
>>> file_type_by_extension('.aif')
'audio'
>>> file_type_by_extension('.3GP')
'video'
>>> file_type_by_extension('.m4a')
'audio'
>>> file_type_by_extension('.txt') is None
True
>>> file_type_by_extension(None) is None
True
>>> file_type_by_extension('ogg')
Traceback (most recent call last):
...
ValueError: Extension does not start with a dot: ogg
"""
if not extension:
return None
if not extension.startswith('.'):
raise ValueError('Extension does not start with a dot: %s' % extension)
extension = extension.lower()
if extension in _MIME_TYPES_EXT:
return _MIME_TYPES_EXT[extension].split('/')[0]
# Need to prepend something to the extension, so guess_type works
type, encoding = mimetypes.guess_type('file'+extension)
if type is not None and '/' in type:
filetype, rest = type.split('/', 1)
if filetype in ('audio', 'video', 'image'):
return filetype
return None
def get_first_line( s):
"""
Returns only the first line of a string, stripped so
that it doesn't have whitespace before or after.
"""
return s.strip().split('\n')[0].strip()
def object_string_formatter( s, **kwargs):
"""
Makes attributes of object passed in as keyword
arguments available as {OBJECTNAME.ATTRNAME} in
the passed-in string and returns a string with
the above arguments replaced with the attribute
values of the corresponding object.
Example:
e = Episode()
e.title = 'Hello'
s = '{episode.title} World'
print object_string_formatter( s, episode = e)
=> 'Hello World'
"""
result = s
for ( key, o ) in kwargs.items():
matches = re.findall( r'\{%s\.([^\}]+)\}' % key, s)
for attr in matches:
if hasattr( o, attr):
try:
from_s = '{%s.%s}' % ( key, attr )
to_s = getattr( o, attr)
result = result.replace( from_s, to_s)
except:
logger.warn('Could not replace attribute "%s" in string "%s".', attr, s)
return result
def format_desktop_command(command, filenames, start_position=None):
"""
Formats a command template from the "Exec=" line of a .desktop
file to a string that can be invoked in a shell.
Handled format strings: %U, %u, %F, %f and a fallback that
appends the filename as first parameter of the command.
Also handles non-standard %p which is replaced with the start_position
(probably only makes sense if starting a single file). (see bug 1140)
See http://standards.freedesktop.org/desktop-entry-spec/1.0/ar01s06.html
Returns a list of commands to execute, either one for
each filename if the application does not support multiple
file names or one for all filenames (%U, %F or unknown).
"""
# Replace backslashes with slashes to fix win32 issues
# (even on win32, "/" works, but "\" does not)
command = command.replace('\\', '/')
if start_position is not None:
command = command.replace('%p', str(start_position))
command = shlex.split(command)
command_before = command
command_after = []
multiple_arguments = True
for fieldcode in ('%U', '%F', '%u', '%f'):
if fieldcode in command:
command_before = command[:command.index(fieldcode)]
command_after = command[command.index(fieldcode)+1:]
multiple_arguments = fieldcode in ('%U', '%F')
break
if multiple_arguments:
return [command_before + filenames + command_after]
commands = []
for filename in filenames:
commands.append(command_before+[filename]+command_after)
return commands
def url_strip_authentication(url):
"""
Strips authentication data from an URL. Returns the URL with
the authentication data removed from it.
>>> url_strip_authentication('https://host.com/')
'https://host.com/'
>>> url_strip_authentication('telnet://foo:bar@host.com/')
'telnet://host.com/'
>>> url_strip_authentication('ftp://billy@example.org')
'ftp://example.org'
>>> url_strip_authentication('ftp://billy:@example.org')
'ftp://example.org'
>>> url_strip_authentication('http://aa:bc@localhost/x')
'http://localhost/x'
>>> url_strip_authentication('http://i%2Fo:P%40ss%3A@blubb.lan/u.html')
'http://blubb.lan/u.html'
>>> url_strip_authentication('http://c:d@x.org/')
'http://x.org/'
>>> url_strip_authentication('http://P%40%3A:i%2F@cx.lan')
'http://cx.lan'
>>> url_strip_authentication('http://x@x.com:s3cret@example.com/')
'http://example.com/'
"""
url_parts = list(urlparse.urlsplit(url))
# url_parts[1] is the HOST part of the URL
# Remove existing authentication data
if '@' in url_parts[1]:
url_parts[1] = url_parts[1].rsplit('@', 1)[1]
return urlparse.urlunsplit(url_parts)
def url_add_authentication(url, username, password):
"""
Adds authentication data (username, password) to a given
URL in order to construct an authenticated URL.
>>> url_add_authentication('https://host.com/', '', None)
'https://host.com/'
>>> url_add_authentication('http://example.org/', None, None)
'http://example.org/'
>>> url_add_authentication('telnet://host.com/', 'foo', 'bar')
'telnet://foo:bar@host.com/'
>>> url_add_authentication('ftp://example.org', 'billy', None)
'ftp://billy@example.org'
>>> url_add_authentication('ftp://example.org', 'billy', '')
'ftp://billy:@example.org'
>>> url_add_authentication('http://localhost/x', 'aa', 'bc')
'http://aa:bc@localhost/x'
>>> url_add_authentication('http://blubb.lan/u.html', 'i/o', 'P@ss:')
'http://i%2Fo:P@ss:@blubb.lan/u.html'
>>> url_add_authentication('http://a:b@x.org/', 'c', 'd')
'http://c:d@x.org/'
>>> url_add_authentication('http://i%2F:P%40%3A@cx.lan', 'P@x', 'i/')
'http://P@x:i%2F@cx.lan'
>>> url_add_authentication('http://x.org/', 'a b', 'c d')
'http://a%20b:c%20d@x.org/'
"""
if username is None or username == '':
return url
# Relaxations of the strict quoting rules (bug 1521):
# 1. Accept '@' in username and password
# 2. Acecpt ':' in password only
username = urllib.quote(username, safe='@')
if password is not None:
password = urllib.quote(password, safe='@:')
auth_string = ':'.join((username, password))
else:
auth_string = username
url = url_strip_authentication(url)
url_parts = list(urlparse.urlsplit(url))
# url_parts[1] is the HOST part of the URL
url_parts[1] = '@'.join((auth_string, url_parts[1]))
return urlparse.urlunsplit(url_parts)
def urlopen(url):
"""
An URL opener with the User-agent set to gPodder (with version)
"""
username, password = username_password_from_url(url)
if username is not None or password is not None:
url = url_strip_authentication(url)
password_mgr = urllib2.HTTPPasswordMgrWithDefaultRealm()
password_mgr.add_password(None, url, username, password)
handler = urllib2.HTTPBasicAuthHandler(password_mgr)
opener = urllib2.build_opener(handler)
else:
opener = urllib2.build_opener()
headers = {'User-agent': gpodder.user_agent}
request = urllib2.Request(url, headers=headers)
return opener.open(request)
def get_real_url(url):
"""
Gets the real URL of a file and resolves all redirects.
"""
try:
return urlopen(url).geturl()
except:
logger.error('Getting real url for %s', url, exc_info=True)
return url
def find_command(command):
"""
Searches the system's PATH for a specific command that is
executable by the user. Returns the first occurence of an
executable binary in the PATH, or None if the command is
not available.
On Windows, this also looks for ".bat" and
".exe" files if "" itself doesn't exist.
"""
if 'PATH' not in os.environ:
return None
for path in os.environ['PATH'].split(os.pathsep):
command_file = os.path.join(path, command)
if gpodder.win32 and not os.path.exists(command_file):
for extension in ('.bat', '.exe'):
cmd = command_file + extension
if os.path.isfile(cmd):
command_file = cmd
break
if os.path.isfile(command_file) and os.access(command_file, os.X_OK):
return command_file
return None
idle_add_handler = None
def idle_add(func, *args):
"""Run a function in the main GUI thread
This is a wrapper function that does the Right Thing depending on if we are
running on Gtk+, Qt or CLI.
You should use this function if you are calling from a Python thread and
modify UI data, so that you make sure that the function is called as soon
as possible from the main UI thread.
"""
if gpodder.ui.gtk:
import gobject
gobject.idle_add(func, *args)
elif gpodder.ui.qml:
from PySide.QtCore import Signal, QTimer, QThread, Qt, QObject
class IdleAddHandler(QObject):
signal = Signal(object)
def __init__(self):
QObject.__init__(self)
self.main_thread_id = QThread.currentThreadId()
self.signal.connect(self.run_func)
def run_func(self, func):
assert QThread.currentThreadId() == self.main_thread_id, \
("Running in %s, not %s"
% (str(QThread.currentThreadId()),
str(self.main_thread_id)))
func()
def idle_add(self, func, *args):
def doit():
try:
func(*args)
except Exception, e:
logger.exception("Running %s%s: %s",
func, str(tuple(args)), str(e))
if QThread.currentThreadId() == self.main_thread_id:
# If we emit the signal in the main thread,
# then the function will be run immediately.
# Instead, use a single shot timer with a 0
# timeout: this will run the function when the
# event loop next iterates.
QTimer.singleShot(0, doit)
else:
self.signal.emit(doit)
global idle_add_handler
if idle_add_handler is None:
idle_add_handler = IdleAddHandler()
idle_add_handler.idle_add(func, *args)
else:
func(*args)
def bluetooth_available():
"""
Returns True or False depending on the availability
of bluetooth functionality on the system.
"""
if find_command('bluetooth-sendto') or \
find_command('gnome-obex-send'):
return True
else:
return False
def bluetooth_send_file(filename):
"""
Sends a file via bluetooth.
This function tries to use "bluetooth-sendto", and if
it is not available, it also tries "gnome-obex-send".
"""
command_line = None
if find_command('bluetooth-sendto'):
command_line = ['bluetooth-sendto']
elif find_command('gnome-obex-send'):
command_line = ['gnome-obex-send']
if command_line is not None:
command_line.append(filename)
return (subprocess.Popen(command_line).wait() == 0)
else:
logger.error('Cannot send file. Please install "bluetooth-sendto" or "gnome-obex-send".')
return False
def format_time(value):
"""Format a seconds value to a string
>>> format_time(0)
'00:00'
>>> format_time(20)
'00:20'
>>> format_time(3600)
'01:00:00'
>>> format_time(10921)
'03:02:01'
"""
dt = datetime.datetime.utcfromtimestamp(value)
if dt.hour == 0:
return dt.strftime('%M:%S')
else:
return dt.strftime('%H:%M:%S')
def parse_time(value):
"""Parse a time string into seconds
>>> parse_time('00:00')
0
>>> parse_time('00:00:00')
0
>>> parse_time('00:20')
20
>>> parse_time('00:00:20')
20
>>> parse_time('01:00:00')
3600
>>> parse_time('03:02:01')
10921
"""
if not value:
raise ValueError('Invalid value: %s' % (str(value),))
for format in ('%H:%M:%S', '%M:%S'):
try:
t = time.strptime(value, format)
return (t.tm_hour * 60 + t.tm_min) * 60 + t.tm_sec
except ValueError, ve:
continue
return int(value)
def format_seconds_to_hour_min_sec(seconds):
"""
Take the number of seconds and format it into a
human-readable string (duration).
>>> format_seconds_to_hour_min_sec(3834)
u'1 hour, 3 minutes and 54 seconds'
>>> format_seconds_to_hour_min_sec(3600)
u'1 hour'
>>> format_seconds_to_hour_min_sec(62)
u'1 minute and 2 seconds'
"""
if seconds < 1:
return N_('%(count)d second', '%(count)d seconds', seconds) % {'count':seconds}
result = []
seconds = int(seconds)
hours = seconds/3600
seconds = seconds%3600
minutes = seconds/60
seconds = seconds%60
if hours:
result.append(N_('%(count)d hour', '%(count)d hours', hours) % {'count':hours})
if minutes:
result.append(N_('%(count)d minute', '%(count)d minutes', minutes) % {'count':minutes})
if seconds:
result.append(N_('%(count)d second', '%(count)d seconds', seconds) % {'count':seconds})
if len(result) > 1:
return (' '+_('and')+' ').join((', '.join(result[:-1]), result[-1]))
else:
return result[0]
def http_request(url, method='HEAD'):
(scheme, netloc, path, parms, qry, fragid) = urlparse.urlparse(url)
conn = httplib.HTTPConnection(netloc)
start = len(scheme) + len('://') + len(netloc)
conn.request(method, url[start:])
return conn.getresponse()
def gui_open(filename):
"""
Open a file or folder with the default application set
by the Desktop environment. This uses "xdg-open" on all
systems with a few exceptions:
on Win32, os.startfile() is used
on Maemo, osso is used to communicate with Nokia Media Player
"""
try:
if gpodder.win32:
os.startfile(filename)
elif gpodder.osx:
subprocess.Popen(['open', filename])
else:
subprocess.Popen(['xdg-open', filename])
return True
except:
logger.error('Cannot open file/folder: "%s"', filename, exc_info=True)
return False
def open_website(url):
"""
Opens the specified URL using the default system web
browser. This uses Python's "webbrowser" module, so
make sure your system is set up correctly.
"""
if gpodder.ui.fremantle:
import osso
context = osso.Context('gPodder', gpodder.__version__, False)
rpc = osso.Rpc(context)
rpc.rpc_run_with_defaults('osso_browser', \
'open_new_window', \
(url,))
else:
threading.Thread(target=webbrowser.open, args=(url,)).start()
def convert_bytes(d):
"""
Convert byte strings to unicode strings
This function will decode byte strings into unicode
strings. Any other data types will be left alone.
>>> convert_bytes(None)
>>> convert_bytes(1)
1
>>> convert_bytes(4711L)
4711L
>>> convert_bytes(True)
True
>>> convert_bytes(3.1415)
3.1415
>>> convert_bytes('Hello')
u'Hello'
>>> convert_bytes(u'Hey')
u'Hey'
"""
if d is None:
return d
if any(isinstance(d, t) for t in (int, long, bool, float)):
return d
elif not isinstance(d, unicode):
return d.decode('utf-8', 'ignore')
return d
def sanitize_encoding(filename):
r"""
Generate a sanitized version of a string (i.e.
remove invalid characters and encode in the
detected native language encoding).
>>> sanitize_encoding('\x80')
''
>>> sanitize_encoding(u'unicode')
'unicode'
"""
# The encoding problem goes away in Python 3.. hopefully!
if sys.version_info >= (3, 0):
return filename
global encoding
if not isinstance(filename, unicode):
filename = filename.decode(encoding, 'ignore')
return filename.encode(encoding, 'ignore')
def sanitize_filename(filename, max_length=0, use_ascii=False):
"""
Generate a sanitized version of a filename that can
be written on disk (i.e. remove/replace invalid
characters and encode in the native language) and
trim filename if greater than max_length (0 = no limit).
If use_ascii is True, don't encode in the native language,
but use only characters from the ASCII character set.
"""
if not isinstance(filename, unicode):
filename = filename.decode(encoding, 'ignore')
if max_length > 0 and len(filename) > max_length:
logger.info('Limiting file/folder name "%s" to %d characters.',
filename, max_length)
filename = filename[:max_length]
filename = filename.encode('ascii' if use_ascii else encoding, 'ignore')
filename = filename.translate(SANITIZATION_TABLE)
filename = filename.strip('.' + string.whitespace)
return filename
def find_mount_point(directory):
"""
Try to find the mount point for a given directory.
If the directory is itself a mount point, return
it. If not, remove the last part of the path and
re-check if it's a mount point. If the directory
resides on your root filesystem, "/" is returned.
>>> find_mount_point('/')
'/'
>>> find_mount_point(u'/something')
Traceback (most recent call last):
...
ValueError: Convert unicode objects to str first.
>>> find_mount_point(None)
Traceback (most recent call last):
...
ValueError: Directory names should be of type str.
>>> find_mount_point(42)
Traceback (most recent call last):
...
ValueError: Directory names should be of type str.
>>> from minimock import mock, restore
>>> mocked_mntpoints = ('/', '/home', '/media/usbdisk', '/media/cdrom')
>>> mock('os.path.ismount', returns_func=lambda x: x in mocked_mntpoints)
>>>
>>> # For mocking os.getcwd(), we simply use a lambda to avoid the
>>> # massive output of "Called os.getcwd()" lines in this doctest
>>> os.getcwd = lambda: '/home/thp'
>>>
>>> find_mount_point('.')
Called os.path.ismount('/home/thp')
Called os.path.ismount('/home')
'/home'
>>> find_mount_point('relativity')
Called os.path.ismount('/home/thp/relativity')
Called os.path.ismount('/home/thp')
Called os.path.ismount('/home')
'/home'
>>> find_mount_point('/media/usbdisk/')
Called os.path.ismount('/media/usbdisk')
'/media/usbdisk'
>>> find_mount_point('/home/thp/Desktop')
Called os.path.ismount('/home/thp/Desktop')
Called os.path.ismount('/home/thp')
Called os.path.ismount('/home')
'/home'
>>> find_mount_point('/media/usbdisk/Podcasts/With Spaces')
Called os.path.ismount('/media/usbdisk/Podcasts/With Spaces')
Called os.path.ismount('/media/usbdisk/Podcasts')
Called os.path.ismount('/media/usbdisk')
'/media/usbdisk'
>>> find_mount_point('/home/')
Called os.path.ismount('/home')
'/home'
>>> find_mount_point('/media/cdrom/../usbdisk/blubb//')
Called os.path.ismount('/media/usbdisk/blubb')
Called os.path.ismount('/media/usbdisk')
'/media/usbdisk'
>>> restore()
"""
if isinstance(directory, unicode):
# XXX: This is only valid for Python 2 - misleading error in Python 3?
# We do not accept unicode strings, because they could fail when
# trying to be converted to some native encoding, so fail loudly
# and leave it up to the callee to encode into the proper encoding.
raise ValueError('Convert unicode objects to str first.')
if not isinstance(directory, str):
# In Python 2, we assume it's a byte str; in Python 3, we assume
# that it's a unicode str. The abspath/ismount/split functions of
# os.path work with unicode str in Python 3, but not in Python 2.
raise ValueError('Directory names should be of type str.')
directory = os.path.abspath(directory)
while directory != '/':
if os.path.ismount(directory):
return directory
else:
(directory, tail_data) = os.path.split(directory)
return '/'
# matches http:// and ftp:// and mailto://
protocolPattern = re.compile(r'^\w+://')
def isabs(string):
"""
@return true if string is an absolute path or protocoladdress
for addresses beginning in http:// or ftp:// or ldap:// -
they are considered "absolute" paths.
Source: http://code.activestate.com/recipes/208993/
"""
if protocolPattern.match(string): return 1
return os.path.isabs(string)
def commonpath(l1, l2, common=[]):
"""
helper functions for relpath
Source: http://code.activestate.com/recipes/208993/
"""
if len(l1) < 1: return (common, l1, l2)
if len(l2) < 1: return (common, l1, l2)
if l1[0] != l2[0]: return (common, l1, l2)
return commonpath(l1[1:], l2[1:], common+[l1[0]])
def relpath(p1, p2):
"""
Finds relative path from p1 to p2
Source: http://code.activestate.com/recipes/208993/
"""
pathsplit = lambda s: s.split(os.path.sep)
(common,l1,l2) = commonpath(pathsplit(p1), pathsplit(p2))
p = []
if len(l1) > 0:
p = [ ('..'+os.sep) * len(l1) ]
p = p + l2
if len(p) is 0:
return "."
return os.path.join(*p)
def get_hostname():
"""Return the hostname of this computer
This can be implemented in a different way on each
platform and should yield a unique-per-user device ID.
"""
nodename = platform.node()
if nodename:
return nodename
# Fallback - but can this give us "localhost"?
return socket.gethostname()
def detect_device_type():
"""Device type detection for gpodder.net
This function tries to detect on which
kind of device gPodder is running on.
Possible return values:
desktop, laptop, mobile, server, other
"""
if gpodder.ui.fremantle or gpodder.ui.harmattan:
return 'mobile'
elif glob.glob('/proc/acpi/battery/*'):
# Linux: If we have a battery, assume Laptop
return 'laptop'
return 'desktop'
def write_m3u_playlist(m3u_filename, episodes, extm3u=True):
"""Create an M3U playlist from a episode list
If the parameter "extm3u" is False, the list of
episodes should be a list of filenames, and no
extended information will be written into the
M3U files (#EXTM3U / #EXTINF).
If the parameter "extm3u" is True (default), then the
list of episodes should be PodcastEpisode objects,
as the extended metadata will be taken from them.
"""
f = open(m3u_filename, 'w')
if extm3u:
# Mandatory header for extended playlists
f.write('#EXTM3U\n')
for episode in episodes:
if not extm3u:
# Episode objects are strings that contain file names
f.write(episode+'\n')
continue
if episode.was_downloaded(and_exists=True):
filename = episode.local_filename(create=False)
assert filename is not None
if os.path.dirname(filename).startswith(os.path.dirname(m3u_filename)):
filename = filename[len(os.path.dirname(m3u_filename)+os.sep):]
f.write('#EXTINF:0,'+episode.playlist_title()+'\n')
f.write(filename+'\n')
f.close()
def generate_names(filename):
basename, ext = os.path.splitext(filename)
for i in itertools.count():
if i:
yield '%s (%d)%s' % (basename, i+1, ext)
else:
yield filename
def is_known_redirecter(url):
"""Check if a URL redirect is expected, and no filenames should be updated
We usually honor URL redirects, and update filenames accordingly.
In some cases (e.g. Soundcloud) this results in a worse filename,
so we hardcode and detect these cases here to avoid renaming files
for which we know that a "known good default" exists.
The problem here is that by comparing the currently-assigned filename
with the new filename determined by the URL, we cannot really determine
which one is the "better" URL (e.g. "n5rMSpXrqmR9.128.mp3" for Soundcloud).
"""
# Soundcloud-hosted media downloads (we take the track name as filename)
if url.startswith('http://ak-media.soundcloud.com/'):
return True
return False
def atomic_rename(old_name, new_name):
"""Atomically rename/move a (temporary) file
This is usually used when updating a file safely by writing
the new contents into a temporary file and then moving the
temporary file over the original file to replace it.
"""
if gpodder.win32:
# Win32 does not support atomic rename with os.rename
shutil.move(old_name, new_name)
else:
os.rename(old_name, new_name)
def check_command(self, cmd):
"""Check if a command line command/program exists"""
# Prior to Python 2.7.3, this module (shlex) did not support Unicode input.
cmd = sanitize_encoding(cmd)
program = shlex.split(cmd)[0]
return (find_command(program) is not None)
def rename_episode_file(episode, filename):
"""Helper method to update a PodcastEpisode object
Useful after renaming/converting its download file.
"""
if not os.path.exists(filename):
raise ValueError('Target filename does not exist.')
basename, extension = os.path.splitext(filename)
episode.download_filename = os.path.basename(filename)
episode.file_size = os.path.getsize(filename)
episode.mime_type = mimetype_from_extension(extension)
episode.save()
episode.db.commit()
def get_update_info(url='http://gpodder.org/downloads'):
"""
Get up to date release information from gpodder.org.
Returns a tuple: (up_to_date, latest_version, release_date, days_since)
Example result (up to date version, 20 days after release):
(True, '3.0.4', '2012-01-24', 20)
Example result (outdated version, 10 days after release):
(False, '3.0.5', '2012-02-29', 10)
"""
data = urlopen(url).read()
id_field_re = re.compile(r'<([a-z]*)[^>]*id="([^"]*)"[^>]*>([^<]*)')
info = dict((m.group(2), m.group(3)) for m in id_field_re.finditer(data))
latest_version = info['latest-version']
release_date = info['release-date']
release_parsed = datetime.datetime.strptime(release_date, '%Y-%m-%d')
days_since_release = (datetime.datetime.today() - release_parsed).days
convert = lambda s: tuple(int(x) for x in s.split('.'))
up_to_date = (convert(gpodder.__version__) >= convert(latest_version))
return up_to_date, latest_version, release_date, days_since_release
gpodder-3.1.2/src/gpodder/query.py 0000664 0001750 0001750 00000012134 11751103635 016510 0 ustar thp thp 0000000 0000000 # -*- coding: utf-8 -*-
#
# gPodder - A media aggregator and podcast client
# Copyright (c) 2005-2012 Thomas Perl and the gPodder Team
#
# gPodder is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# gPodder is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see ', 'eval')
except Exception, e:
print e
self._query = None
def match(self, episode):
if self._query is None:
return False
if self._regex:
return re.search(self._query, episode.title, self._flags) is not None
elif self._string:
return self._query in episode.title.lower()
return Matcher(episode).match(self._query)
def filter(self, episodes):
return filter(self.match, episodes)
def UserEQL(query):
"""EQL wrapper for user input
Automatically adds missing quotes around a
non-EQL string for user-based input. In this
case, EQL queries need to be enclosed in ().
"""
if query is None:
return None
if query == '' or (query and query[0] not in "(/'\""):
return EQL("'%s'" % query)
else:
return EQL(query)
gpodder-3.1.2/src/gpodder/plugins/ 0000775 0001750 0001750 00000000000 11760761026 016455 5 ustar thp thp 0000000 0000000 gpodder-3.1.2/src/gpodder/plugins/xspf.py 0000664 0001750 0001750 00000012575 11751103635 020015 0 ustar thp thp 0000000 0000000 #!/usr/bin/python
# -*- coding: utf-8 -*-
#
# gPodder - A media aggregator and podcast client
# Copyright (c) 2005-2012 Thomas Perl and the gPodder Team
#
# gPodder is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# gPodder is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see ; 2010-08-07
# Currently, this is restricted to FM4 On Demand content, as the XSPF parser
# here isn't generic enough to parse all other feeds reliably. Please get in
# touch if you want support for other feeds - you can use the existing parser
# as a template for your own! :)
#
# See http://fm4.orf.at/radio/stories/audio for available feeds
import gpodder
_ = gpodder.gettext
from gpodder import model
from gpodder import util
import os
import time
import re
import feedparser
from xml.dom import minidom
def get_metadata(url):
"""Get file download metadata
Returns a (size, type, name) from the given download
URL. Will use the network connection to determine the
metadata via the HTTP header fields.
"""
track_fp = util.urlopen(url)
headers = track_fp.info()
filesize = headers['content-length'] or '0'
filetype = headers['content-type'] or 'application/octet-stream'
if 'last-modified' in headers:
parsed_date = feedparser._parse_date(headers['last-modified'])
filedate = time.mktime(parsed_date)
else:
filedate = None
filename = os.path.basename(os.path.dirname(url))
track_fp.close()
return filesize, filetype, filedate, filename
class FM4OnDemandPlaylist(object):
URL_REGEX = re.compile('http://onapp1\.orf\.at/webcam/fm4/fod/([^/]+)\.xspf$')
CONTENT = {
'spezialmusik': (
'FM4 Sendungen',
'http://onapp1.orf.at/webcam/fm4/fod/SOD_Bild_Spezialmusik.jpg',
'http://fm4.orf.at/',
'Sendungen jeweils sieben Tage zum Nachhören.',
),
'unlimited': (
'FM4 Unlimited',
'http://onapp1.orf.at/webcam/fm4/fod/SOD_Bild_Unlimited.jpg',
'http://fm4.orf.at/unlimited',
'Montag bis Freitag (14-15 Uhr)',
),
'soundpark': (
'FM4 Soundpark',
'http://onapp1.orf.at/webcam/fm4/fod/SOD_Bild_Soundpark.jpg',
'http://fm4.orf.at/soundpark',
'Nacht von Sonntag auf Montag (1-6 Uhr)',
),
}
@classmethod
def handle_url(cls, url):
m = cls.URL_REGEX.match(url)
if m is not None:
category = m.group(1)
return cls(url, category)
@classmethod
def get_text_contents(cls, node):
if hasattr(node, '__iter__'):
return u''.join(cls.get_text_contents(x) for x in node)
elif node.nodeType == node.TEXT_NODE:
return node.data
else:
return u''.join(cls.get_text_contents(c) for c in node.childNodes)
def __init__(self, url, category):
self.url = url
self.category = category
# TODO: Use proper caching of contents with support for
# conditional GETs (If-Modified-Since, ETag, ...)
self.data = minidom.parse(util.urlopen(url))
self.playlist = self.data.getElementsByTagName('playlist')[0]
def get_title(self):
title = self.playlist.getElementsByTagName('title')[0]
default = self.get_text_contents(title)
return self.CONTENT.get(self.category, \
(default, None, None, None))[0]
def get_image(self):
return self.CONTENT.get(self.category, \
(None, None, None, None))[1]
def get_link(self):
return self.CONTENT.get(self.category, \
(None, None, 'http://fm4.orf.at/', None))[2]
def get_description(self):
return self.CONTENT.get(self.category, \
(None, None, None, 'XSPF playlist'))[3]
def get_new_episodes(self, channel, existing_guids):
tracks = []
seen_guids = []
for track in self.playlist.getElementsByTagName('track'):
title = self.get_text_contents(track.getElementsByTagName('title'))
url = self.get_text_contents(track.getElementsByTagName('location'))
seen_guids.append(url)
if url in existing_guids:
continue
filesize, filetype, filedate, filename = get_metadata(url)
episode = channel.episode_factory({
'title': title,
'link': '',
'description': '',
'url': url,
'file_size': int(filesize),
'mime_type': filetype,
'guid': url,
'published': filedate,
})
episode.save()
tracks.append(episode)
return tracks, seen_guids
# Register our URL handlers
model.register_custom_handler(FM4OnDemandPlaylist)
gpodder-3.1.2/src/gpodder/plugins/__init__.py 0000664 0001750 0001750 00000001373 11751103635 020566 0 ustar thp thp 0000000 0000000 # -*- coding: utf-8 -*-
#
# gPodder - A media aggregator and podcast client
# Copyright (c) 2005-2012 Thomas Perl and the gPodder Team
#
# gPodder is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# gPodder is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see ; 2009-11-03
import gpodder
_ = gpodder.gettext
from gpodder import model
from gpodder import util
try:
# For Python < 2.6, we use the "simplejson" add-on module
import simplejson as json
except ImportError:
# Python 2.6 already ships with a nice "json" module
import json
import os
import time
import re
import email
# gPodder's consumer key for the Soundcloud API
CONSUMER_KEY = 'zrweghtEtnZLpXf3mlm8mQ'
def soundcloud_parsedate(s):
"""Parse a string into a unix timestamp
Only strings provided by Soundcloud's API are
parsed with this function (2009/11/03 13:37:00).
"""
m = re.match(r'(\d{4})/(\d{2})/(\d{2}) (\d{2}):(\d{2}):(\d{2})', s)
return time.mktime([int(x) for x in m.groups()]+[0, 0, -1])
def get_param(s, param='filename', header='content-disposition'):
"""Get a parameter from a string of headers
By default, this gets the "filename" parameter of
the content-disposition header. This works fine
for downloads from Soundcloud.
"""
msg = email.message_from_string(s)
if header in msg:
value = msg.get_param(param, header=header)
decoded_list = email.header.decode_header(value)
value = []
for part, encoding in decoded_list:
if encoding:
value.append(part.decode(encoding))
else:
value.append(unicode(part))
return u''.join(value)
return None
def get_metadata(url):
"""Get file download metadata
Returns a (size, type, name) from the given download
URL. Will use the network connection to determine the
metadata via the HTTP header fields.
"""
track_fp = util.urlopen(url)
headers = track_fp.info()
filesize = headers['content-length'] or '0'
filetype = headers['content-type'] or 'application/octet-stream'
headers_s = '\n'.join('%s:%s'%(k,v) for k, v in headers.items())
filename = get_param(headers_s) or os.path.basename(os.path.dirname(url))
track_fp.close()
return filesize, filetype, filename
class SoundcloudUser(object):
def __init__(self, username):
self.username = username
self.cache_file = os.path.join(gpodder.home, 'Soundcloud')
if os.path.exists(self.cache_file):
try:
self.cache = json.load(open(self.cache_file, 'r'))
except:
self.cache = {}
else:
self.cache = {}
def commit_cache(self):
json.dump(self.cache, open(self.cache_file, 'w'))
def get_coverart(self):
global CONSUMER_KEY
key = ':'.join((self.username, 'avatar_url'))
if key in self.cache:
return self.cache[key]
image = None
try:
json_url = 'http://api.soundcloud.com/users/%s.json?consumer_key=%s' % (self.username, CONSUMER_KEY)
user_info = json.load(util.urlopen(json_url))
image = user_info.get('avatar_url', None)
self.cache[key] = image
finally:
self.commit_cache()
return image
def get_tracks(self, feed):
"""Get a generator of tracks from a SC user
The generator will give you a dictionary for every
track it can find for its user."""
global CONSUMER_KEY
try:
json_url = 'http://api.soundcloud.com/users/%(user)s/%(feed)s.json?filter=downloadable&consumer_key=%(consumer_key)s' \
% { "user":self.username, "feed":feed, "consumer_key": CONSUMER_KEY }
tracks = (track for track in json.load(util.urlopen(json_url)) \
if track['downloadable'])
for track in tracks:
# Prefer stream URL (MP3), fallback to download URL
url = track.get('stream_url', track['download_url']) + \
'?consumer_key=%(consumer_key)s' \
% { 'consumer_key': CONSUMER_KEY }
if url not in self.cache:
try:
self.cache[url] = get_metadata(url)
except:
continue
filesize, filetype, filename = self.cache[url]
yield {
'title': track.get('title', track.get('permalink')) or _('Unknown track'),
'link': track.get('permalink_url') or 'http://soundcloud.com/'+self.username,
'description': track.get('description') or _('No description available'),
'url': url,
'file_size': int(filesize),
'mime_type': filetype,
'guid': track.get('permalink', track.get('id')),
'published': soundcloud_parsedate(track.get('created_at', None)),
}
finally:
self.commit_cache()
class SoundcloudFeed(object):
URL_REGEX = re.compile('http://([a-z]+\.)?soundcloud\.com/([^/]+)$', re.I)
@classmethod
def handle_url(cls, url):
m = cls.URL_REGEX.match(url)
if m is not None:
subdomain, username = m.groups()
return cls(username)
def __init__(self, username):
self.username = username
self.sc_user = SoundcloudUser(username)
def get_title(self):
return _('%s on Soundcloud') % self.username
def get_image(self):
return self.sc_user.get_coverart()
def get_link(self):
return 'http://soundcloud.com/%s' % self.username
def get_description(self):
return _('Tracks published by %s on Soundcloud.') % self.username
def get_new_episodes(self, channel, existing_guids):
return self._get_new_episodes(channel, existing_guids, 'tracks')
def _get_new_episodes(self, channel, existing_guids, track_type):
tracks = [t for t in self.sc_user.get_tracks(track_type)]
seen_guids = [track['guid'] for track in tracks]
episodes = []
for track in tracks:
if track['guid'] not in existing_guids:
episode = channel.episode_factory(track)
episode.save()
episodes.append(episode)
return episodes, seen_guids
class SoundcloudFavFeed(SoundcloudFeed):
URL_REGEX = re.compile('http://([a-z]+\.)?soundcloud\.com/([^/]+)/favorites', re.I)
def __init__(self, username):
super(SoundcloudFavFeed,self).__init__(username)
def get_title(self):
return _('%s\'s favorites on Soundcloud') % self.username
def get_link(self):
return 'http://soundcloud.com/%s/favorites' % self.username
def get_description(self):
return _('Tracks favorited by %s on Soundcloud.') % self.username
def get_new_episodes(self, channel, existing_guids):
return self._get_new_episodes(channel, existing_guids, 'favorites')
# Register our URL handlers
model.register_custom_handler(SoundcloudFeed)
model.register_custom_handler(SoundcloudFavFeed)
gpodder-3.1.2/src/gpodder/__init__.py 0000664 0001750 0001750 00000013516 11760760347 017120 0 ustar thp thp 0000000 0000000 # -*- coding: utf-8 -*-
#
# gPodder - A media aggregator and podcast client
# Copyright (c) 2005-2012 Thomas Perl and the gPodder Team
#
# gPodder is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# gPodder is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see '
__version__ = '3.1.2'
__date__ = '2012-05-28'
__relname__ = 'Capture the Moon'
__copyright__ = '© 2005-2012 Thomas Perl and the gPodder Team'
__license__ = 'GNU General Public License, version 3 or later'
__url__ = 'http://gpodder.org/'
__version_info__ = tuple(int(x) for x in __version__.split('.'))
import os
import sys
import platform
import gettext
import locale
# Check if real hard dependencies are available
try:
import feedparser
except ImportError:
print """
Error: Module "feedparser" (python-feedparser) not found.
The feedparser module can be downloaded from
http://code.google.com/p/feedparser/
"""
sys.exit(1)
del feedparser
try:
import mygpoclient
except ImportError:
print """
Error: Module "mygpoclient" (python-mygpoclient) not found.
The mygpoclient module can be downloaded from
http://thp.io/2010/mygpoclient/
"""
sys.exit(1)
del mygpoclient
try:
import sqlite3
except ImportError:
print """
Error: Module "sqlite3" not found.
Build Python with SQLite 3 support or get it from
http://code.google.com/p/pysqlite/
"""
sys.exit(1)
del sqlite3
# The User-Agent string for downloads
user_agent = 'gPodder/%s (+%s)' % (__version__, __url__)
# Are we running in GUI, Maemo or console mode?
class UI(object):
def __init__(self):
self.fremantle = False
self.harmattan = False
self.gtk = False
self.qml = False
self.cli = False
ui = UI()
# D-Bus specific interface names
dbus_bus_name = 'org.gpodder'
dbus_gui_object_path = '/gui'
dbus_podcasts_object_path = '/podcasts'
dbus_interface = 'org.gpodder.interface'
dbus_podcasts = 'org.gpodder.podcasts'
dbus_session_bus = None
# Set "win32" to True if we are on Windows
win32 = (platform.system() == 'Windows')
# Set "osx" to True if we are on Mac OS X
osx = (platform.system() == 'Darwin')
# i18n setup (will result in "gettext" to be available)
# Use _ = gpodder.gettext in modules to enable string translations
textdomain = 'gpodder'
locale_dir = gettext.bindtextdomain(textdomain)
t = gettext.translation(textdomain, locale_dir, fallback=True)
try:
# Python 2
gettext = t.ugettext
ngettext = t.ungettext
except AttributeError:
# Python 3
gettext = t.gettext
ngettext = t.ngettext
if win32:
try:
# Workaround for bug 650
from gtk.glade import bindtextdomain
bindtextdomain(textdomain, locale_dir)
del bindtextdomain
except:
# Ignore for QML UI or missing glade module
pass
del t
# Set up textdomain for gtk.Builder (this accesses the C library functions)
if hasattr(locale, 'bindtextdomain'):
locale.bindtextdomain(textdomain, locale_dir)
del locale_dir
# Set up socket timeouts to fix bug 174
SOCKET_TIMEOUT = 60
import socket
socket.setdefaulttimeout(SOCKET_TIMEOUT)
del socket
del SOCKET_TIMEOUT
# Variables reserved for GUI-specific use (will be set accordingly)
ui_folders = []
credits_file = None
icon_file = None
images_folder = None
user_extensions = None
# Episode states used in the database
STATE_NORMAL, STATE_DOWNLOADED, STATE_DELETED = range(3)
# Paths (gPodder's home folder, config, db, download and data prefix)
home = None
config_file = None
database_file = None
downloads = None
prefix = None
# Function to set a new gPodder home folder
def set_home(new_home):
global home, config_file, database_file, downloads
home = os.path.abspath(new_home)
config_file = os.path.join(home, 'Settings.json')
database_file = os.path.join(home, 'Database')
downloads = os.path.join(home, 'Downloads')
# Default locations for configuration and data files
default_home = os.path.expanduser(os.path.join('~', 'gPodder'))
set_home(os.environ.get('GPODDER_HOME', default_home))
if home != default_home:
print >>sys.stderr, 'Storing data in', home, '(GPODDER_HOME is set)'
# Plugins to load by default
DEFAULT_PLUGINS = [
'gpodder.plugins.soundcloud',
'gpodder.plugins.xspf',
]
def load_plugins():
"""Load (non-essential) plugin modules
This loads a default set of plugins, but you can use
the environment variable "GPODDER_PLUGINS" to modify
the list of plugins."""
PLUGINS = os.environ.get('GPODDER_PLUGINS', None)
if PLUGINS is None:
PLUGINS = DEFAULT_PLUGINS
else:
PLUGINS = PLUGINS.split()
for plugin in PLUGINS:
try:
__import__(plugin)
except Exception, e:
print >>sys.stderr, 'Cannot load plugin: %s (%s)' % (plugin, e)
def detect_platform():
global ui
try:
etc_issue = open('/etc/issue').read()
except Exception, e:
etc_issue = ''
ui.fremantle = ('Maemo 5' in etc_issue)
ui.harmattan = ('MeeGo 1.2 Harmattan' in etc_issue)
if (ui.fremantle or ui.harmattan) and 'GPODDER_HOME' not in os.environ:
new_home = os.path.expanduser(os.path.join('~', 'MyDocs', 'gPodder'))
set_home(os.path.expanduser(new_home))
gpodder-3.1.2/src/gpodder/api.py 0000664 0001750 0001750 00000020523 11751103635 016115 0 ustar thp thp 0000000 0000000 # -*- coding: utf-8 -*-
#
# gPodder - A media aggregator and podcast client
# Copyright (c) 2005-2012 Thomas Perl and the gPodder Team
#
# gPodder is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# gPodder is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see ; 2009-06-11
#
import feedparser
try:
# Python 2
from rfc822 import mktime_tz
except ImportError:
# Python 3
from email.utils import mktime_tz
def patch_feedparser():
"""Monkey-patch the Universal Feed Parser"""
# Detect the 'plain' content type as 'text/plain'
# http://code.google.com/p/feedparser/issues/detail?id=80
def mapContentType2(self, contentType):
contentType = contentType.lower()
if contentType == 'text' or contentType == 'plain':
contentType = 'text/plain'
elif contentType == 'html':
contentType = 'text/html'
elif contentType == 'xhtml':
contentType = 'application/xhtml+xml'
return contentType
try:
if feedparser._FeedParserMixin().mapContentType('plain') == 'plain':
feedparser._FeedParserMixin.mapContentType = mapContentType2
except:
pass
# Fix parsing of Media RSS with feedparser, as described here:
# http://code.google.com/p/feedparser/issues/detail?id=100#c4
def _start_media_content(self, attrsD):
context = self._getContext()
context.setdefault('media_content', [])
context['media_content'].append(attrsD)
try:
feedparser._FeedParserMixin._start_media_content = _start_media_content
except:
pass
# Fix problem with the EA.com official podcast
# https://bugs.gpodder.org/show_bug.cgi?id=588
if '*/*' not in feedparser.ACCEPT_HEADER.split(','):
feedparser.ACCEPT_HEADER += ',*/*'
# Fix problem with YouTube feeds and pubDate/atom:modified
# https://bugs.gpodder.org/show_bug.cgi?id=1492
# http://code.google.com/p/feedparser/issues/detail?id=310
def _end_updated(self):
value = self.pop('updated')
parsed_value = feedparser._parse_date(value)
overwrite = ('youtube.com' not in self.baseuri)
self._save('updated_parsed', parsed_value, overwrite=overwrite)
try:
feedparser._FeedParserMixin._end_updated = _end_updated
except:
pass
patch_feedparser()
class ExceptionWithData(Exception):
"""Base exception with additional payload"""
def __init__(self, data):
Exception.__init__(self)
self.data = data
def __str__(self):
return '%s: %s' % (self.__class__.__name__, str(self.data))
# Temporary errors
class Offline(Exception): pass
class BadRequest(Exception): pass
class InternalServerError(Exception): pass
class WifiLogin(ExceptionWithData): pass
# Fatal errors
class Unsubscribe(Exception): pass
class NotFound(Exception): pass
class InvalidFeed(Exception): pass
class UnknownStatusCode(ExceptionWithData): pass
# Authentication error
class AuthenticationRequired(Exception): pass
# Successful parsing of the feed
class UpdatedFeed(ExceptionWithData): pass
class NewLocation(ExceptionWithData): pass
class NotModified(ExceptionWithData): pass
class Fetcher(object):
# Supported types, see http://feedvalidator.org/docs/warning/EncodingMismatch.html
FEED_TYPES = ('application/rss+xml',
'application/atom+xml',
'application/rdf+xml',
'application/xml',
'text/xml')
def __init__(self, user_agent):
self.user_agent = user_agent
def _resolve_url(self, url):
"""Provide additional ways of resolving an URL
Subclasses can override this method to provide more
ways of resolving a given URL to a feed URL. If the
Fetcher is in "autodiscovery" mode, it will try this
method as a last resort for coming up with a feed URL.
"""
return None
def _autodiscover_feed(self, feed):
try:
# First, try all 2012-01-18
#
import copy
try:
# For Python < 2.6, we use the "simplejson" add-on module
import simplejson as json
except ImportError:
# Python 2.6 already ships with a nice "json" module
import json
class JsonConfigSubtree(object):
def __init__(self, parent, name):
self._parent = parent
self._name = name
def __repr__(self):
return '' % (self._name,)
def _attr(self, name):
return '.'.join((self._name, name))
def __getitem__(self, name):
return self._parent._lookup(self._name).__getitem__(name)
def __delitem__(self, name):
self._parent._lookup(self._name).__delitem__(name)
def __setitem__(self, name, value):
self._parent._lookup(self._name).__setitem__(name, value)
def __getattr__(self, name):
if name == 'keys':
# Kludge for using dict() on a JsonConfigSubtree
return getattr(self._parent._lookup(self._name), name)
return getattr(self._parent, self._attr(name))
def __setattr__(self, name, value):
if name.startswith('_'):
object.__setattr__(self, name, value)
else:
self._parent.__setattr__(self._attr(name), value)
class JsonConfig(object):
_INDENT = 2
def __init__(self, data=None, default=None, on_key_changed=None):
"""
Create a new JsonConfig object
data: A JSON string that contains the data to load (optional)
default: A dict that contains default config values (optional)
on_key_changed: Callback when a value changes (optional)
The signature of on_key_changed looks like this:
func(name, old_value, new_value)
name: The key name, e.g. "ui.gtk.show_toolbar"
old_value: The old value, e.g. False
new_value: The new value, e.g. True
For newly-set keys, on_key_changed is also called. In this case,
None will be the old_value:
>>> def callback(*args): print 'callback:', args
>>> c = JsonConfig(on_key_changed=callback)
>>> c.a.b = 10
callback: ('a.b', None, 10)
>>> c.a.b = 11
callback: ('a.b', 10, 11)
>>> c.x.y.z = [1,2,3]
callback: ('x.y.z', None, [1, 2, 3])
>>> c.x.y.z = 42
callback: ('x.y.z', [1, 2, 3], 42)
Please note that dict-style access will not call on_key_changed:
>>> def callback(*args): print 'callback:', args
>>> c = JsonConfig(on_key_changed=callback)
>>> c.a.b = 1 # This works as expected
callback: ('a.b', None, 1)
>>> c.a['c'] = 10 # This doesn't call on_key_changed!
>>> del c.a['c'] # This also doesn't call on_key_changed!
"""
self._default = default
self._data = copy.deepcopy(self._default) or {}
self._on_key_changed = on_key_changed
if data is not None:
self._restore(data)
def _restore(self, backup):
"""
Restore a previous state saved with repr()
This function allows you to "snapshot" the current values of
the configuration and reload them later on. Any missing
default values will be added on top of the restored config.
Returns True if new keys from the default config have been added,
False if no keys have been added (backup contains all default keys)
>>> c = JsonConfig()
>>> c.a.b = 10
>>> backup = repr(c)
>>> print c.a.b
10
>>> c.a.b = 11
>>> print c.a.b
11
>>> c._restore(backup)
False
>>> print c.a.b
10
"""
self._data = json.loads(backup)
# Add newly-added default configuration options
if self._default is not None:
return self._merge_keys(self._default)
return False
def _merge_keys(self, merge_source):
"""Merge keys from merge_source into this config object
Return True if new keys were merged, False otherwise
"""
added_new_key = False
# Recurse into the data and add missing items
work_queue = [(self._data, merge_source)]
while work_queue:
data, default = work_queue.pop()
for key, value in default.iteritems():
if key not in data:
# Copy defaults for missing key
data[key] = copy.deepcopy(value)
added_new_key = True
elif isinstance(value, dict):
# Recurse into sub-dictionaries
work_queue.append((data[key], value))
elif type(value) != type(data[key]):
# Type mismatch of current value and default
if type(value) == int and type(data[key]) == float:
# Convert float to int if default value is int
data[key] = int(data[key])
return added_new_key
def __repr__(self):
"""
>>> c = JsonConfig('{"a": 1}')
>>> print c
{
"a": 1
}
"""
return json.dumps(self._data, indent=self._INDENT)
def _lookup(self, name):
return reduce(lambda d, k: d[k], name.split('.'), self._data)
def _keys_iter(self):
work_queue = []
work_queue.append(([], self._data))
while work_queue:
path, data = work_queue.pop(0)
if isinstance(data, dict):
for key in sorted(data.keys()):
work_queue.append((path + [key], data[key]))
else:
yield '.'.join(path)
def __getattr__(self, name):
try:
value = self._lookup(name)
if not isinstance(value, dict):
return value
except KeyError:
pass
return JsonConfigSubtree(self, name)
def __setattr__(self, name, value):
if name.startswith('_'):
object.__setattr__(self, name, value)
return
attrs = name.split('.')
target_dict = self._data
while attrs:
attr = attrs.pop(0)
if not attrs:
old_value = target_dict.get(attr, None)
if old_value != value or attr not in target_dict:
target_dict[attr] = value
if self._on_key_changed is not None:
self._on_key_changed(name, old_value, value)
break
target = target_dict.get(attr, None)
if target is None or not isinstance(target, dict):
target_dict[attr] = target = {}
target_dict = target
gpodder-3.1.2/src/gpodder/log.py 0000664 0001750 0001750 00000006242 11751103635 016127 0 ustar thp thp 0000000 0000000 # -*- coding: utf-8 -*-
#
# gPodder - A media aggregator and podcast client
# Copyright (c) 2005-2012 Thomas Perl and the gPodder Team
#
# gPodder is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# gPodder is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see ; 2012-03-02
# Based on an initial draft by Neal Walfield
import gpodder
import glob
import logging
import os
import sys
import time
import traceback
logger = logging.getLogger(__name__)
def setup(verbose=True):
# Configure basic stdout logging
STDOUT_FMT = '%(created)f [%(name)s] %(levelname)s: %(message)s'
logging.basicConfig(format=STDOUT_FMT,
level=logging.DEBUG if verbose else logging.WARNING)
# Replace except hook with a custom one that logs it as an error
original_excepthook = sys.excepthook
def on_uncaught_exception(exctype, value, tb):
message = ''.join(traceback.format_exception(exctype, value, tb))
logger.error('Uncaught exception: %s', message)
original_excepthook(exctype, value, tb)
sys.excepthook = on_uncaught_exception
if os.environ.get('GPODDER_WRITE_LOGS', 'yes') != 'no':
# Configure file based logging
logging_basename = time.strftime('%Y-%m-%d.log')
logging_directory = os.path.join(gpodder.home, 'Logs')
if not os.path.isdir(logging_directory):
try:
os.makedirs(logging_directory)
except:
logger.warn('Cannot create output directory: %s',
logging_directory)
return False
# Keep logs around for 5 days
LOG_KEEP_DAYS = 5
# Purge old logfiles if they are older than LOG_KEEP_DAYS days
old_logfiles = glob.glob(os.path.join(logging_directory, '*-*-*.log'))
for old_logfile in old_logfiles:
st = os.stat(old_logfile)
if time.time() - st.st_mtime > 60*60*24*LOG_KEEP_DAYS:
logger.info('Purging old logfile: %s', old_logfile)
try:
os.remove(old_logfile)
except:
logger.warn('Cannot purge logfile: %s', exc_info=True)
root = logging.getLogger()
logfile = os.path.join(logging_directory, logging_basename)
file_handler = logging.FileHandler(logfile, 'a', 'utf-8')
FILE_FMT = '%(asctime)s [%(name)s] %(levelname)s: %(message)s'
file_handler.setFormatter(logging.Formatter(FILE_FMT))
root.addHandler(file_handler)
logger.debug('==== gPodder starts up (ui=%s) ===', ', '.join(name
for name in ('cli', 'gtk', 'qml') if getattr(gpodder.ui, name, False)))
return True
gpodder-3.1.2/src/gpodder/player.py 0000664 0001750 0001750 00000004504 11751103635 016641 0 ustar thp thp 0000000 0000000 # -*- coding: utf-8 -*-
#
# gPodder - A media aggregator and podcast client
# Copyright (c) 2005-2012 Thomas Perl and the gPodder Team
#
# gPodder is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# gPodder is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see ; 2010-04-25
#
# Specification: http://gpodder.org/wiki/Media_Player_D-Bus_API
#
import gpodder
import urllib
class MediaPlayerDBusReceiver(object):
INTERFACE = 'org.gpodder.player'
SIGNAL_STARTED = 'PlaybackStarted'
SIGNAL_STOPPED = 'PlaybackStopped'
def __init__(self, on_play_event):
self.on_play_event = on_play_event
self.bus = gpodder.dbus_session_bus
self.bus.add_signal_receiver(self.on_playback_started, \
self.SIGNAL_STARTED, \
self.INTERFACE, \
None, \
None)
self.bus.add_signal_receiver(self.on_playback_stopped, \
self.SIGNAL_STOPPED, \
self.INTERFACE, \
None, \
None)
def on_playback_started(self, position, file_uri):
pass
def on_playback_stopped(self, start, end, total, file_uri):
# Assume the URI comes as quoted UTF-8 string, so decode
# it first to utf-8 (should be no problem) for unquoting
# to work correctly on this later on (Maemo bug 11811)
if isinstance(file_uri, unicode):
file_uri = file_uri.encode('utf-8')
if file_uri.startswith('/'):
file_uri = 'file://' + urllib.quote(file_uri)
self.on_play_event(start, end, total, file_uri)
gpodder-3.1.2/src/gpodder/opml.py 0000664 0001750 0001750 00000015732 11751103635 016321 0 ustar thp thp 0000000 0000000 # -*- coding: utf-8 -*-
#
# gPodder - A media aggregator and podcast client
# Copyright (c) 2005-2012 Thomas Perl and the gPodder Team
#
# gPodder is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# gPodder is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see 2007-08-19
#
# based on: libopmlreader.py (2006-06-13)
# libopmlwriter.py (2005-12-08)
#
"""OPML import and export functionality
This module contains helper classes to import subscriptions
from OPML files on the web and to export a list of channel
objects to valid OPML 1.1 files that can be used to backup
or distribute gPodder's channel subscriptions.
"""
import logging
logger = logging.getLogger(__name__)
from gpodder import util
import xml.dom.minidom
import os.path
import os
import shutil
from email.utils import formatdate
import gpodder
class Importer(object):
"""
Helper class to import an OPML feed from protocols
supported by urllib2 (e.g. HTTP) and return a GTK
ListStore that can be displayed in the GUI.
This class should support standard OPML feeds and
contains workarounds to support odeo.com feeds.
"""
VALID_TYPES = ('rss', 'link')
def __init__( self, url):
"""
Parses the OPML feed from the given URL into
a local data structure containing channel metadata.
"""
self.items = []
try:
if os.path.exists(url):
doc = xml.dom.minidom.parse(url)
else:
doc = xml.dom.minidom.parseString(util.urlopen(url).read())
for outline in doc.getElementsByTagName('outline'):
# Make sure we are dealing with a valid link type (ignore case)
otl_type = outline.getAttribute('type')
if otl_type is None or otl_type.lower() not in self.VALID_TYPES:
continue
if outline.getAttribute('xmlUrl') or outline.getAttribute('url'):
channel = {
'url': outline.getAttribute('xmlUrl') or outline.getAttribute('url'),
'title': outline.getAttribute('title') or outline.getAttribute('text') or outline.getAttribute('xmlUrl') or outline.getAttribute('url'),
'description': outline.getAttribute('text') or outline.getAttribute('xmlUrl') or outline.getAttribute('url'),
}
if channel['description'] == channel['title']:
channel['description'] = channel['url']
for attr in ( 'url', 'title', 'description' ):
channel[attr] = channel[attr].strip()
self.items.append( channel)
if not len(self.items):
logger.info('OPML import finished, but no items found: %s', url)
except:
logger.error('Cannot import OPML from URL: %s', url, exc_info=True)
class Exporter(object):
"""
Helper class to export a list of channel objects
to a local file in OPML 1.1 format.
See www.opml.org for the OPML specification.
"""
FEED_TYPE = 'rss'
def __init__( self, filename):
if filename is None:
self.filename = None
elif filename.endswith( '.opml') or filename.endswith( '.xml'):
self.filename = filename
else:
self.filename = '%s.opml' % ( filename, )
def create_node( self, doc, name, content):
"""
Creates a simple XML Element node in a document
with tag name "name" and text content "content",
as in content and returns the element.
"""
node = doc.createElement( name)
node.appendChild( doc.createTextNode( content))
return node
def create_outline( self, doc, channel):
"""
Creates a OPML outline as XML Element node in a
document for the supplied channel.
"""
outline = doc.createElement( 'outline')
outline.setAttribute( 'title', channel.title)
outline.setAttribute( 'text', channel.description)
outline.setAttribute( 'xmlUrl', channel.url)
outline.setAttribute( 'type', self.FEED_TYPE)
return outline
def write( self, channels):
"""
Creates a XML document containing metadata for each
channel object in the "channels" parameter, which
should be a list of channel objects.
OPML 2.0 specification: http://www.opml.org/spec2
Returns True on success or False when there was an
error writing the file.
"""
if self.filename is None:
return False
doc = xml.dom.minidom.Document()
opml = doc.createElement('opml')
opml.setAttribute('version', '2.0')
doc.appendChild(opml)
head = doc.createElement( 'head')
head.appendChild( self.create_node( doc, 'title', 'gPodder subscriptions'))
head.appendChild( self.create_node( doc, 'dateCreated', formatdate(localtime=True)))
opml.appendChild( head)
body = doc.createElement( 'body')
for channel in channels:
body.appendChild( self.create_outline( doc, channel))
opml.appendChild( body)
try:
data = doc.toprettyxml(encoding='utf-8', indent=' ', newl=os.linesep)
# We want to have at least 512 KiB free disk space after
# saving the opml data, if this is not possible, don't
# try to save the new file, but keep the old one so we
# don't end up with a clobbed, empty opml file.
FREE_DISK_SPACE_AFTER = 1024*512
path = os.path.dirname(self.filename) or os.path.curdir
available = util.get_free_disk_space(path)
if available < 2*len(data)+FREE_DISK_SPACE_AFTER:
# On Windows, if we have zero bytes available, assume that we have
# not had the win32file module available + assume enough free space
if not gpodder.win32 or available > 0:
logger.error('Not enough free disk space to save channel list to %s', self.filename)
return False
fp = open(self.filename+'.tmp', 'w')
fp.write(data)
fp.close()
util.atomic_rename(self.filename+'.tmp', self.filename)
except:
logger.error('Could not open file for writing: %s', self.filename,
exc_info=True)
return False
return True
gpodder-3.1.2/src/gpodder/download.py 0000664 0001750 0001750 00000102227 11751103635 017155 0 ustar thp thp 0000000 0000000 # -*- coding: utf-8 -*-
#
# gPodder - A media aggregator and podcast client
# Copyright (c) 2005-2012 Thomas Perl and the gPodder Team
#
# gPodder is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# gPodder is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see 2007-09-15
#
# Based on libwget.py (2005-10-29)
#
from __future__ import with_statement
import logging
logger = logging.getLogger(__name__)
from gpodder import util
from gpodder import youtube
from gpodder import vimeo
import gpodder
import socket
import threading
import urllib
import urlparse
import shutil
import os.path
import os
import time
import collections
import mimetypes
import email
from email.header import decode_header
_ = gpodder.gettext
def get_header_param(headers, param, header_name):
"""Extract a HTTP header parameter from a dict
Uses the "email" module to retrieve parameters
from HTTP headers. This can be used to get the
"filename" parameter of the "content-disposition"
header for downloads to pick a good filename.
Returns None if the filename cannot be retrieved.
"""
try:
headers_string = ['%s:%s'%(k,v) for k,v in headers.items()]
msg = email.message_from_string('\n'.join(headers_string))
if header_name in msg:
value = msg.get_param(param, header=header_name)
if value is None:
return None
decoded_list = decode_header(value)
value = []
for part, encoding in decoded_list:
if encoding:
value.append(part.decode(encoding))
else:
value.append(unicode(part))
return u''.join(value)
except Exception, e:
logger.error('Cannot get %s from %s', param, header_name, exc_info=True)
return None
class ContentRange(object):
# Based on:
# http://svn.pythonpaste.org/Paste/WebOb/trunk/webob/byterange.py
#
# Copyright (c) 2007 Ian Bicking and Contributors
#
# Permission is hereby granted, free of charge, to any person obtaining
# a copy of this software and associated documentation files (the
# "Software"), to deal in the Software without restriction, including
# without limitation the rights to use, copy, modify, merge, publish,
# distribute, sublicense, and/or sell copies of the Software, and to
# permit persons to whom the Software is furnished to do so, subject to
# the following conditions:
#
# The above copyright notice and this permission notice shall be
# included in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
"""
Represents the Content-Range header
This header is ``start-stop/length``, where stop and length can be
``*`` (represented as None in the attributes).
"""
def __init__(self, start, stop, length):
assert start >= 0, "Bad start: %r" % start
assert stop is None or (stop >= 0 and stop >= start), (
"Bad stop: %r" % stop)
self.start = start
self.stop = stop
self.length = length
def __repr__(self):
return '<%s %s>' % (
self.__class__.__name__,
self)
def __str__(self):
if self.stop is None:
stop = '*'
else:
stop = self.stop + 1
if self.length is None:
length = '*'
else:
length = self.length
return 'bytes %s-%s/%s' % (self.start, stop, length)
def __iter__(self):
"""
Mostly so you can unpack this, like:
start, stop, length = res.content_range
"""
return iter([self.start, self.stop, self.length])
@classmethod
def parse(cls, value):
"""
Parse the header. May return None if it cannot parse.
"""
if value is None:
return None
value = value.strip()
if not value.startswith('bytes '):
# Unparseable
return None
value = value[len('bytes '):].strip()
if '/' not in value:
# Invalid, no length given
return None
range, length = value.split('/', 1)
if '-' not in range:
# Invalid, no range
return None
start, end = range.split('-', 1)
try:
start = int(start)
if end == '*':
end = None
else:
end = int(end)
if length == '*':
length = None
else:
length = int(length)
except ValueError:
# Parse problem
return None
if end is None:
return cls(start, None, length)
else:
return cls(start, end-1, length)
class DownloadCancelledException(Exception): pass
class AuthenticationError(Exception): pass
class gPodderDownloadHTTPError(Exception):
def __init__(self, url, error_code, error_message):
self.url = url
self.error_code = error_code
self.error_message = error_message
class DownloadURLOpener(urllib.FancyURLopener):
version = gpodder.user_agent
# Sometimes URLs are not escaped correctly - try to fix them
# (see RFC2396; Section 2.4.3. Excluded US-ASCII Characters)
# FYI: The omission of "%" in the list is to avoid double escaping!
ESCAPE_CHARS = dict((ord(c), u'%%%x'%ord(c)) for c in u' <>#"{}|\\^[]`')
def __init__( self, channel):
self.channel = channel
self._auth_retry_counter = 0
urllib.FancyURLopener.__init__(self, None)
def http_error_default(self, url, fp, errcode, errmsg, headers):
"""
FancyURLopener by default does not raise an exception when
there is some unknown HTTP error code. We want to override
this and provide a function to log the error and raise an
exception, so we don't download the HTTP error page here.
"""
# The following two lines are copied from urllib.URLopener's
# implementation of http_error_default
void = fp.read()
fp.close()
raise gPodderDownloadHTTPError(url, errcode, errmsg)
def redirect_internal(self, url, fp, errcode, errmsg, headers, data):
""" This is the exact same function that's included with urllib
except with "void = fp.read()" commented out. """
if 'location' in headers:
newurl = headers['location']
elif 'uri' in headers:
newurl = headers['uri']
else:
return
# This blocks forever(?) with certain servers (see bug #465)
#void = fp.read()
fp.close()
# In case the server sent a relative URL, join with original:
newurl = urlparse.urljoin(self.type + ":" + url, newurl)
return self.open(newurl)
# The following is based on Python's urllib.py "URLopener.retrieve"
# Also based on http://mail.python.org/pipermail/python-list/2001-October/110069.html
def http_error_206(self, url, fp, errcode, errmsg, headers, data=None):
# The next line is taken from urllib's URLopener.open_http
# method, at the end after the line "if errcode == 200:"
return urllib.addinfourl(fp, headers, 'http:' + url)
def retrieve_resume(self, url, filename, reporthook=None, data=None):
"""Download files from an URL; return (headers, real_url)
Resumes a download if the local filename exists and
the server supports download resuming.
"""
current_size = 0
tfp = None
if os.path.exists(filename):
try:
current_size = os.path.getsize(filename)
tfp = open(filename, 'ab')
#If the file exists, then only download the remainder
if current_size > 0:
self.addheader('Range', 'bytes=%s-' % (current_size))
except:
logger.warn('Cannot resume download: %s', filename, exc_info=True)
tfp = None
current_size = 0
if tfp is None:
tfp = open(filename, 'wb')
# Fix a problem with bad URLs that are not encoded correctly (bug 549)
url = url.decode('ascii', 'ignore')
url = url.translate(self.ESCAPE_CHARS)
url = url.encode('ascii')
url = urllib.unwrap(urllib.toBytes(url))
fp = self.open(url, data)
headers = fp.info()
if current_size > 0:
# We told the server to resume - see if she agrees
# See RFC2616 (206 Partial Content + Section 14.16)
# XXX check status code here, too...
range = ContentRange.parse(headers.get('content-range', ''))
if range is None or range.start != current_size:
# Ok, that did not work. Reset the download
# TODO: seek and truncate if content-range differs from request
tfp.close()
tfp = open(filename, 'wb')
current_size = 0
logger.warn('Cannot resume: Invalid Content-Range (RFC2616).')
result = headers, fp.geturl()
bs = 1024*8
size = -1
read = current_size
blocknum = int(current_size/bs)
if reporthook:
if "content-length" in headers:
size = int(headers.getrawheader("Content-Length")) + current_size
reporthook(blocknum, bs, size)
while read < size or size == -1:
if size == -1:
block = fp.read(bs)
else:
block = fp.read(min(size-read, bs))
if block == "":
break
read += len(block)
tfp.write(block)
blocknum += 1
if reporthook:
reporthook(blocknum, bs, size)
fp.close()
tfp.close()
del fp
del tfp
# raise exception if actual size does not match content-length header
if size >= 0 and read < size:
raise urllib.ContentTooShortError("retrieval incomplete: got only %i out "
"of %i bytes" % (read, size), result)
return result
# end code based on urllib.py
def prompt_user_passwd( self, host, realm):
# Keep track of authentication attempts, fail after the third one
self._auth_retry_counter += 1
if self._auth_retry_counter > 3:
raise AuthenticationError(_('Wrong username/password'))
if self.channel.auth_username or self.channel.auth_password:
logger.debug('Authenticating as "%s" to "%s" for realm "%s".',
self.channel.auth_username, host, realm)
return ( self.channel.auth_username, self.channel.auth_password )
return (None, None)
class DownloadQueueWorker(threading.Thread):
def __init__(self, queue, exit_callback, continue_check_callback, minimum_tasks):
threading.Thread.__init__(self)
self.queue = queue
self.exit_callback = exit_callback
self.continue_check_callback = continue_check_callback
# The minimum amount of tasks that should be downloaded by this worker
# before using the continue_check_callback to determine if it might
# continue accepting tasks. This can be used to forcefully start a
# download, even if a download limit is in effect.
self.minimum_tasks = minimum_tasks
def run(self):
logger.info('Starting new thread: %s', self.getName())
while True:
# Check if this thread is allowed to continue accepting tasks
# (But only after reducing minimum_tasks to zero - see above)
if self.minimum_tasks > 0:
self.minimum_tasks -= 1
elif not self.continue_check_callback(self):
return
try:
task = self.queue.pop()
logger.info('%s is processing: %s', self.getName(), task)
task.run()
task.recycle()
except IndexError, e:
logger.info('No more tasks for %s to carry out.', self.getName())
break
self.exit_callback(self)
class DownloadQueueManager(object):
def __init__(self, config):
self._config = config
self.tasks = collections.deque()
self.worker_threads_access = threading.RLock()
self.worker_threads = []
def __exit_callback(self, worker_thread):
with self.worker_threads_access:
self.worker_threads.remove(worker_thread)
def __continue_check_callback(self, worker_thread):
with self.worker_threads_access:
if len(self.worker_threads) > self._config.max_downloads and \
self._config.max_downloads_enabled:
self.worker_threads.remove(worker_thread)
return False
else:
return True
def spawn_threads(self, force_start=False):
"""Spawn new worker threads if necessary
If force_start is True, forcefully spawn a thread and
let it process at least one episodes, even if a download
limit is in effect at the moment.
"""
with self.worker_threads_access:
if not len(self.tasks):
return
if force_start or len(self.worker_threads) == 0 or \
len(self.worker_threads) < self._config.max_downloads or \
not self._config.max_downloads_enabled:
# We have to create a new thread here, there's work to do
logger.info('Starting new worker thread.')
# The new worker should process at least one task (the one
# that we want to forcefully start) if force_start is True.
if force_start:
minimum_tasks = 1
else:
minimum_tasks = 0
worker = DownloadQueueWorker(self.tasks, self.__exit_callback, \
self.__continue_check_callback, minimum_tasks)
self.worker_threads.append(worker)
worker.start()
def are_queued_or_active_tasks(self):
with self.worker_threads_access:
return len(self.worker_threads) > 0
def add_task(self, task, force_start=False):
"""Add a new task to the download queue
If force_start is True, ignore the download limit
and forcefully start the download right away.
"""
if task.status != DownloadTask.INIT:
# Remove the task from its current position in the
# download queue (if any) to avoid race conditions
# where two worker threads download the same file
try:
self.tasks.remove(task)
except ValueError, e:
pass
task.status = DownloadTask.QUEUED
if force_start:
# Add the task to be taken on next pop
self.tasks.append(task)
else:
# Add the task to the end of the queue
self.tasks.appendleft(task)
self.spawn_threads(force_start)
class DownloadTask(object):
"""An object representing the download task of an episode
You can create a new download task like this:
task = DownloadTask(episode, gpodder.config.Config(CONFIGFILE))
task.status = DownloadTask.QUEUED
task.run()
While the download is in progress, you can access its properties:
task.total_size # in bytes
task.progress # from 0.0 to 1.0
task.speed # in bytes per second
str(task) # name of the episode
task.status # current status
task.status_changed # True if the status has been changed (see below)
task.url # URL of the episode being downloaded
task.podcast_url # URL of the podcast this download belongs to
task.episode # Episode object of this task
You can cancel a running download task by setting its status:
task.status = DownloadTask.CANCELLED
The task will then abort as soon as possible (due to the nature
of downloading data, this can take a while when the Internet is
busy).
The "status_changed" attribute gets set to True everytime the
"status" attribute changes its value. After you get the value of
the "status_changed" attribute, it is always reset to False:
if task.status_changed:
new_status = task.status
# .. update the UI accordingly ..
Obviously, this also means that you must have at most *one*
place in your UI code where you check for status changes and
broadcast the status updates from there.
While the download is taking place and after the .run() method
has finished, you can get the final status to check if the download
was successful:
if task.status == DownloadTask.DONE:
# .. everything ok ..
elif task.status == DownloadTask.FAILED:
# .. an error happened, and the
# error_message attribute is set ..
print task.error_message
elif task.status == DownloadTask.PAUSED:
# .. user paused the download ..
elif task.status == DownloadTask.CANCELLED:
# .. user cancelled the download ..
The difference between cancelling and pausing a DownloadTask is
that the temporary file gets deleted when cancelling, but does
not get deleted when pausing.
Be sure to call .removed_from_list() on this task when removing
it from the UI, so that it can carry out any pending clean-up
actions (e.g. removing the temporary file when the task has not
finished successfully; i.e. task.status != DownloadTask.DONE).
The UI can call the method "notify_as_finished()" to determine if
this episode still has still to be shown as "finished" download
in a notification window. This will return True only the first time
it is called when the status is DONE. After returning True once,
it will always return False afterwards.
The same thing works for failed downloads ("notify_as_failed()").
"""
# Possible states this download task can be in
STATUS_MESSAGE = (_('Added'), _('Queued'), _('Downloading'),
_('Finished'), _('Failed'), _('Cancelled'), _('Paused'))
(INIT, QUEUED, DOWNLOADING, DONE, FAILED, CANCELLED, PAUSED) = range(7)
def __str__(self):
return self.__episode.title
def __get_status(self):
return self.__status
def __set_status(self, status):
if status != self.__status:
self.__status_changed = True
self.__status = status
status = property(fget=__get_status, fset=__set_status)
def __get_status_changed(self):
if self.__status_changed:
self.__status_changed = False
return True
else:
return False
status_changed = property(fget=__get_status_changed)
def __get_url(self):
return self.__episode.url
url = property(fget=__get_url)
def __get_podcast_url(self):
return self.__episode.channel.url
podcast_url = property(fget=__get_podcast_url)
def __get_episode(self):
return self.__episode
episode = property(fget=__get_episode)
def cancel(self):
if self.status in (self.DOWNLOADING, self.QUEUED):
self.status = self.CANCELLED
def removed_from_list(self):
if self.status != self.DONE:
util.delete_file(self.tempname)
def __init__(self, episode, config):
assert episode.download_task is None
self.__status = DownloadTask.INIT
self.__status_changed = True
self.__episode = episode
self._config = config
# Create the target filename and save it in the database
self.filename = self.__episode.local_filename(create=True)
self.tempname = self.filename + '.partial'
self.total_size = self.__episode.file_size
self.speed = 0.0
self.progress = 0.0
self.error_message = None
# Have we already shown this task in a notification?
self._notification_shown = False
# Variables for speed limit and speed calculation
self.__start_time = 0
self.__start_blocks = 0
self.__limit_rate_value = self._config.limit_rate_value
self.__limit_rate = self._config.limit_rate
# Callbacks
self._progress_updated = lambda x: None
# If the tempname already exists, set progress accordingly
if os.path.exists(self.tempname):
try:
already_downloaded = os.path.getsize(self.tempname)
if self.total_size > 0:
self.progress = max(0.0, min(1.0, float(already_downloaded)/self.total_size))
except OSError, os_error:
logger.error('Cannot get size for %s', os_error)
else:
# "touch self.tempname", so we also get partial
# files for resuming when the file is queued
open(self.tempname, 'w').close()
# Store a reference to this task in the episode
episode.download_task = self
def notify_as_finished(self):
if self.status == DownloadTask.DONE:
if self._notification_shown:
return False
else:
self._notification_shown = True
return True
return False
def notify_as_failed(self):
if self.status == DownloadTask.FAILED:
if self._notification_shown:
return False
else:
self._notification_shown = True
return True
return False
def add_progress_callback(self, callback):
self._progress_updated = callback
def status_updated(self, count, blockSize, totalSize):
# We see a different "total size" while downloading,
# so correct the total size variable in the thread
if totalSize != self.total_size and totalSize > 0:
self.total_size = float(totalSize)
if self.__episode.file_size != self.total_size:
logger.debug('Updating file size of %s to %s',
self.filename, self.total_size)
self.__episode.file_size = self.total_size
self.__episode.save()
if self.total_size > 0:
self.progress = max(0.0, min(1.0, float(count*blockSize)/self.total_size))
self._progress_updated(self.progress)
self.calculate_speed(count, blockSize)
if self.status == DownloadTask.CANCELLED:
raise DownloadCancelledException()
if self.status == DownloadTask.PAUSED:
raise DownloadCancelledException()
def calculate_speed(self, count, blockSize):
if count % 5 == 0:
now = time.time()
if self.__start_time > 0:
# Has rate limiting been enabled or disabled?
if self.__limit_rate != self._config.limit_rate:
# If it has been enabled then reset base time and block count
if self._config.limit_rate:
self.__start_time = now
self.__start_blocks = count
self.__limit_rate = self._config.limit_rate
# Has the rate been changed and are we currently limiting?
if self.__limit_rate_value != self._config.limit_rate_value and self.__limit_rate:
self.__start_time = now
self.__start_blocks = count
self.__limit_rate_value = self._config.limit_rate_value
passed = now - self.__start_time
if passed > 0:
speed = ((count-self.__start_blocks)*blockSize)/passed
else:
speed = 0
else:
self.__start_time = now
self.__start_blocks = count
passed = now - self.__start_time
speed = count*blockSize
self.speed = float(speed)
if self._config.limit_rate and speed > self._config.limit_rate_value:
# calculate the time that should have passed to reach
# the desired download rate and wait if necessary
should_have_passed = float((count-self.__start_blocks)*blockSize)/(self._config.limit_rate_value*1024.0)
if should_have_passed > passed:
# sleep a maximum of 10 seconds to not cause time-outs
delay = min(10.0, float(should_have_passed-passed))
time.sleep(delay)
def recycle(self):
self.episode.download_task = None
def run(self):
# Speed calculation (re-)starts here
self.__start_time = 0
self.__start_blocks = 0
# If the download has already been cancelled, skip it
if self.status == DownloadTask.CANCELLED:
util.delete_file(self.tempname)
self.progress = 0.0
self.speed = 0.0
return False
# We only start this download if its status is "queued"
if self.status != DownloadTask.QUEUED:
return False
# We are downloading this file right now
self.status = DownloadTask.DOWNLOADING
self._notification_shown = False
try:
# Resolve URL and start downloading the episode
url = youtube.get_real_download_url(self.__episode.url, \
self._config.youtube_preferred_fmt_id)
url = vimeo.get_real_download_url(url)
downloader = DownloadURLOpener(self.__episode.channel)
# HTTP Status codes for which we retry the download
retry_codes = (408, 418, 504, 598, 599)
max_retries = max(0, self._config.auto.retries)
# Retry the download on timeout (bug 1013)
for retry in range(max_retries + 1):
if retry > 0:
logger.info('Retrying download of %s (%d)', url, retry)
time.sleep(1)
try:
headers, real_url = downloader.retrieve_resume(url,
self.tempname, reporthook=self.status_updated)
# If we arrive here, the download was successful
break
except urllib.ContentTooShortError, ctse:
if retry < max_retries:
logger.info('Content too short: %s - will retry.',
url)
continue
raise
except socket.timeout, tmout:
if retry < max_retries:
logger.info('Socket timeout: %s - will retry.', url)
continue
raise
except gPodderDownloadHTTPError, http:
if retry < max_retries and http.error_code in retry_codes:
logger.info('HTTP error %d: %s - will retry.',
http.error_code, url)
continue
raise
new_mimetype = headers.get('content-type', self.__episode.mime_type)
old_mimetype = self.__episode.mime_type
_basename, ext = os.path.splitext(self.filename)
if new_mimetype != old_mimetype or util.wrong_extension(ext):
logger.info('Updating mime type: %s => %s', old_mimetype, new_mimetype)
old_extension = self.__episode.extension()
self.__episode.mime_type = new_mimetype
new_extension = self.__episode.extension()
# If the desired filename extension changed due to the new
# mimetype, we force an update of the local filename to fix the
# extension.
if old_extension != new_extension or util.wrong_extension(ext):
self.filename = self.__episode.local_filename(create=True, force_update=True)
# In some cases, the redirect of a URL causes the real filename to
# be revealed in the final URL (e.g. http://gpodder.org/bug/1423)
if real_url != url and not util.is_known_redirecter(real_url):
realname, realext = util.filename_from_url(real_url)
# Only update from redirect if the redirected-to filename has
# a proper extension (this is needed for e.g. YouTube)
if not util.wrong_extension(realext):
real_filename = ''.join((realname, realext))
self.filename = self.__episode.local_filename(create=True,
force_update=True, template=real_filename)
logger.info('Download was redirected (%s). New filename: %s',
real_url, os.path.basename(self.filename))
# Look at the Content-disposition header; use if if available
disposition_filename = get_header_param(headers, \
'filename', 'content-disposition')
# Some servers do send the content-disposition header, but provide
# an empty filename, resulting in an empty string here (bug 1440)
if disposition_filename is not None and disposition_filename != '':
# The server specifies a download filename - try to use it
disposition_filename = os.path.basename(disposition_filename)
self.filename = self.__episode.local_filename(create=True, \
force_update=True, template=disposition_filename)
new_mimetype, encoding = mimetypes.guess_type(self.filename)
if new_mimetype is not None:
logger.info('Using content-disposition mimetype: %s',
new_mimetype)
self.__episode.set_mimetype(new_mimetype, commit=True)
# Re-evaluate filename and tempname to take care of podcast renames
# while downloads are running (which will change both file names)
self.filename = self.__episode.local_filename(create=False)
self.tempname = os.path.join(os.path.dirname(self.filename),
os.path.basename(self.tempname))
shutil.move(self.tempname, self.filename)
# Model- and database-related updates after a download has finished
self.__episode.on_downloaded(self.filename)
except DownloadCancelledException:
logger.info('Download has been cancelled/paused: %s', self)
if self.status == DownloadTask.CANCELLED:
util.delete_file(self.tempname)
self.progress = 0.0
self.speed = 0.0
except urllib.ContentTooShortError, ctse:
self.status = DownloadTask.FAILED
self.error_message = _('Missing content from server')
except IOError, ioe:
logger.error('%s while downloading "%s": %s', ioe.strerror,
self.__episode.title, ioe.filename, exc_info=True)
self.status = DownloadTask.FAILED
d = {'error': ioe.strerror, 'filename': ioe.filename}
self.error_message = _('I/O Error: %(error)s: %(filename)s') % d
except gPodderDownloadHTTPError, gdhe:
logger.error('HTTP %s while downloading "%s": %s',
gdhe.error_code, self.__episode.title, gdhe.error_message,
exc_info=True)
self.status = DownloadTask.FAILED
d = {'code': gdhe.error_code, 'message': gdhe.error_message}
self.error_message = _('HTTP Error %(code)s: %(message)s') % d
except Exception, e:
self.status = DownloadTask.FAILED
logger.error('Download failed: %s', str(e), exc_info=True)
self.error_message = _('Error: %s') % (str(e),)
if self.status == DownloadTask.DOWNLOADING:
# Everything went well - we're done
self.status = DownloadTask.DONE
if self.total_size <= 0:
self.total_size = util.calculate_size(self.filename)
logger.info('Total size updated to %d', self.total_size)
self.progress = 1.0
gpodder.user_extensions.on_episode_downloaded(self.__episode)
return True
self.speed = 0.0
# We finished, but not successfully (at least not really)
return False
gpodder-3.1.2/src/gpodder/core.py 0000664 0001750 0001750 00000003777 11751103635 016310 0 ustar thp thp 0000000 0000000 # -*- coding: utf-8 -*-
#
# gPodder - A media aggregator and podcast client
# Copyright (c) 2005-2012 Thomas Perl and the gPodder Team
#
# gPodder is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# gPodder is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see ; 2011-02-06
import gpodder
from gpodder import util
from gpodder import config
from gpodder import dbsqlite
from gpodder import extensions
from gpodder import model
class Core(object):
def __init__(self,
config_class=config.Config,
database_class=dbsqlite.Database,
model_class=model.Model):
# Initialize the gPodder home directory
util.make_directory(gpodder.home)
# Open the database and configuration file
self.db = database_class(gpodder.database_file)
self.model = model_class(self.db)
self.config = config_class(gpodder.config_file)
# Load extension modules and install the extension manager
gpodder.user_extensions = extensions.ExtensionManager(self)
# Load installed/configured plugins
gpodder.load_plugins()
# Update the current device in the configuration
self.config.mygpo.device.type = util.detect_device_type()
def shutdown(self):
# Notify all extensions that we are being shut down
gpodder.user_extensions.shutdown()
# Close the database and store outstanding changes
self.db.close()
gpodder-3.1.2/tools/ 0000775 0001750 0001750 00000000000 11760761026 013721 5 ustar thp thp 0000000 0000000 gpodder-3.1.2/tools/i18n/ 0000775 0001750 0001750 00000000000 11760761026 014500 5 ustar thp thp 0000000 0000000 gpodder-3.1.2/tools/i18n/summary.py 0000664 0001750 0001750 00000003717 11751103635 016553 0 ustar thp thp 0000000 0000000 #!/usr/bin/python
# summary.py - Text-based visual translation completeness summary
# Thomas Perl , 2009-01-03
#
# Usage: make statistics | python summary.py
#
import sys
import re
import math
import glob
import os
import subprocess
width = 40
class Language(object):
def __init__(self, language, translated, fuzzy, untranslated):
self.language = language
self.translated = int(translated)
self.fuzzy = int(fuzzy)
self.untranslated = int(untranslated)
def get_translated_ratio(self):
return float(self.translated)/float(self.translated+self.fuzzy+self.untranslated)
def get_fuzzy_ratio(self):
return float(self.fuzzy)/float(self.translated+self.fuzzy+self.untranslated)
def get_untranslated_ratio(self):
return float(self.untranslated)/float(self.translated+self.fuzzy+self.untranslated)
def __cmp__(self, other):
return cmp(self.get_translated_ratio(), other.get_translated_ratio())
languages = []
COUNTS_RE = '((\d+) translated message[s]?)?(, (\d+) fuzzy translation[s]?)?(, (\d+) untranslated message[s]?)?\.'
po_folder = os.path.join(os.path.dirname(__file__), '..', '..', 'po')
for filename in glob.glob(os.path.join(po_folder, '*.po')):
language, _ = os.path.splitext(os.path.basename(filename))
msgfmt = subprocess.Popen(['msgfmt', '--statistics', filename],
stderr=subprocess.PIPE)
_, stderr = msgfmt.communicate()
match = re.match(COUNTS_RE, stderr).groups()
languages.append(Language(language, match[1] or '0', match[3] or '0', match[5] or '0'))
print ''
for language in sorted(languages):
tc = '#'*(int(math.floor(width*language.get_translated_ratio())))
fc = '~'*(int(math.floor(width*language.get_fuzzy_ratio())))
uc = ' '*(width-len(tc)-len(fc))
print ' %5s [%s%s%s] -- %3.0f %% translated' % (language.language, tc, fc, uc, language.get_translated_ratio()*100)
print """
Total translations: %s
""" % (len(languages))
gpodder-3.1.2/tools/i18n/validate.sh 0000664 0001750 0001750 00000000217 11751103635 016621 0 ustar thp thp 0000000 0000000 #!/bin/sh
set -e
for translation in `dirname $0`/../../po/*.po; do
echo "Checking: $translation"
msgfmt --check "$translation"
done
gpodder-3.1.2/tools/i18n/merge-from-transifex.sh 0000664 0001750 0001750 00000003403 11760760347 021102 0 ustar thp thp 0000000 0000000 #!/bin/sh
#
# merge-from-transifex.sh
# Fix problems with the "tx" command line client by forcing a download of
# all translations and then using the downloaded translations as a compendium
# in msgmerge to update the .po file without destroying existing content.
# ..which I think is what the "tx" client should do all along?! :/
#
# Thomas Perl ; 2012-01-21
#
set -e
MERGE_DIR=_tmp_merge_dir
MESSAGES_POT=messages.pot
if [ "`which tx`" = "" ]; then
echo "The Transifex client 'tx' was not found."
echo "If you are on Debian: apt-get install transifex-client"
exit 1
fi
if [ "`which git`" = "" ]; then
echo "Please install 'git'. We need it to revert changes by 'tx' ;)"
exit 1
fi
cd `dirname $0`/../../po/
if git status --porcelain | grep -q '^ M po'; then
echo "Uncommitted changes in po/ - cannot continue."
echo "Please revert or commit current changes before continuing."
exit 1
fi
rm *.po
if [ -d "$MERGE_DIR" ]; then
echo "The directory $MERGE_DIR still exists. Please remove it."
exit 1
fi
# First, pull translations from Transifex, overwriting existing .po files
echo "Downloading UPDATED translations from Transifex..."
tx pull --force --all
FILES=*.po
echo "Moving files to merge directory..."
mkdir "$MERGE_DIR"
mv -v $FILES "$MERGE_DIR"
echo "Restoring original .po files from Git..."
git checkout .
echo "Merging translations..."
for POFILE in $FILES; do
echo -n "Merging $POFILE"
msgmerge --compendium="$MERGE_DIR/$POFILE" \
"$POFILE" "$MESSAGES_POT" --output-file="$POFILE"
done
echo "Removing merge directory..."
rm -rf "$MERGE_DIR"
echo "Running validation script to check for errors..."
sh ../tools/i18n/validate.sh
echo "All done. Please review changes and stage them for commmit."
gpodder-3.1.2/tools/generate-ubuntu-source.sh 0000664 0001750 0001750 00000001750 11751103635 020664 0 ustar thp thp 0000000 0000000 #!/bin/sh
# Generate Ubuntu derivations of a normal Debian package source
# 2009-09-23 Thomas Perl
SOURCEFILE=$1
VERSION=`echo $SOURCEFILE | sed -e 's/[^_]*_\(.*\)-[^-]*\.dsc/\1/g'`
FOLDER=`echo $SOURCEFILE | sed -e 's/\([^_]*\)_.*/\1/g'`-${VERSION}
# See https://wiki.ubuntu.com/DevelopmentCodeNames
UBUNTU_RELEASES="karmic lucid maverick natty oneiric precise"
echo "SOURCEFILE = $SOURCEFILE"
echo "VERSION = $VERSION"
echo "FOLDER = $FOLDER"
for DIST in $UBUNTU_RELEASES; do
dpkg-source -x $SOURCEFILE
cd $FOLDER
VERSION=`dpkg-parsechangelog | awk '/^Version: / {print $2}'`
NEW_VERSION=${VERSION}~${DIST}0
dch --distribution ${DIST} \
--force-bad-version --preserve \
--newversion ${NEW_VERSION} "Automatic build for ${DIST}"
dpkg-buildpackage -S -sa -us -uc
cd ..
rm -rf $FOLDER
done
debsign *.changes
echo
echo " If signing (as oppposed to singing) went well, do this now:"
echo
echo " dput ppa:thp/gpodder *.changes"
echo
gpodder-3.1.2/tools/make-help.txt 0000664 0001750 0001750 00000002250 11751103635 016320 0 ustar thp thp 0000000 0000000
gPodder' makefile commands
----------------------- ---- --- -- - -
For developers
make unittest Run doctests and unittests
make manpage Update generated manual pages from source
make messages Update translation files in po/ from source
make headlink Print commit URL for the current Git head
make clean Remove generated and compiled files
make distclean "make clean" + remove dist/
For maintainers
make releasetest Run some basic release sanity checks
make release Create the source tarball in dist/
For users/packagers
make install Install gPodder into $DESTDIR/$PREFIX
----------------------- ---- --- -- - -
make install supports the following environment variables:
PREFIX The installation prefix (default: /usr)
DESTDIR The installation destination (default: /)
GPODDER_INSTALL_UIS A space-separated list of UIs to install
LINGUAS A space-separated list of translations
See the README file for more information on how to install gPodder.
gpodder-3.1.2/tools/draft/ 0000775 0001750 0001750 00000000000 11760761026 015021 5 ustar thp thp 0000000 0000000 gpodder-3.1.2/tools/draft/README 0000664 0001750 0001750 00000000065 11751103635 015676 0 ustar thp thp 0000000 0000000 gPodder "tres" draft implementation / prototype code
gpodder-3.1.2/tools/draft/directory-ui/ 0000775 0001750 0001750 00000000000 11760761026 017440 5 ustar thp thp 0000000 0000000 gpodder-3.1.2/tools/draft/directory-ui/search_soundcloud.png 0000664 0001750 0001750 00000000632 11751103635 023647 0 ustar thp thp 0000000 0000000 PNG
IHDR h6 sRGB pHYs tIME
.o; ,IDAT(ϕJAEϛK⢅l I h)bA;B, ?//NHc)1.+ٙ}A{ߝuj
>a |CRkK$PAy/` f , T>d>zLoOU/N Fĉ:1sM`8h~y(NF
ŵ YXa\Rͣzuiv_w)wΙ}ښNqhV-RKgJt0Y=\IzHF+HDHF;f!ޓiz~
Ȓ|&?_"ɛik IENDB` gpodder-3.1.2/tools/draft/directory-ui/tagcloud.py 0000664 0001750 0001750 00000007770 11751103635 021623 0 ustar thp thp 0000000 0000000
import gtk
import gobject
import cgi
tags = (
('Electronica', 5),
('Reggae', 5),
('Electro', 20),
('Detroit Techno', 4),
('Funk', 14),
('Jazz', 4),
('Minimal', 20),
('Soulful Drum and Bass', 6),
('Dub', 7),
('Drum and Bass', 23),
('Deep Techno', 7),
('Deephouse', 27),
('Soulful', 9),
('Minimal Techno', 30),
('Downtempo', 17),
('House', 29),
('Dubstep', 14),
('Techno', 32),
('Electrotech', 8),
('Techhouse', 28),
('Disco', 15),
('Downbeat', 28),
('Electrohouse', 14),
('Hiphop', 25),
('Trance', 6),
('Freestyle', 14),
('Funky House', 3),
('Minimal House', 4),
('Nu Jazz', 11),
('Chill-Out', 6),
('Breaks', 10),
('UK Garage', 4),
('Soul', 10),
('Progressive House', 3),
('Lounge', 6),
)
class TagCloud(gtk.Layout):
__gsignals__ = {
'selected': (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE,
(gobject.TYPE_STRING,))
}
def __init__(self, tags, min_size=20, max_size=36):
self.__gobject_init__()
gtk.Layout.__init__(self)
self._tags = tags
self._min_size = min_size
self._max_size = max_size
self._min_weight = min(weight for tag, weight in self._tags)
self._max_weight = max(weight for tag, weight in self._tags)
self._size = 0, 0
self._alloc_id = self.connect('size-allocate', self._on_size_allocate)
self._init_tags()
self._in_relayout = False
def _on_size_allocate(self, widget, allocation):
self._size = (allocation.width, allocation.height)
if not self._in_relayout:
self.relayout()
def _init_tags(self):
for tag, weight in self._tags:
label = gtk.Label()
markup = '%s ' % (1000*self._scale(weight), cgi.escape(tag))
label.set_markup(markup)
button = gtk.ToolButton(label)
button.connect('clicked', lambda b: self.emit('selected', tag))
self.put(button, 1, 1)
def _scale(self, weight):
weight_range = float(self._max_weight-self._min_weight)
ratio = float(weight-self._min_weight)/weight_range
return int(self._min_size + (self._max_size-self._min_size)*ratio)
def relayout(self):
self._in_relayout = True
x, y, max_h = 0, 0, 0
current_row = []
pw, ph = self._size
def fixup_row(widgets, x, y, max_h):
residue = (pw - x)
x = int(residue/2)
for widget in widgets:
cw, ch = widget.size_request()
self.move(widget, x, y+max(0, int((max_h-ch)/2)))
x += cw + 10
for child in self.get_children():
w, h = child.size_request()
if x + w > pw:
fixup_row(current_row, x, y, max_h)
y += max_h + 10
max_h, x = 0, 0
current_row = []
self.move(child, x, y)
x += w + 10
max_h = max(max_h, h)
current_row.append(child)
fixup_row(current_row, x, y, max_h)
self.set_size(pw, y+max_h)
def unrelayout():
self._in_relayout = False
return False
gobject.idle_add(unrelayout)
gobject.type_register(TagCloud)
if __name__ == '__main__':
l = TagCloud(tags)
try:
import hildon
w = hildon.StackableWindow()
sw = hildon.PannableArea()
except:
w = gtk.Window()
w.set_default_size(600, 300)
sw = gtk.ScrolledWindow()
sw.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
w.set_title('Tag cloud Demo')
w.add(sw)
sw.add(l)
def on_tag_selected(cloud, tag):
print 'tag selected:', tag
l.connect('selected', on_tag_selected)
w.show_all()
w.connect('destroy', gtk.main_quit)
gtk.main()
gpodder-3.1.2/tools/draft/directory-ui/search_gpodder.png 0000664 0001750 0001750 00000001715 11751103635 023117 0 ustar thp thp 0000000 0000000 PNG
IHDR a sRGB bKGD pHYs tIME
ł MIDAT8mO[u )2
=Af!Bڲ@f ,ad AMc4܀ $ĭj6 څ%MdV}@{>s
]9B ՀCȦX~?z&A57>X[UUUxsm\.LMM] }`&ry~\-] $I5M+nEËd@ t:o~(G{Ⱥ&(( _ G%vDZ;+壨v"N[s>}vkkkx< b+ 'bZ t9 2g UDǨw8`^MT``+c*q9?\k/0e" "?0ͧ$ =:F?w5%)jaoa3r@0ͥN ζNC߱~l4r҈Bt
JTQ~ &>}BJ!u5 MqdM@ IENDB` gpodder-3.1.2/tools/draft/directory-ui/directory_tags.png 0000664 0001750 0001750 00000001347 11751103635 023171 0 ustar thp thp 0000000 0000000 PNG
IHDR a sBIT|d pHYs
B(x tEXtSoftware www.inkscape.org< dIDAT8KHQANciCZD,Zzs!n\
eXE2j4I#lF{{[Ҍx 8D)TO{V_Y౯dEzß ̦Fn\ݳ՚e$ }`B Ny |OVѓ[l1:9^Y* ANj] y[r6ەcj,l5@#(*.98x].ؓ[ nCxx@qlť0 Nwlx.91)8)jo
!No 7Qҗik71cҊ!3ctR
֜y@-ik2Kk^X :s`TI&%y`<<<0${q`, vpAg \ƭ IDAT8ˍ]lSu磧[MVMٔhDM(!|D/w:
W%HbG:62
ڳn뺶ӿ8I/x'o\} ** H̶~JԬy~oS$yl
?Gq叭w_rdcnMֶU^w^9*@Ol pm "Pܫ|\ynnxO_cI4OjhP@xjmt
84J ]/獌] tȅwaSZm#_z= 'pנ (-sEKϹ54)0``L"u&s+>Ü*gO{+G傒e%ʔD|9=pʑ wM*%%}n
q!Q9OO7?vqw]$"r s~ѪrPP~Cke3ӡ#E[ + @)̙TbGYX X6b0Z!PH~ 4#쵭;~so"ΝVfJEk뉮 :.be32zvz/q&`R80ov%S0Ӌ `߳PQgp
R]ar J7 "zTXtSoftware xsLOJUMLO
JML /Ԯ M IENDB` gpodder-3.1.2/tools/draft/directory-ui/directory_example.png 0000664 0001750 0001750 00000001624 11751103635 023664 0 ustar thp thp 0000000 0000000 PNG
IHDR a sBIT|d pHYs
B(x tEXtSoftware www.inkscape.org< tEXtTitle Optical Drive>g IDAT8}]L[@|:0Ó_ك. &}11ΨaO5 Ag`
2VK-- M>Dm^
ttv8Ҡr1,/ >ܰH&2>$9>RA67HLo-heI͢HttvɘmKˎ`m6RׯoeeeN ǩ>m[7oޠXGT^xw
k,--kU6q N ?n2 ʘU˷45bk$&pʎ;o ,}7uuI{o/e L>M4'b6m[xu
\.D dؕM3 kx;T*Y q }|PBUT`>e?{3G %9) 0&gRQվ<ɶe1%~?8N?Z0OWƯvi0 000 K(KwH:v(bY{sEn,̻n՝ĆsalC7t!Cc !V@HU&2/.7 IENDB` gpodder-3.1.2/tools/draft/directory-ui/search_miro.png 0000664 0001750 0001750 00000001376 11751103635 022444 0 ustar thp thp 0000000 0000000 PNG
IHDR a sRGB bKGD pHYs tIME
A. ~IDAT8˭KkqIfbjV
VŪqVvѝ [A b .[
>>DQRmՐ64d_UTnl.98 Gu4\M{4XZ U ==K
r:P-X+T^<=>;W A (?b J ܝm99R-^#JhίCD^Hp~U6w 9\dJm}4FD0a I q&//<XtF-E* );YI;Nȁ0~гC^? aBN 57 $^Dr⓳ sr6>4~nl/*5px q 0SlnPE ?Gi~^3hM~9&W> ,` ʑ,x?R
V`X
B,WH9 TT5īTr4 TЯV ܝgd [2Gj~o
O.r:& wrC{= 5X,#UBz; _ P(/ p )
y
/S(A y_7*wuUutQXEo? 7?Nz7ܟq6Пq p=ф{t 3VϸLûGI!wy947q5Wk@û2,dZۧthm?;,VqYZۧ#Ol8p$ ,"v Aի9~6O{Oןu\$ V\ }lwڔXkt1AO w96KimϦ.܃Mk荗y~ ivw/:@FoOpn|]dB]hB]l4?.6ПqMϸ&O]`B]5oI:ϙ~o?f3
xLmm `#cb=`
(3`?տbjuϸgݙ@ _C_pON.u:k@5`-H9{ŕ`(@ X
bB^,. w\6oU/Pmw;}iV
̝)!_U-ݡ~&&j
>%'TԼO(%?+,WR&߽WDk_/֩m5!_5"5C]nX3ce 5)UKPVUl5)WniJ)'d HmkBF )3 )>mkTSx}isF6vv<6%Y /؈pUf&mGwtxEJ /U
@ D7
̧2
7+E$tuvrWg WN8 /"Oϡx{jXҿ~l\\98Sgl;9wfgGp
[gl:PYF)VuDuoϯE?;WۇW 8j{K8>}>os$+ ];ئo ODቨd,9ó-]v̱GpaeglF ; g~]o T{ƀҹZ5a?9: &t=m>omz!Dbc O |q5|<#4q!_ Tc0c1N4 oN<^hdOg
J:k`̧ PspMί
E)_7Λ`2i̳}f1H ˉK/Kcޠ. 7PKޒ k N*
? [K +03TTz"BTpB6EHnne@GP:%}VXrzvٟ$F\pYNdtV
~ۂ|h gh͛HZѽċY)bG*̛sg{y0@T !%Kb\3'@f&$qDƩ7&ܒ"+è1 ExiΨ
'H㻐 ތ 'M<\b!03'qIk on{ p;LRn#g_i.m-s 6cPPb
Z@+,?L) 3oǙ2q^#@\4E(Eb0#_c4@" DR*^(5/g0l'`頒ߛXVyjIƌ&ȑ:ӈ^=d/tRbmYb-U(}^R{SpכCʼnN'`Vqn 7\abx %3e&W@
h\+q-yZBr5\:2
B@(eS&z}+ % @&iR0ܤez צs(?-6Xׁ 4olr厃tgcU,PY>%^D b+ ;)mI Y7 Rc$]͈On;{R< V436+HZWV H&ݚ~}IBO2I kn]s\2;0 ,QOc\2=s0V]MnNh&-P(MBKfaIx,b t(`# Cxtb-_(b7{OHl 1)MY@5K3 KPgȯeHL5&5Y,I`gQA3pQ}HLÑIG49.D&~on_Z+ A"ё("M8L>o Kʩf ']N7[_'0CgV[7ǖY LeyYnǰߨ%ZMS2{$T_~S8Md @ @#I;͖F8C5|*+ssv-I_'o}^5tE&k2[pQȰvf1Y1K _W3T扅c)_qnAKhi:]eq¾3{7n37@NqQLTS w,$頱a1eq]jcteR$5|rѱ2mb61 cE# H 隑 ǔ^ٚYv7IPR m&U!(r5
)_ye%NA%n CPp °TKƫIP'L.Ր |AKN,W25I.wM|[j/ghKx x!k0L1 (H48 ѩש5ׄafOba:Df# Et|;S5s#;^
b M8!rzm}3[]X ' q>fHN֑RR}63E
6%fNKCHtvJLTw`JUYS5MO$o-y&tGT$a6qI.x_Mpzq 9Gt{(ܬta22dw
ٓ̃yA1(l7a ۮ90U,VSG.O]\ٜhPBx}գ:äԛN&kĥʗz4l1W7a}04;}C ?\`a'WI/v-KgCcA3/sI/Fc uFfi9P / X7!n< >"yqdJk3.u>U%q6)SCJ 6x5ѯ[`l1 QblHM>t". 3C wi I/R
Ҋv^207siN'Q*[.e]
oRmE.iz2G: Kxm(%3IZRY _
7
,I,cJȝ+H$#ZxE:,@.i`ԧKF#Q/gxX
(NtH#6KjieI.q%8e=3#R/%grN}3#`[ hGT >
,"`s,s_kYEZꆫ|rhF*% yܚh1o!ʮ9D'BNM$(D\ @_Fk:AZv|!9\[$maלZ\s-veiՄ.e?=Zq!Vi
ɉ)ZFz|;iEBZQ'6" T*ӊ iŝHS)]NTS)+Nkh'D2dD KYnbEĺ6:l;9̈́fi# Vf@y^Nfs!y'6w_sQIk!& \(ղ5e$[j {:} ZKS1OkuL/ LAt7OkNjm3#ڢG;mZ:WU+U?^k_#}FS"ר&݁ Ѧfm(-s&jw8~_P,mL<+;UijX^3{ݹr"*
?Ý '<7wp.~2 JJku# s3l WrwlҥB^v楷W{"'0مZ{, iOl~DW^} vzDUכ-oj7MhH?4L *{77/3ZH3Cڔy)_|N>Uz3?i:c ݧl/2V0/ܿʏ,
,)__R1kxL5 +wwq9Nv{O^Ԉ1/ Ao(06IgLwY_O+VjyFviH ? ),(VJx +^}
t
Y[82)\$ mjT9ܢōu
ggiZm }jSmczH}Ü}ƞa!վv=Qs v(3lDIΧ
`pNw 1t]VӜOZL&KᐗJH{/-[b8@9S9GLLܾ zSCY!kU~;z߁ M
|P }%y/Dmi*֖6YK 6?
I FqA^OB*p997Wwd ?6 zK/2 jf-}DcZ 9n cgnJ{Hľ<˝ZTt<[o czC"F@~!^LȎт?zɝEuƼr`T~3я'gZ^~?ؼkN;?ȺlxIfѬ'Ҿ?Om9ͅLW;aI\fK'.GP֖g&x \fl]VJtY.+qYEǟ8;}qSfQ1ނqV7zTb }ZEP9 ], 0HՇNhvxϝ=;iur3n{N
W/4_W[&.igQ'?%K< 4SHHRƿ>YÌv wߎdyꯔU)"H ?_*]`(jH-cn=9$S1i6 hK҅9">vGn䷯ 5̯uʻ祶&Mx|n@ 2@X9|ؔ #)q֔8ee - kph(V }RoiOGlsh6hB=~w!/iu\FrcOOh5'j-'D( C+B>M+l?'z]YO/gmg;gfOx*ii!.cʹ8}>akyCaS:X±5 ]4^ WíW;W˥KVM[
[B5?o|ew>,W9 vt _qvr~VQ.Dپ8aurJ4 Hta8nj_ OC}0g0gh9pr6VgW 0< #H@ 8譭 էY}a+uW *X|=!7x wm`H AGKq}6ƋW^~0>C_ $!^3q = 2rퟜ\o]&BG?:еpщ 9_ώ7 %ٿS^$=米 ?HCCWґ$smAS%*(c6bA`lǒ(φژꀵnSJ\%!ȗ큲(rȫo"ׯ[ ;c@JZ
R{pkpyM*
Xmpr+rt6V\.]Ѣ_!] a;)c.cGc]ԉ JܕuX[}]F%!;pثx0* 'h1AYT$cv*'bX⫵("?jy @1I0`ZK0jAsZ"*Ͳ3I삠a.oԓ!5ÇGE8
"GU?5ka̱y?fJt#qCР.s møZњJ_cTע.o
:`e~jk1
<0Ĕ4@>.wZCu
s`ad1h9%F}-qiӲPRM6'TS NE϶C.lmta듂<]d0.j}]O6g Zw ,cՍ:3R/[{("EjQ3%sk{z~2Β C/\|gO7 e0/CJL
aRe }%M]%@HVK,0l+MB r oE2Mup^Ș'͠1$4"HW`.z^40ﺬqm43gA*E9Hz@3jezH::I/aM=$]R&IhZ߀}
L IS`ZIS I%)qbL\mPK~Z')(t&,l
W{ ZTMjcxJ4iMضdJ`k؆t}WflZ
uY'=? ?#{0aϗY̨#Ō!l|3C%iI\SL2EċE52 e~O
9,GK S\ ²ez>V[5]؋(¬P Xky~V,?˘6͔ʵUđ~ J\?Cj ̈8 q징0QxWǘYh!ûz.L !4w
Ɉor#1.z:4 s-:W )s2~AdSضCٓ-2 /L9Cl:aC! r;P.ZrZY%%^֣/?bk. "#y%{O&T-n37DXA B#Vd*T9-"9wp:)iE5{byb= &~}&nW^6\r | aBC7ĘV}19E .=, `"J!m2z\eyݰr] sHEH Y]q P(Uʿ~ 3(IV=3ٺkKPY <,jF_L{q ْ)&[YTC5Q
W,fT7恙jsFO!GTarTH4W sΘrjI;U\V2wYqA]9:
j5ԢK,i)xEKEZ,B.ux "jQ q}u2f10u]DzKܰx}%IQ@^}d l3& D*OkQS:n;<{ԩiߐ1Y
ׅnNR7=KSuQ|V(ْF cM-'Klo;Վ BT{>~r FA;zG'Ww Am TC!-i< ucۨڞ`ۨVe<] ,.F ųAjfa,T٤Ǣq]5j`2Yi
z]k ǟw@750K^)1+v4>z7
Vg ,HU(ڎ 8,:]]tjpۨ4w;IymRWm,YH ݐUJ Ph v5,[3*Ѝ:bV *Y#5cR
("B6cRZ%B#eη刊Q{̍[B5⎨8ېht4Y@1az9cP`u֊
1h#>
rmxAqmS/A,zU+ ~K2s\ԯAB@'3TDjbr[G6Tv@PS>l-Lf+e3ԧU[+ oPSu8lͰjޏ-#1ϙ}6x6&_ö|,)^MW_Vhh7꿿 0x0ãqCwpG#ba A ņΎ_%o۔o,M-}?o!{wަ JިCFwf
9]WA\\Lf[xilϣTs 1H QlH اEt (SAZ_Y X
mkBT W x흍8 FSHI!)$FRHnw HY x3ꇤ saaaaxIǏ 'U{o_ھgW9 o'GW
{>~Jlo߾)*/N\ϱov[iZ_ձaJΝ/:6O- 92b?Tlk%?_21B sY5>:> c=1Ow y^- ڶ,Xz usM#גU]>H_yYv!ۉ_mi Rus ]Xm _g)YY)m]y,m z1aaaxEߓGקo/Y \k6xjgH|yu.\aæM&wk#ϐ$?]Mo\Ⱦ,/ڥ Q@~6 s?)}, l gX #vQg Bٙ^uのuhm?}{].~}v_J;xogJY]@.)oqC?}>@Xߘ'- (W? źvƔOʙRv[K?[A}?-wmՑ}g\=c }M ggg DŽ-B^k_g?F? v0||؎=ǧHPgs/h ؑI
t~{n^}ZyD5XWvO )"c0 vY Z|~_%/,p\ɹyΰZ/;/xs_9? Pܯ5ݻ\[y|č8g ʱL{? 0 0 _k3>z_\S |<)b|7aaaxn.t a?l^Cvkؽ#~e)3<3^kdlc&jK+o"e<.ʞ`^(3zu
l+6v<ï
k7]/lc[`On} G뎱zt^v2)?;Wmr5 oc Iz?Ozx{&!ez."ѯ
1Gg{+ҏ lw<=}GݽFƨ^) zI pG K ֜{{e G12ۭqiumf>.}~a? 0 0 [u+7Svq֭y΅
?ނ}XwŶv?ߩDZۓ-q/?߳=<~#>Fk"qzrQo 9r,nY[; o:)@-`ק-7({߯S@µK9 ֠ɸ>:n3
_[_*mtcmC>qSL=<6;ǫsaaa{xˌ\ފp x?0#5zяc]x^l(f:~ ٣^lin59W~\;?vn6erUbS~v^U O7O(|;+SG4|?f *?rW~2oNٟS9~daևmH6mX[J~s.ym4ٶO|B d/b5ɿyU? 0 0 0 0 0 0 0.P~ *1@G\⟿KrKXs2(ߥ纎J8'>X@▼QQbqwx b)_K|v 1M6kee-2Ǜ59 ?K^E~9ϱQﱮYF8N?~;:=J<-t ĒyNAgC \NXKs)'^Kg\~2}6}Գ) n]Or ^j~"{ p29w6 /. z-v:+M{W JYZ굢`%
Ҥl9ힶ կ#OUz+U?;sd~ vND7*.Y+v:ye;8}~|+ÑޅN9}{Bƞ#txխsXɿkS V/uJ=o G<ջL'L:D]6jfgLz/+ؽ[{ rCMYq~[ {yy czA;w9zszWHVax3 % mkBT x흍 ) q ĉ8D ^>gI@XjjgiЃ`0 `0 ?ϟ|:s eQ3|ӧO|:2|.};7eGFO6_Qv]T]^ˮg{>pjz kuo{ yye?{-x/ D: 3D&e^Hyi#/OG zϪ߯_~
:sMe#M3Y#=2 QЙ[\s=E8}E>GȩT ڲ T g-}VfoSVw zV}./>~!?U1<#} =F[ ~QڋBN..+푹^edLo+[\- k
dW(}6q$#?z6Bөi?L7!3O_Q}Пuo [=tkȋM!'}/Ƈdr2_Cﲨ: `0 :8o=+8-4}۞cĥXdq{bUq©ήm!ƶg*Ϊ U\z[GA=^+ru{LV U?)V>ғ) x|Yҁg i\yi^cUo*= !TY?rfg WsʽV n*V X#=Fϫ+[F~yH\L~[O҇h5ݵTow|Sfӟ+);F;:x
)/OS yUo2e)Ve3'wgGg=J^`0
ľu kU,Ks ؑ5n Y,bXw{ w&3QהNQev ]ƷgcH˞i{A3I8hwduwU IWq8I>+@p QşGcZ\ƪUߝ]/:3d;ɫ:gB9R|GW~w2;fzt|+i5nΟgZY|<1NyŬ|E7k?z/k><=Α}N΅>uWydʬdz `0 *\?W8G Y :Dgcg< 2+'W6qn؟{ru"wU쏘~c#T?+y{Q,,^qF /Xv8.֩g3}ȸOP ~n%hUG4(_sn|W}Tg&x^c,Fѭ+ <#+}/Uw8BRh_|33!mr\7U9m({ѝpvew[xG]߱?g;,nҽow8]וb?OV=Z_ #ve?vN_WrYLo;1g9pV^G~>[_vNOS 3 `0Q[ veO\k^8 ֔v<Zbz\Opbn$~}oz3ј
mK vU]^iNW A#x딫jt q :E=
z%օq)CcYEqyRG-+u (K\hP'*^ء^q=m=y|Kvūe\rȊ4 ={W1;=ݷx p;o@>ȘT\Ԏ+ C=*ɫ|GJ OCW]x1.ﵠ9_Eб
Vq)v(ʑ}[G wǺ {-o S dו_˞׃2 ;iT&w*w:gSOsj%Z[~_˯d֮+w]7 `0]k Iu+eL]ւoA^;=GR? v쯱;<y o$N1紈=:ߥPVu< <&3KyC/4 r)i=*/|Ύ^]QNН1qGw>ù{ ?Kv:A}E:_n +{u=rq͓̳]>>d}+|L01`0 leg:`W,3O?]\9P~[kOWiGc~) -<w.3q}'vuw$Vnv(r52S;Wk_Kϔ8B/hEՠ '9w?K;x:x<|@cϽVyc@ۖS w8B q]=2lBe6V}eR( VeZT 4 ade2ޒ+nYBTqSߔ<[&=f[|szP)G}{Zׅ3n7jpWwftEw[ǽ;`l? `0 `0 `{~i`oLy>uoi\qK|} 7Svu9G쯿c¾#>,jow{Ն ݲL=mW2u_8دjo?kD߱mw>#}E:OۡO;y`$jw ymkBT 6 x횉m0]HI!)$FR?6c>>~ sm+vuՑνYu8uN?WP>1JsWiV_uKE ϸ/r_gKW]ױEY cl,[TYHT}xL#}A GV 7^}>iҞ- i;}LJX&TP3T#ߨ gJ l e'=?͘ona|7>?ǐU%;/mN/IfQփz{G}?v✽3X~j{zTAO^ʰ>?sy|G)PU{ ..T}6 ڳ-F`p]k ߅~b
О$wݓٱ|sCo A+q3lOx@(0a+? T,_7s\Ϙ^Bl1)C+k(FyN"8dPC_9>O0&l4Im+nwGrŰ)/tihf ѸX> E)<,6s45zb?J \<O M%O#(76:= ӋYAH
Ls6MXBcX&ǘJte. 3.je(??Lj=%wZizFTx$kP8Em jAOހ >~؆B9 ֤8UK CvjbL Cy ;mj P. DkwUE3ܨ8xUJs\ɟ+;}sF Q( KIXݛƨ
1 +KdX ];Jģcx$DX`i @l̏rnm$^9΄zBGϞQ=nfkDe;
<a>,⢞jk0B[p($ Ǡp4 nq`XƓ vϵ.xHnorJ5H u뇗 f a[Z:>36[g RL؍?( &w.7C#~B{]
UW 71jk~ecGr D.=K@WDZM0倐0\xvqNZ >#
BE )&yA}t?B Ym(WIpɱ |2+\2 )l8tl @Z.BeRSƃm>dIl'N
adĢG3%#)?$s _5=Y BR#-k"qGP-e"f%֩-ϓ3 78M9ϊ,_*n;HEBƱ cl~
˝[/sagIE2,z1t:kL ș壋G) {7ond{@rP>kwk #kXfyEAB9uM4P=_lgW؇N#_nGpp ,Z Uu6ȓVӰ0EK7*|]{75F\ԶzQz! uH>upT٣o3P)[^6` -d&*=%fY<^ط`_6|h 3ء>2 Pq7ώ ,NsjF=B` 큳CiU)R鐏@LҮ ǧmb<2FHRq ùF X i䎲OmGA}:*u f: @ʫRH.66jcGOpO-
6 HKJU:Jǃv ,3DZEƮqq7p?ȌK%ȧ$;? Qr6pP7`a^=R_)m>D3# £ _'
I ɭu͋C-Rne㯄 ssL<ȭ/R)|Lt_1Lk=rr 4/gEr~PnB[\g[{gYvRW'
{Fem1{ wL; 7&$xc0 n&u@5sCCձm 8Heft x{q(aтa?Q%l4ςxmWI׆GC1kQ3iJh,KRO`ʲ4)%b6B8\ pe;u)ko)#WSncRx{[sXv195_0Kՙ7> Tp5ٴl3S"؝LX睫[5m Q ="u}pϘ*xbՉ#iM+@Z! Ϯ~jYݬ$ ?5mtu] %@݅:4h8ۃtu3;
ΑO1A/r
R*5i&j#Y 2:$Z(ad@>'z
L뇶6Z8|`6"X1_z'
F-я?X^ A:?1;h/KVB' vOn FS ƤQ{=kh7MwXQp\v͓O/.
N3HKRlK"q ^Wh1wt h@3e 6N|I;y? 8t[[! $, ήLe"z%IކAkRl!3u8ځy?_W)AbCO!rza5Sn֗#<43y6"R߃CQ&>[#
B Hǽ{vekOTlq(UH͵h ݔ8,@tՂL{p /*L"d_y k,4 G̖bD>,.ok"D;|7[. DCA#ilϟI֬ Dq]+eE _-- ڰc ^Lq1~CCC9gNH8BkhJ#Z-`VoMa 9r$ պZ-hkh
?C$ ^tď9d(8P݅]ڶw[wl;dn׆oKd Hބ(DInI M_( 5)6H/Y1 QRk ,nXHʉ?>df&6^EJmt{CCc`0ʅv 5 x<\9Yc}106"״!֏9dl:' 1H"z'7QqɌ#KR./CVgQȬ \ `?d1yuM6Ƶ8ZX]8^pwQE
&1frRKi$GݜЕ h3'{ ;;~FK37ku<pdʎ+C RMzƏ7)n Ҁ lEG yl:̑Io BS%|ЕsTulebA}Aʹ10A{ KʘӺtjdLI=r PRg_LbR
Şl?␔)![Fo wi&k^CV(t@pW2{hxHGRn͉eCbxԉ6G Qd27\ثdS=\Ff*0 ۣ OP5(rZߙxQZ>~GAe N-jY7Ҿn;n?ӹ"Px} /N W:݊&:x" ꭥу;R펔 c䛅љElmG§a= h¨BG_uYnZ쫭FYs U"zM&:Gnu.DX5Xn ;}ԫ%XO?~2& Frjj 8 yA*W I9/ub)Zl: s 85J>~iI3Y ԕ;:#hELם[ROd^GA˩f~Y!En0~/A
Km>^WYq"<цF*c:xw|͞w%ehRgd9̕v3v
Dgh>>?3hYDkgC(ʹԕSԜ|
2Q94(?OGQ34
fccPopTYaW(> @tX4`LGٞpɄaŰl \[9c26U M6f, 'C4i?W~p sϠ?kAKrŵk@I|>^xs?\`,D̒5W^w DMXf_8<%| 8_왉pP1Wlm߃f?4:́_Ԕv M;k:p _sj؎qw]$F} y
,b'N=o0,
~M
YR46+!}@~ujctCP.Y(xz?70WXFܣo3z0c8RGg 0 TUw"/4֏CQ`[{Ocn]+{{ N!33+5]qpj'
r9FDȬ)~: 9Gmx2-?sraG"yvUpa;Ră A\&
?#n 0eed~oq嶭! !DzP^H)>oȑ.ļԶ=Hy7S-M
?8ycߧq|#5"2Б lm#UeΤVbM͘jAc7Z
]> 4gb
s 2WRsKg6
's8q zTT[R[w )I95xWj
#!nN+zPڔ KgTE,?{^RDݥ=Ru^zîc&D'i74SJ ߔ&HUG [crͦ< ~ 4}څh;lpAZ%XZ;tQ? yk1+Ƴu6 [ Dc4Ɯ*dB#!}e>samhG3c^ 8u9⸈߂UyB;f "Yi=D = 4&|C3g]~WgjhSIXU"1A5F r4{AljwTt6< /N \Rta| i>T.Wo>>xϯY{緷 m,J{gg}v~)]s!?wX GFl!7U|Cnfﳅ:.@mq%臔Ru?.:aBֺE#G g'yXDuSWNJD)21ѵVagWPqȒ s ?¶@g")s\T{f3go ^w:^" {d#!φt},nyWFKvX4|VB~,˘_&fjp/Wԍwa O H 3I`u1ͤ+_W|+_W|+_W|+_W|+_W|+_W|+_W|+_W|+_W|+_W|+_W|+_W|+_W|+_W|+_W|+_Wݚw) bIDAT8mKSa?
tz. #(qׅta"ؚW]Ew!Evb^ts
ׅeAZ*]H1Džs{xͰ ||
)%=GqrNTe M LX:NP<mH[
4iIB{9w\<
riz; w@Xta9KTe >_φp?l2yG%x >2wVy+ ScĢ!_PC'H|L&n~F{X`P p/K7gs "M`a*w]~ 2N?OnpnJ 8>"0Ԏ
vކǣzZKe F]`Cf3K+,+@ _@ L5$ZmR<7y8 ˛GP e m3mL9 Oo~
7[m~G) >O3p7髣 -0xA$kgm\R.o jmP<'JY.;@}N⣪ST_˭trљh IENDB` gpodder-3.1.2/tools/upgrade-win32-binary-package.py 0000664 0001750 0001750 00000012156 11751103635 021536 0 ustar thp thp 0000000 0000000 #!/usr/bin/python
# Upgrade script for the gPodder Win32 release
# Injects new data into an old win32 release to build a new release
# Thomas Perl ; 2011-04-08
# Required files:
# - An old win32 release
# - The source tarball of the new release
# - The (binary) Debian package of the new release
# - The source tarball of the most recent mygpoclient
# - The source tarball of the most recent feedparser
import os
import subprocess
import sys
import re
import glob
if len(sys.argv) != 6:
print """
Usage: %s
With:
, e.g. gpodder-2.12-win32.zip
, e.g. gpodder-2.14.tar.gz
, e.g. gpodder_2.14-1_all.deb
, e.g. mygpoclient-1.5.tar.gz
, e.g. feedparser-5.0.1.tar.gz
""" % sys.argv[0]
sys.exit(1)
progname, old_zip, source_tgz, deb, mygpoclient_tgz, feedparser_tgz = sys.argv
print '-'*80
print 'gPodder Win32 Release Builder'
print '-'*80
m = re.match(r'gpodder-(\d+).(\d+)-win32.zip', old_zip)
if not m:
print 'Unknown filename scheme for', old_zip
sys.exit(1)
old_version = '.'.join(m.groups())
print 'Old version:', old_version
m = re.match(r'gpodder-(\d+).(\d+).tar.gz', source_tgz)
if not m:
print 'Unknown filename scheme for', source_tgz
sys.exit(1)
new_version = '.'.join(m.groups())
print 'New version:', new_version
m = re.match(r'gpodder_(\d+).(\d+)-(.*)_all.deb$', deb)
if not m:
print 'Unknown filename scheme for', deb
sys.exit(1)
deb_version = '.'.join(m.groups()[:2]) + '-' + m.group(3)
print 'Debian version:', deb_version
m = re.match(r'mygpoclient-(\d+).(\d+).tar.gz', mygpoclient_tgz)
if not m:
print 'Unknown filename scheme for', mygpoclient_tgz
sys.exit(1)
mygpoclient_version = '.'.join(m.groups())
print 'mygpoclient version:', mygpoclient_version
m = re.match(r'feedparser-(\d+).(\d+).(\d+).tar.gz', feedparser_tgz)
if not m:
print 'Unknown filename scheme for', feedparser_tgz
sys.exit(1)
feedparser_version = '.'.join(m.groups())
print 'feedparser version:', feedparser_version
print '-'*80
print 'Press any key to continue, Ctrl+C to abort.',
raw_input()
if not deb_version.startswith(new_version):
print 'New version and Debian version mismatch:'
print new_version, '<->', deb_version
sys.exit(1)
def sh(*args, **kwargs):
print '->', ' '.join(args[0])
try:
ret = subprocess.call(*args, **kwargs)
except Exception, e:
print e
ret = -1
if ret != 0:
print 'EXIT STATUS:', ret
sys.exit(1)
old_dir, _ = os.path.splitext(old_zip)
new_dir = old_dir.replace(old_version, new_version)
target_file = new_dir + '.zip'
source_dir = source_tgz[:-len('.tar.gz')]
deb_dir, _ = os.path.splitext(deb)
mygpoclient_dir = mygpoclient_tgz[:-len('.tar.gz')]
feedparser_dir = feedparser_tgz[:-len('.tar.gz')]
print 'Cleaning up...'
sh(['rm', '-rf', old_dir, new_dir, source_dir, deb_dir,
mygpoclient_dir, feedparser_dir])
print 'Extracting...'
sh(['unzip', '-q', old_zip])
sh(['tar', 'xzf', source_tgz])
sh(['dpkg', '-X', deb, deb_dir], stdout=subprocess.PIPE)
sh(['tar', 'xzf', mygpoclient_tgz])
sh(['tar', 'xzf', feedparser_tgz])
print 'Renaming win32 folder...'
sh(['mv', old_dir, new_dir])
copy_files_direct = [
'ChangeLog',
'COPYING',
'README',
'data/credits.txt',
'data/gpodder.png',
'data/images/*',
'data/ui/*.ui',
'data/ui/desktop/*.ui',
]
print 'Replacing data files...'
for pattern in copy_files_direct:
from_files = glob.glob(os.path.join(source_dir, pattern))
to_files = glob.glob(os.path.join(new_dir, pattern))
to_folder = os.path.dirname(os.path.join(new_dir, pattern))
if to_files:
sh(['rm']+to_files)
if not os.path.exists(to_folder):
sh(['mkdir', to_folder])
if from_files:
sh(['cp']+from_files+[to_folder])
print 'Copying translations...'
sh(['cp', '-r', os.path.join(deb_dir, 'usr', 'share', 'locale'), os.path.join(new_dir, 'share')])
print 'Copying icons...'
sh(['cp', '-r', os.path.join(deb_dir, 'usr', 'share', 'icons'), os.path.join(new_dir, 'icons')])
print 'Replacing Python package gpodder...'
sh(['rm', '-rf', os.path.join(new_dir, 'lib', 'site-packages', 'gpodder')])
sh(['cp', '-r', os.path.join(source_dir, 'src', 'gpodder'), os.path.join(new_dir, 'lib', 'site-packages')])
print 'Replacing Python package mygpoclient...'
sh(['rm', '-rf', os.path.join(new_dir, 'lib', 'site-packages', 'mygpoclient')])
sh(['cp', '-r', os.path.join(mygpoclient_dir, 'mygpoclient'), os.path.join(new_dir, 'lib', 'site-packages')])
print 'Replacing Python module feedparser...'
sh(['rm', '-f', os.path.join(new_dir, 'lib', 'site-packages', 'feedparser.py')])
sh(['cp', os.path.join(feedparser_dir, 'feedparser', 'feedparser.py'), os.path.join(new_dir, 'lib', 'site-packages')])
print 'Building release...'
sh(['rm', '-f', target_file])
sh(['zip', '-qr', target_file, new_dir])
print 'Cleaning up...'
sh(['rm', '-rf', old_dir, new_dir, source_dir, deb_dir,
mygpoclient_dir, feedparser_dir])
print '-'*80 + '\n'
print 'Successfully built gpodder', new_version, 'win32 release:'
print ' ', target_file, '\n'
gpodder-3.1.2/tools/svg-source/ 0000775 0001750 0001750 00000000000 11760761026 016016 5 ustar thp thp 0000000 0000000 gpodder-3.1.2/tools/svg-source/gpodder64.svg 0000664 0001750 0001750 00000167565 11751103635 020355 0 ustar thp thp 0000000 0000000
image/svg+xml
gpodder-3.1.2/tools/svg-source/gpodder22.svg 0000664 0001750 0001750 00000171452 11751103635 020335 0 ustar thp thp 0000000 0000000
image/svg+xml
gpodder-3.1.2/tools/svg-source/gpodder26.svg 0000664 0001750 0001750 00000173105 11751103635 020336 0 ustar thp thp 0000000 0000000
image/svg+xml
gpodder-3.1.2/tools/svg-source/gpodder40.svg 0000664 0001750 0001750 00000225321 11751103635 020330 0 ustar thp thp 0000000 0000000
image/svg+xml
gpodder-3.1.2/tools/svg-source/gpodder24.svg 0000664 0001750 0001750 00000171426 11751103635 020340 0 ustar thp thp 0000000 0000000
image/svg+xml
gpodder-3.1.2/tools/svg-source/gpodder32.svg 0000664 0001750 0001750 00000166024 11751103635 020335 0 ustar thp thp 0000000 0000000
image/svg+xml
gpodder-3.1.2/tools/svg-source/podcast-source.svg 0000664 0001750 0001750 00000446231 11751103635 021500 0 ustar thp thp 0000000 0000000
gPodder podcast cover art
image/svg+xml
Thomas Perl <thp@gpodder.org>
gPodder podcast cover art
2010-02-24
gpodder-3.1.2/tools/svg-source/gpodder16.svg 0000664 0001750 0001750 00000160307 11751103635 020335 0 ustar thp thp 0000000 0000000
image/svg+xml
gpodder-3.1.2/tools/fake-dbus-module/ 0000775 0001750 0001750 00000000000 11760761026 017045 5 ustar thp thp 0000000 0000000 gpodder-3.1.2/tools/fake-dbus-module/README 0000664 0001750 0001750 00000000357 11751103635 017726 0 ustar thp thp 0000000 0000000 This directory contains a dummy "dbus" module for use with gPodder on platforms
where D-Bus is not available. The dummy "dbus" module will do nothing, but still
allow gPodder to run successfully without the need for the real D-Bus module.
gpodder-3.1.2/tools/fake-dbus-module/dbus/ 0000775 0001750 0001750 00000000000 11760761026 020002 5 ustar thp thp 0000000 0000000 gpodder-3.1.2/tools/fake-dbus-module/dbus/service.py 0000664 0001750 0001750 00000000311 11751103635 022003 0 ustar thp thp 0000000 0000000
def method(*args, **kwargs):
return lambda x: x
class BusName(object):
def __init__(self, *args, **kwargs):
pass
class Object:
def __init__(self, *args, **kwargs):
pass
gpodder-3.1.2/tools/fake-dbus-module/dbus/mainloop/ 0000775 0001750 0001750 00000000000 11760761026 021620 5 ustar thp thp 0000000 0000000 gpodder-3.1.2/tools/fake-dbus-module/dbus/mainloop/__init__.py 0000664 0001750 0001750 00000000001 11751103635 023714 0 ustar thp thp 0000000 0000000
gpodder-3.1.2/tools/fake-dbus-module/dbus/mainloop/glib.py 0000664 0001750 0001750 00000000055 11751103635 023103 0 ustar thp thp 0000000 0000000 def DBusGMainLoop(*args, **kwargs):
pass
gpodder-3.1.2/tools/fake-dbus-module/dbus/mainloop.py 0000664 0001750 0001750 00000000000 11751103635 022154 0 ustar thp thp 0000000 0000000 gpodder-3.1.2/tools/fake-dbus-module/dbus/__init__.py 0000664 0001750 0001750 00000000407 11751103635 022110 0 ustar thp thp 0000000 0000000 import dbus.exceptions
class SessionBus(object):
def __init__(self, *args, **kwargs):
pass
def add_signal_receiver(self, *args, **kwargs):
pass
def name_has_owner(self, *args, **kwargs):
return False
SystemBus = SessionBus
gpodder-3.1.2/tools/fake-dbus-module/dbus/glib.py 0000664 0001750 0001750 00000000125 11751103635 021263 0 ustar thp thp 0000000 0000000
class DBusGMainLoop(object):
def __init__(self, *args, **kwargs):
pass
gpodder-3.1.2/tools/fake-dbus-module/dbus/exceptions.py 0000664 0001750 0001750 00000000132 11751103635 022525 0 ustar thp thp 0000000 0000000 class DBusException(Exception):
pass
class NameExistsException(Exception):
pass
gpodder-3.1.2/tools/win32-setup/ 0000775 0001750 0001750 00000000000 11760761026 016021 5 ustar thp thp 0000000 0000000 gpodder-3.1.2/tools/win32-setup/gpodder-setup.iss 0000664 0001750 0001750 00000005373 11751103635 021327 0 ustar thp thp 0000000 0000000 ; Script generated by the Inno Setup Script Wizard.
; SEE THE DOCUMENTATION FOR DETAILS ON CREATING INNO SETUP SCRIPT FILES!
[Setup]
; NOTE: The value of AppId uniquely identifies this application.
; Do not use the same AppId value in installers for other applications.
; (To generate a new GUID, click Tools | Generate GUID inside the IDE.)
AppId={{ABE123A1-41D1-4917-8E1E-C7E37991B673}
AppName=gPodder
AppVersion=3.0.4
AppPublisher=Thomas Perl
AppPublisherURL=http://gpodder.org/
AppSupportURL=http://gpodder.org/
AppUpdatesURL=http://gpodder.org/
DefaultDirName={pf}\gPodder
DefaultGroupName=gPodder
LicenseFile=C:\Users\thp\gpodder\COPYING
InfoBeforeFile=C:\Users\thp\gpodder\README
OutputDir=C:\Users\thp\gpodder\tools\win32-setup
OutputBaseFilename=gpodder-3.0.4-setup
Compression=lzma
SolidCompression=yes
WizardSmallImageFile=C:\Users\thp\gpodder\tools\win32-setup\wizard-small-image.bmp
WizardImageFile=C:\Users\thp\gpodder\tools\win32-setup\wizard-image.bmp
[Languages]
Name: "english"; MessagesFile: "compiler:Default.isl"
[Tasks]
Name: "desktopicon"; Description: "{cm:CreateDesktopIcon}"; GroupDescription: "{cm:AdditionalIcons}"; Flags: unchecked
Name: "quicklaunchicon"; Description: "{cm:CreateQuickLaunchIcon}"; GroupDescription: "{cm:AdditionalIcons}"; Flags: unchecked; OnlyBelowVersion: 0,6.1
[Files]
Source: "C:\Users\thp\gpodder\gpodder.exe"; DestDir: "{app}"; Flags: ignoreversion
Source: "C:\Users\thp\gpodder\gpo.exe"; DestDir: "{app}"; Flags: ignoreversion
Source: "C:\Users\thp\gpodder\COPYING"; DestDir: "{app}"; Flags: ignoreversion
Source: "C:\Users\thp\gpodder\README"; DestDir: "{app}"; Flags: ignoreversion
Source: "C:\Users\thp\gpodder\bin\*"; DestDir: "{app}\bin"; Flags: ignoreversion recursesubdirs createallsubdirs
Source: "C:\Users\thp\gpodder\share\*"; DestDir: "{app}\share"; Excludes: "*.h,*\qml\*"; Flags: ignoreversion recursesubdirs createallsubdirs
Source: "C:\Users\thp\gpodder\src\*"; DestDir: "{app}\src"; Excludes: "*.pyc,*.py~,*\qmlui\*"; Flags: ignoreversion recursesubdirs createallsubdirs
[Icons]
Name: "{group}\gPodder"; Filename: "{app}\gpodder.exe"
Name: "{group}\gPodder (set download folder)"; Filename: "{app}\gpodder.exe"; Parameters: "--select-folder"
Name: "{group}\gPodder (CLI)"; Filename: "{app}\gpo.exe"
Name: "{group}\{cm:ProgramOnTheWeb,gPodder}"; Filename: "http://gpodder.org/"
Name: "{group}\{cm:UninstallProgram,gPodder}"; Filename: "{uninstallexe}"
Name: "{commondesktop}\gPodder"; Filename: "{app}\gpodder.exe"; Tasks: desktopicon
Name: "{userappdata}\Microsoft\Internet Explorer\Quick Launch\gPodder"; Filename: "{app}\gpodder.exe"; Tasks: quicklaunchicon
[Run]
Filename: "{app}\gpodder.exe"; Description: "{cm:LaunchProgram,gPodder}"; Flags: nowait postinstall skipifsilent
gpodder-3.1.2/tools/win32-setup/wizard-image.bmp 0000664 0001750 0001750 00000622326 11751103635 021110 0 ustar thp thp 0000000 0000000 BM$ 6 ( : $ |znxpcnhYf`P]YIWRAQN=LG4EB.@>*=?)=>)*=@-?D1BI7HL:KRAPVETZJX^O\bS`hZgocnymww¿¿¿{l`kVFTH5FB.@?*=?*=?*=@*>@*>@*>@*>@*>?*=>)<>)<=);<(;<(:;'9;'9:'8:&89&89&79%78%78%78%78%78%78%78%78%78%79%79%78%79&79&7:&8:'8:'9;'9;(:<(:<(;=);=)<>)@*>@*>@*>@*>@*>?*=?*=?*=?*=A-?C/AF3ER?O]LZeWcsiry~t}hZeQ?N?*)<>)<=);=(;<(:;'9:&8:&89%78%67$6;'9?)=B+@F-DI/FL1IP4MT8QV8RX:TZY]?Z`A]aB^aB^aB^aB^aB^aB^aB^aB^aB^`A]`A]aA]_@\]>Y[?)<<':9%68$68%79&7:&8:&8;'9;'9<(:<(;=(;=(;=)<>)<>)<>)N)=<(;;(9;(9:&8;'9=';?)=A+?J0FS7P]>ZfDboLjvQr~Wx\~_bcgijllmnnopppppppppppppoonmlkjjheda_][}X{zTvtOokIgdCa^?[Y;US7PL2IE.BA+?@*>>(<=';<':;'9:'89&7;(::'8<':=(;>)=?)=?*=B/@K9IZIXtir^N\?)=?)=?)=>)<<(:9&78$6A*>K1HU9RaB^nLk~Wy`hlorrrrrrrqqqqqppppppppppppppppppppppppppqqqqqqrrrrrrrqonljfa[~|VxtQplJgdC`[=WT7QK1HE,B?)=8%68%7;'9=(;>)=?)=?)=?)=?*O?*=>)=<)::'8:&8?))Nocm¿P=O?)=?*><(:9%7D,AX:TpMmbmrsrqpppppomkjihfda`_^]][ZZYZZZZZZZZZZZZZZZZZ[[[\\]^_``bccdeghjjkllmnoppppppppqrrrrpkbyStfFcU9QH.E;'98%6=(;@*>?)=?))<<':9%7L2IlIg`osqpopppojgda_^\[YXYYZZ[[[[\\\\\\\\\\\\\\\\\\\\\\\[[[[[[[[[ZZZZZZZ[\\]_`bcddgijmoppppoopqsrodxTscC_I0G9%7:&8<(:>))=?*=:&8J0FuPplsrpppnkhc]\[[ZYZZ[[\\\\\\\[\[\\[\\\[\\[\\\[\\[\\\[\\[\\\[\\[\\\[\\\[[[[[ZZZZZZ[[[\\^bdhkmnpppprsrjXz^?[E-B:&8=(;@*>?)=ZIY?*<>)<:&8Y:Vgrpopoid_ZZ[[[[[[\\\[[\[[\[[[\[[\[[[\[[\[[[\[[\[[[\[[\[[[\[[\[[[\[[\[[[\[[\[[[\[[[[[[[[[ZZZ]`dfjopooprqdjHgF-D8%7=(;?)=?)=bQ`>)<:'8Y;Vlrnpog_\Z[\\\\[\\\\\\[\\\\\\[\\\\\\[\\\\\\[\\\\\\[\\\\\\[\\\\\\[\\\\\\[\\\\\\[\\\\\\[\[\\\\\[[ZZ\^binopnprelIh@)>:&8>))*<>*>*X;(9>)bqq_T}W~VWWV~V~V~V~V~V~U~U}T}U}V~XZ[\]^^_____^]\ZWU}T}U~V~V~V~V~WWWV~VWV~WWWV~VWV~WWWV~VWWV~V~V~V~V~V~V~V~V~V~V~V~V~V~WWXYZZ[\\\\\\\[[\[[\[\\\[[\[\\[\YhpsyUu<':>)(=(;G2Dxjw>)<<':sNnrpgU}V~X[\`dhlooopppooooppqqrrssrrrrqppooold]V~U}WWV~V~V~V~WV~V~VV~V~V~WV~V~VV~V~V~WV~V~VV~V~V~WV~V~VV~WWWWWWWWV~V~V~V~WXY[[\\\[[\\\[\\[\\\\Z^molH/F<(:A,?>)<:(8dC`romghknpqppppqqrrrrqomjfa^[||XxyVuyUuzWv|Yx}Zy_~fkqsrrqqpi_U~U~V~WV~WWWW~WWW~WWWW~WWW~WWWW~WWW~WWV~WV~V~U~U~U}U}U}U}U}U}U}U}U}U}U}U}U}V~WXZ[\\\\[\\\[\\\[[^momO4M<':?*=Ŀ?*==);M2Jiqnpooooqrrpmga\~|UwoKkdC`Z?)=?)<>(;>)<>)<>))A,?G1ET)<;&8mJissrspnj_|WxoLkdC`X:TL1ID,B<':8%69%7:&8;'9<':<(:=(;=(;=(;=);=);>)<>)<>)<>)<>)<>)<=);=(;=(;<(:;'99%89&7E0C_E\}]ysqpn`T}WWVV~V~WW~V~V~VV~V~WW~V~V~VV~V~WW~WVV~U}Zdlpppppppppppppqnkgc_[V~T}V~XZ\\\\[\[[[]lonS7P;'9?*=?*=>)YtNovPqmJibB^T8QI0GD,A?)=;'98%7:'8<(;>)@*>?*=?*=?*=B-@E1BG3EM:K[IYgVetdrwyxv|mzjYh]L\N=(;9%8=);W@Tftop`U}V~WWV~WWV~WWWV~WWV~WWWV~WWWU}WenpopsssqqqqrssssqppppomlhaZWV~WZ\\\[\[]lonT8P;'9?*=o`n?*==);:&8:&8:&8:&8:&8;'9;'9<(:=);>)<>))<=(;9%8>*(;C+@J1GQ6M]>YkJgY|gmrrrppppmib\[[XZmplL2I<(:@+>{vrcr?*=;&9H1Fkpp[V~V~V~VV~V~V~WV~V~VV~V~V~WWWV~XlppoqMlB+?8$6<(:<(:>)<>))*)<>)<=);<(:;(:;(9:&8:&8;'9?)=M3J`@\tPp`krrpopookf\_ophC,@=(;D/B]L\@+>7#5vUrrpdT}WW~WWW~WWWW~WWW~WWV~V~U}dpopgFc9%7=))*<>)<>)<>)<>)<<(:9&87$6B*?Q5MdD`|Vwhqrqppqpmnq_?)==);K8J?*=:&9X))<<(:<*::'8<':E-C`?\zRubmqqoonsmLi:&8>))<>)<<(;:&89%7H.EZ:UqMm_lpteI0F>+=);9&7<':C,AL3IY*)<<(:;'9:&9:&8<':?*=@+>?*=;'9Y))<^L\www|@*>8%6nLjrpfT}WV~VV~V~V~WV~V~VV~V~V~V~T}cqr~Wy;&9>))[ ||| zzz --- ``` ppp
}RxWWV~WW[9%7 ;;; )))CCC ??? !!!777 `?\[V~V~WY}Rx
^^^ ~~~555 ttt J0G^V~V~V~[lFh 222 LLL %%% 4"2[WV~V~[H/E lll CCC +++ www T{XW~V}\&$ ***@@@VVV\\\ 111--- }}}
zPtYV~V~Y
qqq >>>sss 111 tLoZWXsKm EEE
FFF nHi[V~[\[[ZtLo (((\\\ III lGh[ZvMq """;;; [[[ UUU666 rJmZZxOs bbbIII((( yOtYY}Qw %%% MMM TzXXU} 888 888KKK 0 .ZWXZ'% JJJ KKK ??? VVVrrrI0F^V~W_5"2 ``` ::: !!!333 _>[[VV~]F.C vvv xxx 222BBB
SzWV~V~[]=Y <<)<<(:xXusq_U}V~WW~WWV~VjosT)8$6lOitohU}V~WU}Wjot]{:&8@*>K7I 000 %%%?*==(;B-@kpocU}S|YjponI2G;'9?*= ggg l\j>)<:'8aF^tpoigmpps`C]9%7>)*<>)<<':rQnqsrticD_8%7>)5 3.,-+.,8"6R?Qvvv YYY ^^^v``` ::: %%%gggfff''' AAA (((TTTddd&&& ### 000 ***www$$$ """gggDDD
AAAyyyxxxeeeXXXLLLHHHOOOVVVZZZsss gpodder-3.1.2/tools/win32-setup/wizard-small-image.bmp 0000664 0001750 0001750 00000031016 11751103635 022204 0 ustar thp thp 0000000 0000000 BM2 6 ( 7 : 1 ¿y|qyvhrn^lhTdaL^`J]aM_cN`ePafSchVejYgl[in]jp`mrcnvis}rz{¿x}o_ldM_\@XaE^eIbiLfoOksRpyUt}Yx[}_`^]]~\}[{Z{~Yz}Xy{WwzVvvTrpPmkMgeIbaE^^BZ_E[hTdqcnwot}v{sfraF^lLhzWv^ehffdba`_^]]^^__``aaabdeghfa]zXvrRnkMhcF_jZgzpwhSevUrdge`\XXXYYZZZ[[[[[ZZZZZZZYYXWWZ\_begc]|qPmbL`}p|yWuh\XW~Y[\\\\\\\\\\\\\\\\\\\\\\\\\\[ZYXY\agbhJdwhvxgub[T}V~WV~WWXXYYZZZ[[[[[[[[[\\\\\\\\[[\\\\[ZZ_ilMhwzkx_\U}V~V~V~V~V~U~U~U~U~U~U~V~WWWXWXXXXYYZZZ[[[\\\\\\\\[Z]fdJaykw]}_U~VWWX[^____^ZWWV~V~V~V~V~V~V~V~V~V~WWWWWWXYZ[\\\\\ZbsRorRog`bcec_}XyxVsvTqtSprRntTp~[z``[VV~WWWWWWWV~U~U~XZZZZYXWY[\\[`}Zxr~hUfqQmvUrnNkpUmmVkfRdo\mx{p^nfOd^}_V~V~WV~V~WV~WU~Wcca`aaabd`[WYZ^{Yw~hWf}\z_U}W~V~W~WWV~XeyXulSivduxguwfvuasmRjoOkvUr\{bfc]_yWugKdaWV~V~WWWU}fqSnwivýrgLdlNiyWu_fgJdoVm`XV~V~V~WV~ZciRfr[o[AXqkkknnnpQmcV~V~V~W~V~T|b[{{kkkUUUSSS ~[yaT|WV~WV~U~dK5H'''$$$---kkkooo &(&2!0\YV~WV~Y\<%9lmm nnndddI,E\XV~X]E*B
???)))dddIII
}Px[W\nDh vvv...SSS333444GGG|||GGGdddlll!!!!!!Q.M\X[0-;=;$$$LLL000www888 777aeb#!V[oEj EEEttt666000 AAAiii 555zLu]C'?.../// ---rrrYYY::: ^^^III f>a_-+adb )))LLL www mmm S1OY 444 ppp ooo ;;; FFF<;_ YYY ```:89M-Id>_! fff 555-*-S1Ne?_ {{{ kkk""" """ X5Tc>^ NNN lll {{{222oEjkDf 444 111xxx kkkTTTx{x VT} BBB !!!9:96 3Z\,)_b`NNN (((xxx YYYFFFddd
f?b[[G*D$$$&&&rrrBBB!!! ! =$:\XYzMu mpm |||ggg ggg ccc!#!, *W~ZV~V_\@Y***WWW RRR'''999?6>|Xx`U}WU~dtYqjjj---???PPPmmm cccvvv GGGwWtcU}U}ZakXi{{{ AAA ^^^iSgbZWfdHa 444 OOOfFbccjJfv vvvBBB hQfkTgxooo www ***lll """```
! IJINONOOO<<< %%%zzzccc555
===lll gpodder-3.1.2/tools/progressbar_icon_tester.py 0000664 0001750 0001750 00000001320 11751103635 021212 0 ustar thp thp 0000000 0000000 #!/usr/bin/python
# Progressbar icon tester
# Thomas Perl ; 2012-02-05
#
# based on: Simple script to test gPodder's "pill" pixbuf implementation
# Thomas Perl ; 2009-09-13
import sys
sys.path.insert(0, 'src')
import gtk
from gpodder.gtkui.draw import draw_cake_pixbuf
def gen(percentage):
pixbuf = draw_cake_pixbuf(percentage)
return gtk.image_new_from_pixbuf(pixbuf)
w = gtk.Window()
w.connect('destroy', gtk.main_quit)
v = gtk.VBox()
w.add(v)
for y in xrange(1):
h = gtk.HBox()
h.set_homogeneous(True)
v.add(h)
PARTS = 20
for x in xrange(PARTS + 1):
h.add(gen(float(x)/float(PARTS)))
w.set_default_size(400, 100)
w.show_all()
gtk.main()
gpodder-3.1.2/tools/win32-launcher/ 0000775 0001750 0001750 00000000000 11760761026 016462 5 ustar thp thp 0000000 0000000 gpodder-3.1.2/tools/win32-launcher/gpodder.ico 0000664 0001750 0001750 00000302536 11751103635 020607 0 ustar thp thp 0000000 0000000 h V 00 % f @@ (B ; ( 6} ( @ -+% 3.+9,5;;+8U<+9c<+9i<+9i<+8c;+7Y9,5I6.0520*#1/)-+$ U=RqPm~Xy]`aa`]Y{xTtnNjV>R7,23?*<tPoWZ\[YYYZZ[\_hId`C]nNjgHc`C]cF_tRp߆XWZvRrtPpXz`uRq?)<C>+<]WqNm )>*=?)<-R8OspK CSSSuyOszPt}7Ug;BBBxxxeMbhSfӒҁ7W iiiOOOp}rrrGGGlll???5q
~~~rYYYFFFppp߃iSf~ gggwww퍊uMpdKaMMMk/]]]VAT_dF`^^^gxxxQllllllf\e|z|cccqW ( @ # #" )'%,)! ,*& /+$
1.'/.(.,*2-(30'31'31'30'2-(.,)/.(0.'.+$
,+' *( )(#%" )(! /-(20*)4/-;9-5_;+7}<+9<+:=*:=*;=+:=*:=+:=+:=+:=+:<+9<,8;,7:,6{8.3i50/O31+C31+;20*320*)0.&)' 2-*!;,7E0B[?XlLhyVu]}adfgggfec`\|zXvsRojKg_B\P7M@-=;-650.[31+?.-'C-AtRpgd`][[\\\\\\\\\\]^`cfevTrQ8N<*:k&$ ?*< Z>VcWXYYZZZ[[[[\\\\\\\\\\\_gfGb?*=Y?)<V;ScWWY\]^]ZWWWWWXXXYZ[[\\\\gL4JH0Fŏge^wUslMieGbaD^cF`lNi^}`WWWWWW^bb`][[\dZ>W?)< ?*=;D-BA+?>*=}>**<7>*)=?)<>*=/?*=jLg^WWWWeiJeW;TV;S^B[mMi[{fdfX=U>)=K3HˏeWWW`bE_>*=G>)<>)=>*=?)<;?) K ?*<Q?PG7w5)3ZWWV~I3G]]],,, % =iddd? {eMMMT7PWWZ;Vvvvc鍍aaaKKKcg{{{MMMCCC6,4V~U}706eee_YYY;@@@ edewNqeB`
NNN/$$$ hhh^=ZB+? u ###111Q5M3$1*** ccc] N3K6+5 C&&& X9T6+5 'eiiiwwwmGh3$1]]] UUU=7*=% E3%%%888{jyjVhbbb k%NNNdddXXX...VVVSU~~~}
1E; ( 0 ` % *%$$$ 2).-"/-) **% ''' )%% 5'% 4.# 22" 22" 22" 22" 4.# 5'% *&& ((& ++& .-) .."/) $$$*%!%#*%" -,%.+%1.)0-) 1/( 1/*#10*'20))20)-30+/30+130,740,930,941,951,741+741+741+531+520*531*321+330+120+/20)+20))1/+'2/*#0/' /-)0.(.,&/.%'&" '"
)( .-'1/))20*331+;6/0Q:,6u;+8=+:=*;=*;>*<>*<>*<>*<>*<>*<>*<>*<>*<>*<>*<>*<>*;>*;=*;=+:<+9<,8;,7:-58/3s51.Y41+O32+K31+G31+A31+;21+31/('/.''% /-&2/)38-3m<+9?**;I1FiIe_klifdb``_^^^^^__``abcefhikmkauSq_B\G0E>*;:,630+30/) ('"
>))<:(6 ?*<
A+?g^XXYYZ[[[[\[\\[\\[\\[\\[\\[[\[[\[\^gkdEa?*=>)=
?); @+>g[WWWWWWWWWWXXXXYYYZZZ[[[\\\\\[\\\\\\_lZ>W?*<{?(??)=߉c]V~V~WY\_abba^ZWV~WV~V~V~V~V~WWWWWXYZ[[[[\[[\c]~?)=@);?)=zVvhfjmkd\|yWuuSprQnsSoyXuckcXWV~WWWWWV~WWZ]][YYZ[\[\^hA+??)<
>*=eN4KpOlhIeZ>WM3JC,@?*=>)*<>)=>)<>**<[?*=3?)<=,<?*='?*=lNifV~VWVVWafZ>WC-A?*=>*G0ET9QfGb{Wvhkfce?*=>)=>*=5N5KkWWWV~WXlR8P>*=?*<<(<<*<?)=
>*= ?)>> CCC '''nnnwNr<': CCC 9 uLp1 /444 iU zPu- + OmBBB ZZZT{1 / 3%yyy V~=(: +++7$5WR6OUUUOOO ***
i UUU...c@^WrJm 333\\\9OOOU|WV} YYYqqq )))
dA`WWWaE^,,,))) aaa rrr---q
PPPRRR
]DZZV~VZd>>>uuuEEE g#$$$::: a c6$4yWu`V~WegJc<(: y 襤FFF ?*=YW=TiX^gD.B>*= eř Gp`n @*=vVrljU;S>*=W㸸՜ wwwƥS@QT:QJ2GZHX?yooo /// hhhľggg 222 --- --- 'dddHHH<<*;>*<>*<>*<>*<>*<>*<>**<>*<>*<>*<>*<>*<>*<>*<>*;=+:=+:<+9;,7:-58/2u51.]41+U41+S32,O41,M31+I31,C31+?31+72/)/10)#/,'&&
.+%2/()30*=5/.U;,7=+:>*XT9QM3JF.CA+?@*>?*=>*<=+:;,78.251-c41+]32,Y31+S31+I20*;0/)',*#.*$6-03=+9>*>*<<+98.2s31,K30+A21*3//)!+(#;)7)>**)<>);_?*<?**<[?*<?*)=?*=!?); ?))=kC-A_lhayVukKg^@ZS8PJ1GB,??*=>*<>)=?*=?*=?)<@+>K4IaF^`~mbWWWWWWWWWWWXahlnnlkgc_ZYZ[\\\kuRq?*=?*=?*<?*=B,@J1HE-B?*=>*=?)=>)*<_?)*<9>)=+?*>%?*='?)<3?*)=u?*<@+>cG`l`WWWWWWWWW\lk\}oNkhHdhHdmMjvTr^glnkf`\\[ksQo>)=>)=>)=?*<_>*<{>**<9>*= @)=@+>>)=Q?*=rRnkXWWWWWWWZm`P6M?*=>)<>)<>)=>*=>*=?*=C,AN5L_A\uSqcmmicmkKg?)=?)=>*=T:QnZWWWWWWWfhI1G>*=?*<9>)<
>*= >*=?*=-?)<[?)<>*)<@*;?)=?*=U?*I1FK2H?*=gWfS- U ] /. .>*<\@YnZWWWWWW[nY=V>)<?)=?**<{>*Z EEE$$$AAAwwwV}N3J yyy 777{{{U}C+@'''|||
tttV}=(:333 uϭ
aaa#"V~=':333\\\ ***[ ___;;; CCC2!0WB+?'''+++ FFF?
H/EWO3K ccc'{ ^^^999eB`Wb@] S }RxWzPt=== 3333 bbb'''___///4!1V~WV} ___EEE HHH000iii ### iEeWWWG.DDDD<<)=?*=rRnjWWXloPk?)=>*< ? 7[ ;;;}]ppp xxx'?**<m###
VVV bbbs?))=N:L/ Y{{{ W BBBtn^l )))_ CCC SSSyyy???
wwwGIKKK qqq oaaa777 AAAtttCS7-QskI! ( <872200 ,,, +++ +++ +++ &&& %%% %%% ### """ #"" +!! -!! 8!! 8)! 8*! 6.
66
55
33
33
33
33
33
33
33
33
55
66
6.
8*! 8)! 8!! .!! ,"" #"" """ $$$ %%% %%% ''' +++ +++ +++ --- 22 22871 ,,)) '''### " 4' 21 ..& .,+ ,,)
((%
%%%$$$/%#1/!00 --$.,(2))3-(11'00&..%--$,,+,++,**++*-+)3+)4+)2+(2+'2.'31'21&10&10&10&11&10&10&10&10&21&31'2.'2+'2+(4+)3+).+)++*,**,++,,'--$//%00&11'3-(-*)-,(.. 00 1/!.%#$$$&&%
))'
,,)
.,+ .." 21 ,& ###'''** 1 7!--' ))) $$$ &
00
2,)/+'--&))).('1.$--$/,)3-)11'//%-,+ 0., 2.* 0.( 3/'!10%#40.*%1/*%0/)%2/('1/*'00*'//*)1/,)2.+)40+)30++30*+30*+21)+11)+21)+41(-41(-30*-30*-30*-32*-30*-30*-30*-41*-41(-41(-21)+11)+21)+30*+30*+30++40+)3.+)1/,)00*)1/*'2.*'0/('00)%10+%3/*#10.%!3/'!1/( /.* 0., .-+ //%22'4-),,&--$1+$)''))%--%1,)..(11
(!! %%% +++ // !! $ )&&&$# .- ++'
'&%0'!-,'1-&-,&0*)1/& 2-) 10) 0/)!1.*#2/*%0/('20()21*)1/*+//*-30,-21+/31+131*122)320)511+530*73/*720*931,951,941,;40,=42,?32,A31,C41,C30+C30+C30+C30,E21-E41-C51-C51-A51-A41,A40,A42,A40,A40,A41,A41,?41,?51,?31,?11,?21*?20*?20*?21*=32*=32+=33+;31+;40,;40,;31,921,93/+730+720*510+521)532)331*131+120+/3.*-00*+20*+10))3/')10)'20+%1.*#0/(!1.* /.% 0/&-+*--&2/(.,'-'!'&%,,(
2+ & && "((( /""
--'+)'.+%11(0-* 2.(!10)#20)'1-*)2/*+30)-30*/1/+340-331+721*731*930,;20+=40*?31,?32,A30,G7//W7.2c8-5o:-6{:-6;,7<+8=+9<+9=+9=+:=+:<+:<+:=+:=+9=+9=+:=+:=+:=+:=+:=+:=+:=+:=+:=,9=,9=+8<,8<-8;-7<.7<-5:.59.4w8.3q7.1i6.0a4.-U41+O42+O32+O21+M22,M33,M32,K42-K40-K31,I42+I40+G41,G30+E31)E32+C22+C42,A41,?40+?10+=30*;31*931*731+540+320+310(/21(-30++1.*'00*%11/)!--* 22(/,#,*#.."+#
++ % (( **".-#-,'00( /.)%1.'+2/*/20*130)510*730+;31+=21*?40,A51+E60.Q7/2_8.4m9-4y:,6<,8=+:>+;>*<>*<>*<>*<>*<>*<>*<>*<>*<>****<>*<>*<>*<>*<>*<>*<>*<>*<>*<>*<>*<>*<>*;=+:=+:<,9<-7:.69-59-49.3y8/2s701k61/a50,Y41+U42,S33,S42,Q41-Q51+O42,M30+M41*K22+I33,G41,E31+C40*A22*?31+=30,;20+731*520+120+-2.()0-(%1.( .-(/+$,)$''
(#" ,,!//%/.'!/.('00+/20,511+;31+?21+C32+E42+I31+K31-S8.2q<,7=+9=+;>*;>*<>*)<>*<>*<=*;=+:=+:<,9;-79.5800u41,_41,[52,[41+Y42,Y33-W33+U41,U42,S41+Q41+O32,M42,K40+I41+E31,C31+?10)93.)522)-11*'//) 2*(((#&&
### -&!0.&10(!3.(+21(521)=22+E21+I31,Q6/0e:-4<,8=*;>*XX;UT9QP5MM3JJ1GG/DD-BA+>?*=?*=?*=?*=?*=?*=?*=?*=?*=?*=?*=?*=?*=>*<=+:;,7:-58/2{62-g42+_41,_52,]32,]32+[42,Y32,W32+U32,S31+O31+I31,C21*=3/*310*)..( **&*& '' ! ** .-)10)%2/(/30*;30+C5/-S8-4u=+9>*;>*<>*?*=?*=?*=?*=?)=>)<>*;=+;<,89.470/o51-e52+_41+]42,[33+Y41+W41+S31,O41+I31+A20)92/*//,(#--#-) $$! $$$ ,(!0,'1/(#2.)-5/-E;,7=*;?*=?*=?*=?*=@*=H0EU9RcC_tQpZ|ejnoooooooooooooooooonmmmmmmmmmmmmmmnnooooooooooooooooooooooonljhc\}xTtoMkcC_Y*<=+::-6700k31,Y31+U32,Q31+O31+K31,E32+=3/*500)+//'!--&,% (( ""+%%
/-"3.+ ;*7]>*;>**<>*;<+88.2m41-K30+A21*=3/+922*121()11*!-+))%%(( + 4),=*;y>*=?*=?*=C-AW:SuQqclooooonlifdb`^\ZZZ[[[[\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\]^_`acdefhjkmoooooooonjbxUtcD_Q6N@*>?*=?*=?*=>*<=*:8,5[10)+0.)'20&!/.)/,&((%((# "" $ >*;>*?*=>)<>*<<*;8*330*#''#.- "" =*:3?*)<<(87 A+<?*)<>)<>())=>)=?*<@+>gFcdihe_YzsOneDbX*=>)=>)=?*=?*=?*=?*M2IW9SV9RN4KG/E@*>?*=?*=?*=?*=?*=?*=?*=?*=?*=?*=?*=>*=>*)<>*=u>*=i>*=]?)=O?*>I?*>I>*=K?*)<]>*=m>*=}?*<>)*)=?*)<>*=>*=?)=?)=>)<>)*<+?*= ?*=>*=>*< @*9<&8=2=?*<>)<?(>?)=W?*Y?Vgnm[WWWWWWWWWWWWWWWWWWZhnomcxStaB^R7OI1FF/DF/DF/DF/DH0EL3JS8P]>YjIfvSr[|bhlnooonmjd^\\\[ZhojQ7N?*=>)=>)= =)=>)==?))<>)*<>**=G>*=-@)=@+>?*=O>)=?*=@+>fIcnneWWWWWWWWWWWWWWWWWXgookpMlP5M@+>?*=?*=?*=?*=?*=?*=?*=?*=?*=?*=?*=?*=?*=D-AL2IW;TdE`uQp_jnoooonjfb\XjohK2I?*=?*=?*=?)<?*< ?*= ?*= >*<?*<>,;>)<%>*=>*?*=?*=?*=?*=>)<>))=>**=>*=?*=?*=?*=?*=?*=@*>A,?K1HaA]uQp_inoononjnoaF/D?*=>)<=%=='=>*=o>*=?*=rQoon]WWWWWWWWWWWWWWWYloldEaA+??*=>*=?**=7?*=M>*=i?*<>)<>**K2HZ=WsOo`innooonwTsB,@?*=?)<>+>1>*=?*=aD^no`WWWWWWWWWWWWWWWcon|WxB,@?*=?)=>*=I>+9?)<;>*)=]?(?@*; ?*=#?)=G?*=?*=?*F.CO5LY?*=>) >*<7?*?*=?)<C,C?*=?)=%?**)<>*=?*=kZj?7 U } = >*>>*=?*=?*=]~om[WWWWWWWWWWWWWWaoolJh?*=?*<>*[WWWWWWWWWW^=Z +++ QDDD +++KKKyyy!q ```
1 /V~WWWWWWWWU}'% *** !fff BBBxxx 111KKKeeeQQQ >>> sKnWWWWWWWW]=Y MMM aBBB IIIGiii '''WWW999CCCrrr N3KV~WWWWWWSy2 0 www M\\\---Y+OOO ^^^]]] , *~RxWWWWWWoHj
777yyy ***777 888{M'444 ccc
uuu>>> sKnWWWWWWH/D
kkk ^^^i??? W) %
`?\WWWWWSz """... [[[S / ZZZ BBB ?)>> AAAHHH rKmWWzPu ---!!! S TTTPPP --- T{WWT{#! !!!
E3M RRR 5"2WWWW4"1 aaa
7 JJJ MMM U7QWWWWI0F ###)!!! @@@BBB KKK pIkWWWWdB` {{{ :::... +++vvv
(&}QwWWWWyPt
GGGMMM QQQ
wOOO """ I/FV~WWWWSz&$ gggU||| zzz |||333 tLoWWWWWV~I/E QQQ HHH jjjWWW= kkk &&& 3!0V~WWWWWWfCb HHH ===$$$ o $$$ddd JJJ
jEeWWWWWWWU|'% EEE NNNLLL jjj ;'9TzWWWWWWWW]?YSSS GGG~~~ 3[ jjj醆{
yOtWWWWWWWWW^& % 666 1! ### s Z>>fffgggFFF T=Qk^WWWWWWWWWfnhA-? ::: XXX 9PPP kkky O B.?kobWWWWWWWWYmowXsB-@4#3 bbb999 KKKUUU gggW K
c ;'9L4JeoiWWWWWWWWdokY@V?*=>*<; nnn !!!G\\\ 6667 + 7 9 - >)*==*= q rrrO000 FFF/>)=7>***=?*=lNhnncWWW]lolY?V?*=?*=?)=OG~~~ lll+[VVV qqq}@+;?)>*=>*<=*<{{{ SSSq=== ]]]3?)>>7 ?*<?*>> E
L8J/?*=?*<@+>U:RuQp\~{Uv_A\E.C?*=?*=?*=@'> 5### 7/RRR 888S@Q?*=?*=?*=?*=?*=?*=?*=?*=>)=M3M)QMMM BBBC5uuu PPPvguL8JB-@?*=?+=H4FYGWggg UUUI/+++ CCC»WWW I%ddd GGGXXX$$$
EEE/
DDD ???YYYqqquuu^^^JJJ... '''!;QQQ
333g
!iii CCC9%fff::: +++MMMK 7ZZZ777 ,,,KKKlllYw?7uK!Ek{W-
gpodder-3.1.2/tools/win32-launcher/gpodder.exe 0000664 0001750 0001750 00000413016 11751103635 020612 0 ustar thp thp 0000000 0000000 MZ @ !L!This program cannot be run in DOS mode.
$ PE L 9$SO h @ Y3 H P .text g h ` 0`.data H l @ `.rdata n @ `@/4 z @ 0@.bss `.idata
~ @ 0.CRT @ 0.tls @ 0.rsrc H @ 0 US4@ t D$ D$ $ Ѓ $@ P6 E ED$ @ D$ ED$D$@ $ @ b @ uJb $@ < b D$@ D$ @ $ b $` $@ D$ @ C$zb @ D$C0$fb @ D$CP$Rb oUSE = w;= rL D$ $ b 1[ = tM= t= u뵐= t== uD$ $ a tdt$ и륐1vD$ $ a tJy$ иh$ иUD$ $ Ma 9D$ $ 1a D$ $ a u
fU$ x@ |U$ x@ dU@ fU@ U$ @ b RteD$@ $U tD$@ $ @ Ћ
D@ t1$)@ Rt*D$7@ $ t $D@ ø 말 U$ @ Qt%D$K@ $ t $ @ Ív UWVSLE E E܉D$D$ D$ D$d@ E$C` t
E܍UT$D$ @ D$ D$ D$ $` u< @ E° MԉH @ »@ މE @ E܉$_ Ee[^_]ÍL$qUWVSQ J E E E E E Dž@ E :EC ¸@ ։(uE E؋E;|E܉$
D$ D$$@ u3D$ D$Ɛ@ D$@ $ ^ $ ^ D$ $ C D$ D$$] D$\ $] E} uD$/ $] E} tNE $b u3D$ D$Ɛ@ D$@ $ ^ $ D] $8@ $ Eԃ} u;$ @E} u$ +E} tE$ Eԃ} D$ $ D$H@ D$l@ $ ] D$ D$$\ Dž° ЍPЉ»@ މD$ D$@ $ = u9D$ D$ D$ D$D$@ $
2 D$@ Eԉ$
Eȃ} u3D$ D$Ɛ@ D$@ $ w\ $ [ D$(@ Eԉ$U
Eă} u3D$ D$Ɛ@ D$8@ $ %\ $ J[ D$^@ Eԉ$
E} u3D$ D$Ɛ@ D$t@ $ [ $ Z D$@ Eԉ$ E} u3D$ D$Ɛ@ D$@ $ [ $ Z D$ܒ@ Eԉ$_ E} u3D$ D$Ɛ@ D$@ $ /[ $ TZ D$@ Eԉ$
E} u3D$ D$Ɛ@ D$$@ $ Z $ Z D$K@ Eԉ$ E} u3D$ D$Ɛ@ D$X@ $ Z $ Y EЋC @ D$ CD$$EЃ $z@ EЃE} D$ $ D$~@ D$@ $ Z D$ D$$"Y Dž° ЍPЉ»ԓ@
މD$q D$@ $ =q u9D$ D$ D$ D$D$@ $
D$]@ $@ EЃE} u3D$ D$Ɛ@ D$_@ $ X $ X E$EЃD$@ $EЃt3D$ D$Ɛ@ D$x@ $ X $ W Eи eY[^_]aUx, )E E D$ D$ D$ D$@ $ ;X ED$ E$*X ED$ d D$ D$ E$ X D$ E$W EED$ D$ D$ E$W D$ E$W ED$ D$ D$ D$ $@ ED$ D$ D$ D$ E D$E$ ED$Ӕ@ E$fV E} / E # D$ D$ ( D$E܉$B u E U؉T$ D$ D$$U EE ߭@ E ߭@ \$\$ D$֔@ D$ $ D$ D$ D$ E$V E ߭@ ɋE ߭ٽf f٭٭D$ D$D$ E$U OD$ D$ D$ $_U ~"$RU $IU D$ D$ D$ ED$$!U y} E$U E؉$T E܉$ E$ } t EÐU} t
$@ S J $E t9 $v b $% t $ $I 5 $j t $ $ UWVSLUĻ @ މEĉ$ E} u $ R @ ߉D$@ E$ u3D$ D$@ D$@ $ IS $ nR E$ $@ $@ J e[^_]U(} u -E$ E}tEt U} u3D$ D$@ D$@ $ R $ Q ED$$@ u3D$ D$@ D$̕@ $ MR $ rQ UWD} u3D$ D$@ D$@ $ R $ 0Q ED$D$%@ $ Q t3D$ D$@ D$D@ $ Q $ P EE° MHPET$UT$D$ D$ D$@ $TQ t3D$ D$@ D$@ $ 1Q $ VP E$P }U8E E `@ t
`@ ED$D$ D$ D$%@ $ P t QEUT$D$`@ D$ D$ D$@ $[P uE`@ E$JP EUWVS<@@ D$@@ D$ D$ D$ $ f t3D$ D$@ D$@ $ O $ O @@ E° MH@@ »@
މ@@ e[^_]UWVS } u a»$@ G މED$$N D$ $ D$k@ D$$ ,O e[^_]%L@ %@ %$@ %(@ %@ %@ %D@ %<@ % @ %H@ %@ %@ %@ %@ %0@ %4@ %8@ %,@ %@ UE tuUT$D$E$ v USE =@ t
@ tHt? [ f@ @ tv tЃ@ u [ ED$D$ E$ U1ÐUSX5 PX1Щ 1 t
@ ƀt
@ t
@ t
@ t
@ t
@ t
@ @ u0 = v x# @t
@ [Ð
@ ā
@ UÐUVSu @ @\$ D$ D$ $@ K t$ED$ $ L L UWVSLÉօu e[^_Ív D$ EȉD$ $ML M E܃@tttoUT$ D$@ EԉD$Eȉ$UMhL E܋Mĉ@Ut{T$ ED$EԉD$Eȉ$-L e[^_fe[^_É\$D$ $@ UWVS,@ t
,[^_f@ @ -@ ~ݻ@ ~a=@ u 5@ t=@ s @ }CU @ r݃,[^_Ð
@ u@ uCuC @ J @ C @ S tF tytE T$$ @ 8ǀ t$ )ρ @ 47u,v 8 ua)ω @ Mta t#u+ U )ʁ @ U U @ 98}v )ρ @ 47u UcʼnD$$ؗ@ U(@ tv С(@ P(@ @uÍv US pw@ t"t fpw@ Ku$X*@ [1ÍCpw@ ufU
@ tf@ 듐UVSĴ@ ue[^$ȴ@ tI Q @ t*$fI RfI u tC4$Ћ[u$ȴ@ KI Pe[^Ív USĴ@ u1]ÐD$ $ (H Åt7EE C$ȴ@ H P@ C @ $ȴ@ H S1멸US]Ĵ@ u 1]f$ȴ@ H Q@ t9u B9t Bu$ȴ@ yH R1]ÐHJ$~G $ȴ@ VH RۋB@ ݍv UE t>ruz Ív kĴ@ HuĴ@ $ȴ@ H PfĴ@ tĴ@ f$ȴ@ G RސQP= L$ r - = w) XYÐ D$,D$ D$(D$D$$D$D$ $ ÐVS$\$0t$4D$8T$@ hS(J uZ9Z ~uJ ZCZ([Ív
L$$T$ D T$ ZCZ([fUWVSLD$։ˍD$1v ƀ~ tB9|$Xv),$L$ xؿ<[^_]1v D$T<[^_]ËD$T O<[^_]Ív D$ cv t$Xt41t$.ǀ|- t/9|$Xv,$L$ x1<[^_]OkWVS@Ët$P|$Tu 1@[^_Ív tlD$< |$X |$< tPD$=D$ \$D$ D$192u9r[^_[^_Ív UWVSLt$`\$d\$4$ F 1F$D$4 x FD$8ntt$2\$8 5 )ыl$ H R ` j v 6 F Z h v @ N ^ n & : L h ~ ( 6 H X n ~
& . 6 > H R ` j v 6 F Z h v RegCloseKey RegCreateKeyA RegOpenKeyExA RegQueryValueExA RegSetValueExA { CreateDirectoryA DeleteCriticalSection EnterCriticalSection ExitProcess GetEnvironmentVariableA GetFileAttributesA GetLastError GetModuleHandleA AGetProcAddress InitializeCriticalSection InterlockedExchange IsDBCSLeadByteEx .LeaveCriticalSection 1LoadLibraryA \MultiByteToWideChar SetCurrentDirectoryA &SetEnvironmentVariableA tSetUnhandledExceptionFilter Sleep TlsGetValue VirtualProtect VirtualQuery WideCharToMultiByte 7 __getmainargs A __mb_cur_max M __p__environ O __p__fmode c __set_app_type _cexit _errno
_iob _onexit _setmode Gabort Natexit Patoi Scalloc \exit _fclose jfopen lfputc qfree yfwrite }getenv localeconv malloc setlocale signal strcat strchr strncpy strrchr vfprintf wcslen E CoTaskMemFree < SHBrowseForFolderA X SHGetFolderPathA e SHGetPathFromIDListA ShellExecuteA P CreateDialogParamA DestroyWindow DispatchMessageA GetDlgItem %GetMessageA MessageBoxA PeekMessageA SendMessageA `TranslateMessage t InternetCloseHandle InternetOpenA InternetOpenUrlA InternetReadFile ADVAPI32.DLL KERNEL32.dll ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( msvcrt.dll < OLE32.dll P P P P SHELL32.DLL d d d d d d d d d USER32.dll x x x x WININET.DLL %@ %@ @ @ @ @ f
SO ( f
SO ` x f
SO L f
SO \ f
SO l f
SO | f
SO f
SO 8 f
SO f
SO f
SO P R O G R E S S h YH ! $ % t, (B n ( v 8 w L ( -+% 3.+9,5;;+8U<+9c<+9i<+9i<+8c;+7Y9,5I6.0520*#1/)-+$ U=RqPm~Xy]`aa`]Y{xTtnNjV>R7,23?*<tPoWZ\[YYYZZ[\_hId`C]nNjgHc`C]cF_tRp߆XWZvRrtPpXz`uRq?)<C>+<]WqNm )>*=?)<-R8OspK CSSSuyOszPt}7Ug;BBBxxxeMbhSfӒҁ7W iiiOOOp}rrrGGGlll???5q
~~~rYYYFFFppp߃iSf~ gggwww퍊uMpdKaMMMk/]]]VAT_dF`^^^gxxxQllllllf\e|z|cccqW ( @ # #" )'%,)! ,*& /+$
1.'/.(.,*2-(30'31'31'30'2-(.,)/.(0.'.+$
,+' *( )(#%" )(! /-(20*)4/-;9-5_;+7}<+9<+:=*:=*;=+:=*:=+:=+:=+:=+:<+9<,8;,7:,6{8.3i50/O31+C31+;20*320*)0.&)' 2-*!;,7E0B[?XlLhyVu]}adfgggfec`\|zXvsRojKg_B\P7M@-=;-650.[31+?.-'C-AtRpgd`][[\\\\\\\\\\]^`cfevTrQ8N<*:k&$ ?*< Z>VcWXYYZZZ[[[[\\\\\\\\\\\_gfGb?*=Y?)<V;ScWWY\]^]ZWWWWWXXXYZ[[\\\\gL4JH0Fŏge^wUslMieGbaD^cF`lNi^}`WWWWWW^bb`][[\dZ>W?)< ?*=;D-BA+?>*=}>**<7>*)=?)<>*=/?*=jLg^WWWWeiJeW;TV;S^B[mMi[{fdfX=U>)=K3HˏeWWW`bE_>*=G>)<>)=>*=?)<;?) K ?*<Q?PG7w5)3ZWWV~I3G]]],,, % =iddd? {eMMMT7PWWZ;Vvvvc鍍aaaKKKcg{{{MMMCCC6,4V~U}706eee_YYY;@@@ edewNqeB`
NNN/$$$ hhh^=ZB+? u ###111Q5M3$1*** ccc] N3K6+5 C&&& X9T6+5 'eiiiwwwmGh3$1]]] UUU=7*=% E3%%%888{jyjVhbbb k%NNNdddXXX...VVVSU~~~}
1E; ( 0 ` *%$$$ 2).-"/-) **% ''' )%% 5'% 4.# 22" 22" 22" 22" 4.# 5'% *&& ((& ++& .-) .."/) $$$*%!%#*%" -,%.+%1.)0-) 1/( 1/*#10*'20))20)-30+/30+130,740,930,941,951,741+741+741+531+520*531*321+330+120+/20)+20))1/+'2/*#0/' /-)0.(.,&/.%'&" '"
)( .-'1/))20*331+;6/0Q:,6u;+8=+:=*;=*;>*<>*<>*<>*<>*<>*<>*<>*<>*<>*<>*<>*<>*;>*;=*;=+:<+9<,8;,7:-58/3s51.Y41+O32+K31+G31+A31+;21+31/('/.''% /-&2/)38-3m<+9?**;I1FiIe_klifdb``_^^^^^__``abcefhikmkauSq_B\G0E>*;:,630+30/) ('"
>))<:(6 ?*<
A+?g^XXYYZ[[[[\[\\[\\[\\[\\[\\[[\[[\[\^gkdEa?*=>)=
?); @+>g[WWWWWWWWWWXXXXYYYZZZ[[[\\\\\[\\\\\\_lZ>W?*<{?(??)=߉c]V~V~WY\_abba^ZWV~WV~V~V~V~V~WWWWWXYZ[[[[\[[\c]~?)=@);?)=zVvhfjmkd\|yWuuSprQnsSoyXuckcXWV~WWWWWV~WWZ]][YYZ[\[\^hA+??)<
>*=eN4KpOlhIeZ>WM3JC,@?*=>)*<>)=>)<>**<[?*=3?)<=,<?*='?*=lNifV~VWVVWafZ>WC-A?*=>*G0ET9QfGb{Wvhkfce?*=>)=>*=5N5KkWWWV~WXlR8P>*=?*<<(<<*<?)=
>*= ?)>> CCC '''nnnwNr<': CCC 9 uLp1 /444 iU zPu- + OmBBB ZZZT{1 / 3%yyy V~=(: +++7$5WR6OUUUOOO ***
i UUU...c@^WrJm 333\\\9OOOU|WV} YYYqqq )))
dA`WWWaE^,,,))) aaa rrr---q
PPPRRR
]DZZV~VZd>>>uuuEEE g#$$$::: a c6$4yWu`V~WegJc<(: y 襤FFF ?*=YW=TiX^gD.B>*= eř Gp`n @*=vVrljU;S>*=W㸸՜ wwwƥS@QT:QJ2GZHX?yooo /// hhhľggg 222 --- --- 'dddHHH<<*;>*<>*<>*<>*<>*<>*<>**<>*<>*<>*<>*<>*<>*<>*<>*;=+:=+:<+9;,7:-58/2u51.]41+U41+S32,O41,M31+I31,C31+?31+72/)/10)#/,'&&
.+%2/()30*=5/.U;,7=+:>*XT9QM3JF.CA+?@*>?*=>*<=+:;,78.251-c41+]32,Y31+S31+I20*;0/)',*#.*$6-03=+9>*>*<<+98.2s31,K30+A21*3//)!+(#;)7)>**)<>);_?*<?**<[?*<?*)=?*=!?); ?))=kC-A_lhayVukKg^@ZS8PJ1GB,??*=>*<>)=?*=?*=?)<@+>K4IaF^`~mbWWWWWWWWWWWXahlnnlkgc_ZYZ[\\\kuRq?*=?*=?*<?*=B,@J1HE-B?*=>*=?)=>)*<_?)*<9>)=+?*>%?*='?)<3?*)=u?*<@+>cG`l`WWWWWWWWW\lk\}oNkhHdhHdmMjvTr^glnkf`\\[ksQo>)=>)=>)=?*<_>*<{>**<9>*= @)=@+>>)=Q?*=rRnkXWWWWWWWZm`P6M?*=>)<>)<>)=>*=>*=?*=C,AN5L_A\uSqcmmicmkKg?)=?)=>*=T:QnZWWWWWWWfhI1G>*=?*<9>)<
>*= >*=?*=-?)<[?)<>*)<@*;?)=?*=U?*I1FK2H?*=gWfS- U ] /. .>*<\@YnZWWWWWW[nY=V>)<?)=?**<{>*Z EEE$$$AAAwwwV}N3J yyy 777{{{U}C+@'''|||
tttV}=(:333 uϭ
aaa#"V~=':333\\\ ***[ ___;;; CCC2!0WB+?'''+++ FFF?
H/EWO3K ccc'{ ^^^999eB`Wb@] S }RxWzPt=== 3333 bbb'''___///4!1V~WV} ___EEE HHH000iii ### iEeWWWG.DDDD<<)=?*=rRnjWWXloPk?)=>*< ? 7[ ;;;}]ppp xxx'?**<m###
VVV bbbs?))=N:L/ Y{{{ W BBBtn^l )))_ CCC SSSyyy???
wwwGIKKK qqq oaaa777 AAAtttCS7-QskI! ( <872200 ,,, +++ +++ +++ &&& %%% %%% ### """ #"" +!! -!! 8!! 8)! 8*! 6.
66
55
33
33
33
33
33
33
33
33
55
66
6.
8*! 8)! 8!! .!! ,"" #"" """ $$$ %%% %%% ''' +++ +++ +++ --- 22 22871 ,,)) '''### " 4' 21 ..& .,+ ,,)
((%
%%%$$$/%#1/!00 --$.,(2))3-(11'00&..%--$,,+,++,**++*-+)3+)4+)2+(2+'2.'31'21&10&10&10&11&10&10&10&10&21&31'2.'2+'2+(4+)3+).+)++*,**,++,,'--$//%00&11'3-(-*)-,(.. 00 1/!.%#$$$&&%
))'
,,)
.,+ .." 21 ,& ###'''** 1 7!--' ))) $$$ &
00
2,)/+'--&))).('1.$--$/,)3-)11'//%-,+ 0., 2.* 0.( 3/'!10%#40.*%1/*%0/)%2/('1/*'00*'//*)1/,)2.+)40+)30++30*+30*+21)+11)+21)+41(-41(-30*-30*-30*-32*-30*-30*-30*-41*-41(-41(-21)+11)+21)+30*+30*+30++40+)3.+)1/,)00*)1/*'2.*'0/('00)%10+%3/*#10.%!3/'!1/( /.* 0., .-+ //%22'4-),,&--$1+$)''))%--%1,)..(11
(!! %%% +++ // !! $ )&&&$# .- ++'
'&%0'!-,'1-&-,&0*)1/& 2-) 10) 0/)!1.*#2/*%0/('20()21*)1/*+//*-30,-21+/31+131*122)320)511+530*73/*720*931,951,941,;40,=42,?32,A31,C41,C30+C30+C30+C30,E21-E41-C51-C51-A51-A41,A40,A42,A40,A40,A41,A41,?41,?51,?31,?11,?21*?20*?20*?21*=32*=32+=33+;31+;40,;40,;31,921,93/+730+720*510+521)532)331*131+120+/3.*-00*+20*+10))3/')10)'20+%1.*#0/(!1.* /.% 0/&-+*--&2/(.,'-'!'&%,,(
2+ & && "((( /""
--'+)'.+%11(0-* 2.(!10)#20)'1-*)2/*+30)-30*/1/+340-331+721*731*930,;20+=40*?31,?32,A30,G7//W7.2c8-5o:-6{:-6;,7<+8=+9<+9=+9=+:=+:<+:<+:=+:=+9=+9=+:=+:=+:=+:=+:=+:=+:=+:=+:=,9=,9=+8<,8<-8;-7<.7<-5:.59.4w8.3q7.1i6.0a4.-U41+O42+O32+O21+M22,M33,M32,K42-K40-K31,I42+I40+G41,G30+E31)E32+C22+C42,A41,?40+?10+=30*;31*931*731+540+320+310(/21(-30++1.*'00*%11/)!--* 22(/,#,*#.."+#
++ % (( **".-#-,'00( /.)%1.'+2/*/20*130)510*730+;31+=21*?40,A51+E60.Q7/2_8.4m9-4y:,6<,8=+:>+;>*<>*<>*<>*<>*<>*<>*<>*<>*<>****<>*<>*<>*<>*<>*<>*<>*<>*<>*<>*<>*<>*<>*;=+:=+:<,9<-7:.69-59-49.3y8/2s701k61/a50,Y41+U42,S33,S42,Q41-Q51+O42,M30+M41*K22+I33,G41,E31+C40*A22*?31+=30,;20+731*520+120+-2.()0-(%1.( .-(/+$,)$''
(#" ,,!//%/.'!/.('00+/20,511+;31+?21+C32+E42+I31+K31-S8.2q<,7=+9=+;>*;>*<>*)<>*<>*<=*;=+:=+:<,9;-79.5800u41,_41,[52,[41+Y42,Y33-W33+U41,U42,S41+Q41+O32,M42,K40+I41+E31,C31+?10)93.)522)-11*'//) 2*(((#&&
### -&!0.&10(!3.(+21(521)=22+E21+I31,Q6/0e:-4<,8=*;>*XX;UT9QP5MM3JJ1GG/DD-BA+>?*=?*=?*=?*=?*=?*=?*=?*=?*=?*=?*=?*=?*=>*<=+:;,7:-58/2{62-g42+_41,_52,]32,]32+[42,Y32,W32+U32,S31+O31+I31,C21*=3/*310*)..( **&*& '' ! ** .-)10)%2/(/30*;30+C5/-S8-4u=+9>*;>*<>*?*=?*=?*=?*=?)=>)<>*;=+;<,89.470/o51-e52+_41+]42,[33+Y41+W41+S31,O41+I31+A20)92/*//,(#--#-) $$! $$$ ,(!0,'1/(#2.)-5/-E;,7=*;?*=?*=?*=?*=@*=H0EU9RcC_tQpZ|ejnoooooooooooooooooonmmmmmmmmmmmmmmnnooooooooooooooooooooooonljhc\}xTtoMkcC_Y*<=+::-6700k31,Y31+U32,Q31+O31+K31,E32+=3/*500)+//'!--&,% (( ""+%%
/-"3.+ ;*7]>*;>**<>*;<+88.2m41-K30+A21*=3/+922*121()11*!-+))%%(( + 4),=*;y>*=?*=?*=C-AW:SuQqclooooonlifdb`^\ZZZ[[[[\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\]^_`acdefhjkmoooooooonjbxUtcD_Q6N@*>?*=?*=?*=>*<=*:8,5[10)+0.)'20&!/.)/,&((%((# "" $ >*;>*?*=>)<>*<<*;8*330*#''#.- "" =*:3?*)<<(87 A+<?*)<>)<>())=>)=?*<@+>gFcdihe_YzsOneDbX*=>)=>)=?*=?*=?*=?*M2IW9SV9RN4KG/E@*>?*=?*=?*=?*=?*=?*=?*=?*=?*=?*=?*=>*=>*)<>*=u>*=i>*=]?)=O?*>I?*>I>*=K?*)<]>*=m>*=}?*<>)*)=?*)<>*=>*=?)=?)=>)<>)*<+?*= ?*=>*=>*< @*9<&8=2=?*<>)<?(>?)=W?*Y?Vgnm[WWWWWWWWWWWWWWWWWWZhnomcxStaB^R7OI1FF/DF/DF/DF/DH0EL3JS8P]>YjIfvSr[|bhlnooonmjd^\\\[ZhojQ7N?*=>)=>)= =)=>)==?))<>)*<>**=G>*=-@)=@+>?*=O>)=?*=@+>fIcnneWWWWWWWWWWWWWWWWWXgookpMlP5M@+>?*=?*=?*=?*=?*=?*=?*=?*=?*=?*=?*=?*=?*=D-AL2IW;TdE`uQp_jnoooonjfb\XjohK2I?*=?*=?*=?)<?*< ?*= ?*= >*<?*<>,;>)<%>*=>*?*=?*=?*=?*=>)<>))=>**=>*=?*=?*=?*=?*=?*=@*>A,?K1HaA]uQp_inoononjnoaF/D?*=>)<=%=='=>*=o>*=?*=rQoon]WWWWWWWWWWWWWWWYloldEaA+??*=>*=?**=7?*=M>*=i?*<>)<>**K2HZ=WsOo`innooonwTsB,@?*=?)<>+>1>*=?*=aD^no`WWWWWWWWWWWWWWWcon|WxB,@?*=?)=>*=I>+9?)<;>*)=]?(?@*; ?*=#?)=G?*=?*=?*F.CO5LY?*=>) >*<7?*?*=?)<C,C?*=?)=%?**)<>*=?*=kZj?7 U } = >*>>*=?*=?*=]~om[WWWWWWWWWWWWWWaoolJh?*=?*<>*[WWWWWWWWWW^=Z +++ QDDD +++KKKyyy!q ```
1 /V~WWWWWWWWU}'% *** !fff BBBxxx 111KKKeeeQQQ >>> sKnWWWWWWWW]=Y MMM aBBB IIIGiii '''WWW999CCCrrr N3KV~WWWWWWSy2 0 www M\\\---Y+OOO ^^^]]] , *~RxWWWWWWoHj
777yyy ***777 888{M'444 ccc
uuu>>> sKnWWWWWWH/D
kkk ^^^i??? W) %
`?\WWWWWSz """... [[[S / ZZZ BBB ?)>> AAAHHH rKmWWzPu ---!!! S TTTPPP --- T{WWT{#! !!!
E3M RRR 5"2WWWW4"1 aaa
7 JJJ MMM U7QWWWWI0F ###)!!! @@@BBB KKK pIkWWWWdB` {{{ :::... +++vvv
(&}QwWWWWyPt
GGGMMM QQQ
wOOO """ I/FV~WWWWSz&$ gggU||| zzz |||333 tLoWWWWWV~I/E QQQ HHH jjjWWW= kkk &&& 3!0V~WWWWWWfCb HHH ===$$$ o $$$ddd JJJ
jEeWWWWWWWU|'% EEE NNNLLL jjj ;'9TzWWWWWWWW]?YSSS GGG~~~ 3[ jjj醆{
yOtWWWWWWWWW^& % 666 1! ### s Z>>fffgggFFF T=Qk^WWWWWWWWWfnhA-? ::: XXX 9PPP kkky O B.?kobWWWWWWWWYmowXsB-@4#3 bbb999 KKKUUU gggW K
c ;'9L4JeoiWWWWWWWWdokY@V?*=>*<; nnn !!!G\\\ 6667 + 7 9 - >)*==*= q rrrO000 FFF/>)=7>***=?*=lNhnncWWW]lolY?V?*=?*=?)=OG~~~ lll+[VVV qqq}@+;?)>*=>*<=*<{{{ SSSq=== ]]]3?)>>7 ?*<?*>> E
L8J/?*=?*<@+>U:RuQp\~{Uv_A\E.C?*=?*=?*=@'> 5### 7/RRR 888S@Q?*=?*=?*=?*=?*=?*=?*=?*=>)=M3M)QMMM BBBC5uuu PPPvguL8JB-@?*=?+=H4FYGWggg UUUI/+++ CCC»WWW I%ddd GGGXXX$$$
EEE/
DDD ???YYYqqquuu^^^JJJ... '''!;QQQ
333g
!iii CCC9%fff::: +++MMMK 7ZZZ777 ,,,KKKlllYw?7uK!Ek{W-
Ȑ J D o w n l o a d i n g d e p e n d e n c i e s M S S h e l l D l g P
m s c t l s _ p r o g r e s s 3 2 X 2 ) C a n c e l P
P l e a s e w a i t . . . P - 1 . 4 0 / 3 2 . 0 0 M B h 00 % @@ (B ( .eh_frame gpodder-3.1.2/tools/win32-launcher/folderselector.c 0000664 0001750 0001750 00000011516 11751103635 021642 0 ustar thp thp 0000000 0000000
#include "gpodder.h"
#include "folderselector.h"
#include
#include
#include
/* Private function declarations */
void
UseFolderSelector();
int
FolderExists(const char *folder);
void
UseFolder(const char *folder);
void
SaveFolder(const char *folder);
const char *
RegistryFolder();
const char *
DefaultFolder();
int
AskUserFolder(const char *folder);
void
DetermineHomeFolder(int force_select)
{
if (force_select) {
/* Forced selection of (new) download folder */
UseFolderSelector();
return;
}
if (getenv("GPODDER_HOME") != NULL) {
/* GPODDER_HOME already set - don't modify */
return;
}
if (FolderExists(RegistryFolder())) {
/* Use folder in registry */
UseFolder(RegistryFolder());
return;
}
if (FolderExists(DefaultFolder())) {
/* Save default in registry and use it */
SaveFolder(DefaultFolder());
UseFolder(DefaultFolder());
return;
}
if (AskUserFolder(DefaultFolder())) {
/* User wants to use the default folder */
SaveFolder(DefaultFolder());
UseFolder(DefaultFolder());
return;
}
/* If everything else fails, use folder selector */
UseFolderSelector();
}
void
UseFolderSelector()
{
BROWSEINFO browseInfo = {
0, /* hwndOwner */
NULL, /* pidlRoot */
NULL, /* pszDisplayName */
"Select the data folder where gPodder will "
"store the database and downloaded episodes:", /* lpszTitle */
BIF_USENEWUI | BIF_RETURNONLYFSDIRS, /* ulFlags */
NULL, /* lpfn */
0, /* lParam */
0, /* iImage */
};
LPITEMIDLIST pidList;
static char path[MAX_PATH];
pidList = SHBrowseForFolder(&browseInfo);
if (pidList == NULL) {
/* User clicked on "Cancel" */
exit(2);
}
memset(path, 0, sizeof(path));
if (!SHGetPathFromIDList(pidList, path)) {
BAILOUT("Could not determine filesystem path from selection.");
}
CoTaskMemFree(pidList);
SaveFolder(path);
UseFolder(path);
}
int
FolderExists(const char *folder)
{
DWORD attrs;
if (folder == NULL) {
return 0;
}
attrs = GetFileAttributes(folder);
return ((attrs != INVALID_FILE_ATTRIBUTES) &&
(attrs & FILE_ATTRIBUTE_DIRECTORY));
}
void
UseFolder(const char *folder)
{
if (folder == NULL) {
BAILOUT("Folder is NULL in UseFolder(). Exiting.");
}
if (SetEnvironmentVariable("GPODDER_HOME", folder) == 0) {
BAILOUT("SetEnvironmentVariable for GPODDER_HOME failed.");
}
}
void
SaveFolder(const char *folder)
{
HKEY regKey;
if (folder == NULL) {
BAILOUT("Folder is NULL in SaveFolder(). Exiting.");
}
if (RegCreateKey(HKEY_CURRENT_USER, GPODDER_REGISTRY_KEY,
®Key) != ERROR_SUCCESS) {
BAILOUT("Cannot create registry key:\n\n"
"HKEY_CURRENT_USER\\" GPODDER_REGISTRY_KEY);
}
if (RegSetValueEx(regKey,
"GPODDER_HOME",
0,
REG_SZ,
folder,
strlen(folder)+1) != ERROR_SUCCESS) {
BAILOUT("Cannot set value in registry:\n\n"
"HKEY_CURRENT_USER\\" GPODDER_REGISTRY_KEY);
}
RegCloseKey(regKey);
}
const char *
RegistryFolder()
{
static char folder[MAX_PATH] = {0};
DWORD folderSize = MAX_PATH;
HKEY regKey;
char *result = NULL;
if (strlen(folder)) {
return folder;
}
if (RegOpenKeyEx(HKEY_CURRENT_USER, GPODDER_REGISTRY_KEY,
0, KEY_READ, ®Key) != ERROR_SUCCESS) {
return NULL;
}
if (RegQueryValueEx(regKey, "GPODDER_HOME", NULL, NULL,
folder, &folderSize) == ERROR_SUCCESS) {
result = folder;
}
RegCloseKey(regKey);
return result;
}
const char *
DefaultFolder()
{
static char defaultFolder[MAX_PATH] = {0};
if (!strlen(defaultFolder)) {
if (SHGetFolderPath(NULL,
CSIDL_PERSONAL | CSIDL_FLAG_CREATE,
NULL,
0,
defaultFolder) != S_OK) {
BAILOUT("Cannot determine your home directory (SHGetFolderPath).");
}
strncat(defaultFolder, "\\gPodder\\", MAX_PATH);
}
return defaultFolder;
}
int
AskUserFolder(const char *folder)
{
char tmp[MAX_PATH+100];
if (folder == NULL) return 0;
strcpy(tmp, PROGNAME " requires a download folder.\n"
"Use the default download folder?\n\n");
strcat(tmp, folder);
return (MessageBox(NULL, tmp, "No download folder selected",
MB_YESNO | MB_ICONQUESTION) == IDYES);
}
gpodder-3.1.2/tools/win32-launcher/gpodder.res 0000664 0001750 0001750 00000303634 11751103635 020626 0 ustar thp thp 0000000 0000000 h ( -+% 3.+9,5;;+8U<+9c<+9i<+9i<+8c;+7Y9,5I6.0520*#1/)-+$ U=RqPm~Xy]`aa`]Y{xTtnNjV>R7,23?*<tPoWZ\[YYYZZ[\_hId`C]nNjgHc`C]cF_tRp߆XWZvRrtPpXz`uRq?)<C>+<]WqNm )>*=?)<-R8OspK CSSSuyOszPt}7Ug;BBBxxxeMbhSfӒҁ7W iiiOOOp}rrrGGGlll???5q
~~~rYYYFFFppp߃iSf~ gggwww퍊uMpdKaMMMk/]]]VAT_dF`^^^gxxxQllllllf\e|z|cccqW ( @ # #" )'%,)! ,*& /+$
1.'/.(.,*2-(30'31'31'30'2-(.,)/.(0.'.+$
,+' *( )(#%" )(! /-(20*)4/-;9-5_;+7}<+9<+:=*:=*;=+:=*:=+:=+:=+:=+:<+9<,8;,7:,6{8.3i50/O31+C31+;20*320*)0.&)' 2-*!;,7E0B[?XlLhyVu]}adfgggfec`\|zXvsRojKg_B\P7M@-=;-650.[31+?.-'C-AtRpgd`][[\\\\\\\\\\]^`cfevTrQ8N<*:k&$ ?*< Z>VcWXYYZZZ[[[[\\\\\\\\\\\_gfGb?*=Y?)<V;ScWWY\]^]ZWWWWWXXXYZ[[\\\\gL4JH0Fŏge^wUslMieGbaD^cF`lNi^}`WWWWWW^bb`][[\dZ>W?)< ?*=;D-BA+?>*=}>**<7>*)=?)<>*=/?*=jLg^WWWWeiJeW;TV;S^B[mMi[{fdfX=U>)=K3HˏeWWW`bE_>*=G>)<>)=>*=?)<;?) K ?*<Q?PG7w5)3ZWWV~I3G]]],,, % =iddd? {eMMMT7PWWZ;Vvvvc鍍aaaKKKcg{{{MMMCCC6,4V~U}706eee_YYY;@@@ edewNqeB`
NNN/$$$ hhh^=ZB+? u ###111Q5M3$1*** ccc] N3K6+5 C&&& X9T6+5 'eiiiwwwmGh3$1]]] UUU=7*=% E3%%%888{jyjVhbbb k%NNNdddXXX...VVVSU~~~}
1E; % ( 0 ` *%$$$ 2).-"/-) **% ''' )%% 5'% 4.# 22" 22" 22" 22" 4.# 5'% *&& ((& ++& .-) .."/) $$$*%!%#*%" -,%.+%1.)0-) 1/( 1/*#10*'20))20)-30+/30+130,740,930,941,951,741+741+741+531+520*531*321+330+120+/20)+20))1/+'2/*#0/' /-)0.(.,&/.%'&" '"
)( .-'1/))20*331+;6/0Q:,6u;+8=+:=*;=*;>*<>*<>*<>*<>*<>*<>*<>*<>*<>*<>*<>*<>*;>*;=*;=+:<+9<,8;,7:-58/3s51.Y41+O32+K31+G31+A31+;21+31/('/.''% /-&2/)38-3m<+9?**;I1FiIe_klifdb``_^^^^^__``abcefhikmkauSq_B\G0E>*;:,630+30/) ('"
>))<:(6 ?*<
A+?g^XXYYZ[[[[\[\\[\\[\\[\\[\\[[\[[\[\^gkdEa?*=>)=
?); @+>g[WWWWWWWWWWXXXXYYYZZZ[[[\\\\\[\\\\\\_lZ>W?*<{?(??)=߉c]V~V~WY\_abba^ZWV~WV~V~V~V~V~WWWWWXYZ[[[[\[[\c]~?)=@);?)=zVvhfjmkd\|yWuuSprQnsSoyXuckcXWV~WWWWWV~WWZ]][YYZ[\[\^hA+??)<
>*=eN4KpOlhIeZ>WM3JC,@?*=>)*<>)=>)<>**<[?*=3?)<=,<?*='?*=lNifV~VWVVWafZ>WC-A?*=>*G0ET9QfGb{Wvhkfce?*=>)=>*=5N5KkWWWV~WXlR8P>*=?*<<(<<*<?)=
>*= ?)>> CCC '''nnnwNr<': CCC 9 uLp1 /444 iU zPu- + OmBBB ZZZT{1 / 3%yyy V~=(: +++7$5WR6OUUUOOO ***
i UUU...c@^WrJm 333\\\9OOOU|WV} YYYqqq )))
dA`WWWaE^,,,))) aaa rrr---q
PPPRRR
]DZZV~VZd>>>uuuEEE g#$$$::: a c6$4yWu`V~WegJc<(: y 襤FFF ?*=YW=TiX^gD.B>*= eř Gp`n @*=vVrljU;S>*=W㸸՜ wwwƥS@QT:QJ2GZHX?yooo /// hhhľggg 222 --- --- 'dddHHH<<*;>*<>*<>*<>*<>*<>*<>**<>*<>*<>*<>*<>*<>*<>*<>*;=+:=+:<+9;,7:-58/2u51.]41+U41+S32,O41,M31+I31,C31+?31+72/)/10)#/,'&&
.+%2/()30*=5/.U;,7=+:>*XT9QM3JF.CA+?@*>?*=>*<=+:;,78.251-c41+]32,Y31+S31+I20*;0/)',*#.*$6-03=+9>*>*<<+98.2s31,K30+A21*3//)!+(#;)7)>**)<>);_?*<?**<[?*<?*)=?*=!?); ?))=kC-A_lhayVukKg^@ZS8PJ1GB,??*=>*<>)=?*=?*=?)<@+>K4IaF^`~mbWWWWWWWWWWWXahlnnlkgc_ZYZ[\\\kuRq?*=?*=?*<?*=B,@J1HE-B?*=>*=?)=>)*<_?)*<9>)=+?*>%?*='?)<3?*)=u?*<@+>cG`l`WWWWWWWWW\lk\}oNkhHdhHdmMjvTr^glnkf`\\[ksQo>)=>)=>)=?*<_>*<{>**<9>*= @)=@+>>)=Q?*=rRnkXWWWWWWWZm`P6M?*=>)<>)<>)=>*=>*=?*=C,AN5L_A\uSqcmmicmkKg?)=?)=>*=T:QnZWWWWWWWfhI1G>*=?*<9>)<
>*= >*=?*=-?)<[?)<>*)<@*;?)=?*=U?*I1FK2H?*=gWfS- U ] /. .>*<\@YnZWWWWWW[nY=V>)<?)=?**<{>*Z EEE$$$AAAwwwV}N3J yyy 777{{{U}C+@'''|||
tttV}=(:333 uϭ
aaa#"V~=':333\\\ ***[ ___;;; CCC2!0WB+?'''+++ FFF?
H/EWO3K ccc'{ ^^^999eB`Wb@] S }RxWzPt=== 3333 bbb'''___///4!1V~WV} ___EEE HHH000iii ### iEeWWWG.DDDD<<)=?*=rRnjWWXloPk?)=>*< ? 7[ ;;;}]ppp xxx'?**<m###
VVV bbbs?))=N:L/ Y{{{ W BBBtn^l )))_ CCC SSSyyy???
wwwGIKKK qqq oaaa777 AAAtttCS7-QskI! ( ( <872200 ,,, +++ +++ +++ &&& %%% %%% ### """ #"" +!! -!! 8!! 8)! 8*! 6.
66
55
33
33
33
33
33
33
33
33
55
66
6.
8*! 8)! 8!! .!! ,"" #"" """ $$$ %%% %%% ''' +++ +++ +++ --- 22 22871 ,,)) '''### " 4' 21 ..& .,+ ,,)
((%
%%%$$$/%#1/!00 --$.,(2))3-(11'00&..%--$,,+,++,**++*-+)3+)4+)2+(2+'2.'31'21&10&10&10&11&10&10&10&10&21&31'2.'2+'2+(4+)3+).+)++*,**,++,,'--$//%00&11'3-(-*)-,(.. 00 1/!.%#$$$&&%
))'
,,)
.,+ .." 21 ,& ###'''** 1 7!--' ))) $$$ &
00
2,)/+'--&))).('1.$--$/,)3-)11'//%-,+ 0., 2.* 0.( 3/'!10%#40.*%1/*%0/)%2/('1/*'00*'//*)1/,)2.+)40+)30++30*+30*+21)+11)+21)+41(-41(-30*-30*-30*-32*-30*-30*-30*-41*-41(-41(-21)+11)+21)+30*+30*+30++40+)3.+)1/,)00*)1/*'2.*'0/('00)%10+%3/*#10.%!3/'!1/( /.* 0., .-+ //%22'4-),,&--$1+$)''))%--%1,)..(11
(!! %%% +++ // !! $ )&&&$# .- ++'
'&%0'!-,'1-&-,&0*)1/& 2-) 10) 0/)!1.*#2/*%0/('20()21*)1/*+//*-30,-21+/31+131*122)320)511+530*73/*720*931,951,941,;40,=42,?32,A31,C41,C30+C30+C30+C30,E21-E41-C51-C51-A51-A41,A40,A42,A40,A40,A41,A41,?41,?51,?31,?11,?21*?20*?20*?21*=32*=32+=33+;31+;40,;40,;31,921,93/+730+720*510+521)532)331*131+120+/3.*-00*+20*+10))3/')10)'20+%1.*#0/(!1.* /.% 0/&-+*--&2/(.,'-'!'&%,,(
2+ & && "((( /""
--'+)'.+%11(0-* 2.(!10)#20)'1-*)2/*+30)-30*/1/+340-331+721*731*930,;20+=40*?31,?32,A30,G7//W7.2c8-5o:-6{:-6;,7<+8=+9<+9=+9=+:=+:<+:<+:=+:=+9=+9=+:=+:=+:=+:=+:=+:=+:=+:=+:=,9=,9=+8<,8<-8;-7<.7<-5:.59.4w8.3q7.1i6.0a4.-U41+O42+O32+O21+M22,M33,M32,K42-K40-K31,I42+I40+G41,G30+E31)E32+C22+C42,A41,?40+?10+=30*;31*931*731+540+320+310(/21(-30++1.*'00*%11/)!--* 22(/,#,*#.."+#
++ % (( **".-#-,'00( /.)%1.'+2/*/20*130)510*730+;31+=21*?40,A51+E60.Q7/2_8.4m9-4y:,6<,8=+:>+;>*<>*<>*<>*<>*<>*<>*<>*<>*<>****<>*<>*<>*<>*<>*<>*<>*<>*<>*<>*<>*<>*<>*;=+:=+:<,9<-7:.69-59-49.3y8/2s701k61/a50,Y41+U42,S33,S42,Q41-Q51+O42,M30+M41*K22+I33,G41,E31+C40*A22*?31+=30,;20+731*520+120+-2.()0-(%1.( .-(/+$,)$''
(#" ,,!//%/.'!/.('00+/20,511+;31+?21+C32+E42+I31+K31-S8.2q<,7=+9=+;>*;>*<>*)<>*<>*<=*;=+:=+:<,9;-79.5800u41,_41,[52,[41+Y42,Y33-W33+U41,U42,S41+Q41+O32,M42,K40+I41+E31,C31+?10)93.)522)-11*'//) 2*(((#&&
### -&!0.&10(!3.(+21(521)=22+E21+I31,Q6/0e:-4<,8=*;>*XX;UT9QP5MM3JJ1GG/DD-BA+>?*=?*=?*=?*=?*=?*=?*=?*=?*=?*=?*=?*=?*=>*<=+:;,7:-58/2{62-g42+_41,_52,]32,]32+[42,Y32,W32+U32,S31+O31+I31,C21*=3/*310*)..( **&*& '' ! ** .-)10)%2/(/30*;30+C5/-S8-4u=+9>*;>*<>*?*=?*=?*=?*=?)=>)<>*;=+;<,89.470/o51-e52+_41+]42,[33+Y41+W41+S31,O41+I31+A20)92/*//,(#--#-) $$! $$$ ,(!0,'1/(#2.)-5/-E;,7=*;?*=?*=?*=?*=@*=H0EU9RcC_tQpZ|ejnoooooooooooooooooonmmmmmmmmmmmmmmnnooooooooooooooooooooooonljhc\}xTtoMkcC_Y*<=+::-6700k31,Y31+U32,Q31+O31+K31,E32+=3/*500)+//'!--&,% (( ""+%%
/-"3.+ ;*7]>*;>**<>*;<+88.2m41-K30+A21*=3/+922*121()11*!-+))%%(( + 4),=*;y>*=?*=?*=C-AW:SuQqclooooonlifdb`^\ZZZ[[[[\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\]^_`acdefhjkmoooooooonjbxUtcD_Q6N@*>?*=?*=?*=>*<=*:8,5[10)+0.)'20&!/.)/,&((%((# "" $ >*;>*?*=>)<>*<<*;8*330*#''#.- "" =*:3?*)<<(87 A+<?*)<>)<>())=>)=?*<@+>gFcdihe_YzsOneDbX*=>)=>)=?*=?*=?*=?*M2IW9SV9RN4KG/E@*>?*=?*=?*=?*=?*=?*=?*=?*=?*=?*=?*=>*=>*)<>*=u>*=i>*=]?)=O?*>I?*>I>*=K?*)<]>*=m>*=}?*<>)*)=?*)<>*=>*=?)=?)=>)<>)*<+?*= ?*=>*=>*< @*9<&8=2=?*<>)<?(>?)=W?*Y?Vgnm[WWWWWWWWWWWWWWWWWWZhnomcxStaB^R7OI1FF/DF/DF/DF/DH0EL3JS8P]>YjIfvSr[|bhlnooonmjd^\\\[ZhojQ7N?*=>)=>)= =)=>)==?))<>)*<>**=G>*=-@)=@+>?*=O>)=?*=@+>fIcnneWWWWWWWWWWWWWWWWWXgookpMlP5M@+>?*=?*=?*=?*=?*=?*=?*=?*=?*=?*=?*=?*=?*=D-AL2IW;TdE`uQp_jnoooonjfb\XjohK2I?*=?*=?*=?)<?*< ?*= ?*= >*<?*<>,;>)<%>*=>*?*=?*=?*=?*=>)<>))=>**=>*=?*=?*=?*=?*=?*=@*>A,?K1HaA]uQp_inoononjnoaF/D?*=>)<=%=='=>*=o>*=?*=rQoon]WWWWWWWWWWWWWWWYloldEaA+??*=>*=?**=7?*=M>*=i?*<>)<>**K2HZ=WsOo`innooonwTsB,@?*=?)<>+>1>*=?*=aD^no`WWWWWWWWWWWWWWWcon|WxB,@?*=?)=>*=I>+9?)<;>*)=]?(?@*; ?*=#?)=G?*=?*=?*F.CO5LY?*=>) >*<7?*?*=?)<C,C?*=?)=%?**)<>*=?*=kZj?7 U } = >*>>*=?*=?*=]~om[WWWWWWWWWWWWWWaoolJh?*=?*<>*[WWWWWWWWWW^=Z +++ QDDD +++KKKyyy!q ```
1 /V~WWWWWWWWU}'% *** !fff BBBxxx 111KKKeeeQQQ >>> sKnWWWWWWWW]=Y MMM aBBB IIIGiii '''WWW999CCCrrr N3KV~WWWWWWSy2 0 www M\\\---Y+OOO ^^^]]] , *~RxWWWWWWoHj
777yyy ***777 888{M'444 ccc
uuu>>> sKnWWWWWWH/D
kkk ^^^i??? W) %
`?\WWWWWSz """... [[[S / ZZZ BBB ?)>> AAAHHH rKmWWzPu ---!!! S TTTPPP --- T{WWT{#! !!!
E3M RRR 5"2WWWW4"1 aaa
7 JJJ MMM U7QWWWWI0F ###)!!! @@@BBB KKK pIkWWWWdB` {{{ :::... +++vvv
(&}QwWWWWyPt
GGGMMM QQQ
wOOO """ I/FV~WWWWSz&$ gggU||| zzz |||333 tLoWWWWWV~I/E QQQ HHH jjjWWW= kkk &&& 3!0V~WWWWWWfCb HHH ===$$$ o $$$ddd JJJ
jEeWWWWWWWU|'% EEE NNNLLL jjj ;'9TzWWWWWWWW]?YSSS GGG~~~ 3[ jjj醆{
yOtWWWWWWWWW^& % 666 1! ### s Z>>fffgggFFF T=Qk^WWWWWWWWWfnhA-? ::: XXX 9PPP kkky O B.?kobWWWWWWWWYmowXsB-@4#3 bbb999 KKKUUU gggW K
c ;'9L4JeoiWWWWWWWWdokY@V?*=>*<; nnn !!!G\\\ 6667 + 7 9 - >)*==*= q rrrO000 FFF/>)=7>***=?*=lNhnncWWW]lolY?V?*=?*=?)=OG~~~ lll+[VVV qqq}@+;?)>*=>*<=*<{{{ SSSq=== ]]]3?)>>7 ?*<?*>> E
L8J/?*=?*<@+>U:RuQp\~{Uv_A\E.C?*=?*=?*=@'> 5### 7/RRR 888S@Q?*=?*=?*=?*=?*=?*=?*=?*=>)=M3M)QMMM BBBC5uuu PPPvguL8JB-@?*=?+=H4FYGWggg UUUI/+++ CCC»WWW I%ddd GGGXXX$$$
EEE/
DDD ???YYYqqquuu^^^JJJ... '''!;QQQ
333g
!iii CCC9%fff::: +++MMMK 7ZZZ777 ,,,KKKlllYw?7uK!Ek{W-
8 0 P R O G R E S S Ȑ J D o w n l o a d i n g d e p e n d e n c i e s M S S h e l l D l g P
m s c t l s _ p r o g r e s s 3 2 X 2 ) C a n c e l P
P l e a s e w a i t . . . P - 1 . 4 0 / 3 2 . 0 0 M B L h 00 % @@ (B ( gpodder-3.1.2/tools/win32-launcher/gpo.exe 0000664 0001750 0001750 00000411016 11751103635 017751 0 ustar thp thp 0000000 0000000 MZ @ !L!This program cannot be run in DOS mode.
$ PE L 9$SO f l @ 8 .text \d f ` 0`.data H j @ `.rdata
l @ `@/4 x @ 0@.bss `.idata
| @ 0.CRT @ 0.tls @ 0.rsrc @ 0 US4@ t D$ D$ $ Ѓ $@ PF ! E ED$ @ D$ ED$D$@ $ @ _ @ uJ_ $@ L _ D$@ D$ @ $ _ $h $@ D$ p@ C$_ @ D$C0$v_ @ D$CP$b_ oUSE = w;= rL D$ $ /_ 1[ = tM= t= u뵐= t== uD$ $ ^ tdt$ и륐1vD$ $ ^ tJy$ иh$ иUD$ $ ]^ 9D$ $ A^ D$ $ %^ u
fU$ d@ |U$ d@ dU@ fUt@ U$ @ j RteD$@ $] tD$@ $ @ Ћ
D@ t1$)@ ' Rt*D$7@ $ t $D@ ø 말 U$ @ Qt%D$K@ $ t $ @ Ív UWVSLE E E܉D$D$ D$ D$d@ E$[] t
E܍UT$D$ @ D$ D$ D$ $ ] u< @ E° MԉH @ »@ މE @ E܉$\ Ee[^_]ÍL$qUWVSQ Z E E E E E Dž@ $@
E :EC ¸@ ։(uE E؋E;|E܉$ D$ D$$@
u3D$ D$ʐ@ D$@ $ [ $ [ D$ $ C D$ D$$Z D$\ $Z E} uD$/ $Z E} tNE $c u3D$ D$ʐ@ D$ @ $ ([ $ EZ $<@ % Eԃ} u;$ 1E} u$ E} tE$ Eԃ} D$ $ D$L@ D$p@ $ Z D$ D$$Y Dž° ЍPЉ»@ މD$ D$@ $u = u9D$ D$ D$ D$D$@ $ D$@ Eԉ$
Eȃ} u3D$ D$ʐ@ D$@ $ Y $ X D$,@ Eԉ$N
Eă} u3D$ D$ʐ@ D$<@ $ .Y $ KX D$b@ Eԉ$ E} u3D$ D$ʐ@ D$x@ $ X $ W D$@ Eԉ$ E} u3D$ D$ʐ@ D$@ $ X $ W D$@ Eԉ$X E} u3D$ D$ʐ@ D$@ $ 8X $ UW D$@ Eԉ$ E} u3D$ D$ʐ@ D$(@ $ W $ W D$O@ Eԉ$ E} u3D$ D$ʐ@ D$\@ $ W $ V EЋC @ D$ CD$$EЃ D$~@ $@ EЃE} u3D$ D$ʐ@ D$@ $ W $ 4V E$EЃD$@ $EЃt3D$ D$ʐ@ D$@ $ V $ U Eи eY[^_]aÐUx, ' )E E D$ D$ D$ D$ $ȓ@ ED$ D$ D$ D$ E D$E$o ED$@ E$BU E} E D$ D$ ( D$E$ u E UT$ D$ D$$T EE ߭ @ E ߭ @ \$\$ D$@ D$ $
D$D$@ p@ @$3T } E$#T E$$ E$ } t EÐU} t
$@ S J $E t9 $v b $% t $ $I 5 $j t $ $ UWVSLUĻ @ މEĉ$ E} u $ R @ ߉D$@ E$ u3D$ D$ @ D$8@ $ YS $ vR E$ $@ $@ J e[^_]U(} u -E$ E}tEt U} u3D$ D$ @ D$Ĕ@ $ R $ Q ED$$@ u3D$ D$ @ D$@ $ ]R $ zQ UWD} u3D$ D$ @ D$ @ $ R $ 8Q ED$D$E@ $ Q t3D$ D$ @ D$d@ $ Q $ P EE° MHPET$UT$D$ D$ D$@ $dQ t3D$ D$ @ D$@ $ AQ $ ^P E$Q }U8E E `@ t
`@ ED$D$ D$ D$E@ $ P t QEUT$D$`@ D$ D$ D$@ $kP uE`@ E$ZP EUWVS<@@ D$@@ D$ D$ D$ $ n t3D$ D$ @ D$ @ $ O $ O @@ E° MH@@ »8@
މ@@ e[^_]UWVS } u a»D@ G މED$$N D$ $ D$@ D$$ ruz Ív kĴ@ HuĴ@ $ȴ@ G PfĴ@ tĴ@ f$ȴ@ G RސQP= L$ r - = w) XYÐ D$,D$ D$(D$D$$D$D$ $ ÐVS$\$0t$4D$8T$@ hS(J uZ9Z ~uJ ZCZ([Ív
L$$T$ D T$ ZCZ([fUWVSLD$։ˍD$1v ƀ~ tB9|$Xv),$L$ xؿ<[^_]1v D$T<[^_]ËD$T O<[^_]Ív D$ cv t$Xt41t$.ǀ|- t/9|$Xv,$L$ x1<[^_]OkWVS@Ët$P|$Tu 1@[^_Ív tlD$< |$X |$< tPD$=D$ \$D$ D$192u9r[^_[^_Ív UWVSLt$`\$d\$4$ F 1F$D$4 x FD$8ntt$2\$8 5 )ыl$ R d x
8 N b z , < R b r
$ , 6 @ N X d n x 2 B V . > R d x
8 N b z , < R b r
$ , 6 @ N X d n x 2 B V RegCloseKey RegCreateKeyA RegOpenKeyExA RegQueryValueExA RegSetValueExA { CreateDirectoryA DeleteCriticalSection EnterCriticalSection ExitProcess GetEnvironmentVariableA GetFileAttributesA GetLastError GetModuleHandleA AGetProcAddress InitializeCriticalSection InterlockedExchange IsDBCSLeadByteEx .LeaveCriticalSection 1LoadLibraryA \MultiByteToWideChar SetConsoleTitleA SetCurrentDirectoryA &SetEnvironmentVariableA tSetUnhandledExceptionFilter Sleep TlsGetValue VirtualProtect VirtualQuery WideCharToMultiByte 7 __getmainargs A __mb_cur_max M __p__environ O __p__fmode c __set_app_type _cexit _errno
_iob _onexit _setmode Gabort Natexit Patoi Scalloc \exit _fclose jfopen kfprintf lfputc qfree yfwrite }getenv localeconv malloc setlocale signal strcat strchr strncpy strrchr vfprintf wcslen E CoTaskMemFree < SHBrowseForFolderA X SHGetFolderPathA e SHGetPathFromIDListA ShellExecuteA MessageBoxA t InternetCloseHandle InternetOpenA InternetOpenUrlA InternetReadFile ADVAPI32.DLL KERNEL32.dll ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( msvcrt.dll < OLE32.dll P P P P SHELL32.DLL d USER32.dll x x x x WININET.DLL "@ "@ @ @ @ @ j
SO j
SO X p j
SO j
SO j
SO j
SO 0 j
SO @ j
SO j
SO P ` h p % , (B @n ( hv L ( -+% 3.+9,5;;+8U<+9c7,5 U=RqPm~Xy]`uSq
?*<tPoWZ\[wSs `C]nNjgHc`C]cF_[BX
" "?)<C:08111111$%%!""000%%%+++555K CSSSu4$22!/TTTjjjVUU111DDDg;BBBxxxeMbhSfӒҁ7W iiiOOOp}rrrGGGlll???5q
~~~rYYYFFFppp߃iSf~ gggwww퍊uMpdKaMMMk/]]]VAT_dF`^^^gxxxQllllllf\e|z|cccqW ( @ # #" )'%,)! ,*& /+$
1.'/.(.,*i )(! /-(20*)4/-;9-5_;+7}<+9<+:=*:=*;=+:C8@9::-./ 2-*!;,7E0B[?XlLhyVu]}adfgV>S
C-AtRpgd`][[\\\eJa!""888 ''&*))
...221 !"*+*79;?*< Z>VcWXYYZZZ[[pVm +*)$$$,,+ (''!! 00.%%$/// $$%$#" ?)<V;ScWWY\]^]ZW`E] $ #H0Fŏge^wUslMieGbaD^cF`lNi^}W>T ?)< ?*=;D-BA+?>*=}>**<7>*)=?)<>*=/?*=G8E$$#543...777
&%%CB@@?>100+,,322
:;;;<=4,2>)=H=F@?>?BB ;;;./0##$:::999>??565(('@*=% E3%%%888{jyjVhbbb k%NNNdddXXX...VVVSU~~~}
1E; ( 0 ` *%$$$ 2).-"/-) **% ''' )%% [!%#*%" -,%.+%1.)0-) 1/( 1/*#10*'20))20)-30+/30+130,740,9PNMBCE***EEE g
)( .-'1/))20*331+;6/0Q:,6u;+8=+:=*;=*;>*<>*<>*<>*<>*<>*<8/5-./&&& ))) k /-&2/)38-3m<+9?**;I1FiIe_klifdb``_^^^7%5
m >)g[WWWWWWWWWWXXXXweuLMNDDDMLJ./.***DEFPLI ***EGHEEDNNL..-SRQ(&&EEE52/DFE"##)('KLMRRP9::
?(??)=߉c]V~V~WY\_abba^ZWV~9&6
@);?)=zVvhfjmkd\|yWuuSprQnsSoyXuckc6$4 #"?)<
>*=eN4KpOlhIeZ>WM3JC,@?*=>)*<>)=>)<>**<[?*=3?)<=,<?*='?*=1(0 /0/*+,*))... 0/.CCC***
210244++*-./ 234***+-.>>?345#">)=>*=5A8?///333899:==567788***((( $$%665:<=GFDFFE"#$ 553567 10.:08 ?*<7KBJ++)'((-02 )*)///
!!!))* qrs m $"^SYIHGRTT]ZXXURTSQ121 >>>MPQFIJ .-,LMN244555---)('@CC676))'EGH,,, 111
[[[ ;*(*(*(*(! DDDKKKKKKKKK444 (((QQQQQQPPPDDD ZZZSA ͏* (V~WWV~0 .kkk!!! ;abbb...---U]]]{{{sKnWWkFf 9OOO0003vvv IIIppp}}}aaaI0FWW5"2 (((NNNk7ZZZ ||| '%WT{
---///;=== U|iEe+++
333***aaa""" SyO3Kaaa>>> CCC '''nnnwNr<': CCC 9 uLp1 /444 iU zPu- + OmBBB ZZZT{1 / 3%yyy V~=(: +++7$5WR6OUUUOOO ***
i UUU...c@^WrJm 333\\\9OOOU|WV} YYYqqq )))
dA`WWWaE^,,,))) aaa rrr---q
PPPRRR
]DZZV~VZd>>>uuuEEE g#$$$::: a c6$4yWu`V~WegJc<(: y 襤FFF ?*=YW=TiX^gD.B>*= eř Gp`n @*=vVrljU;S>*=W㸸՜ wwwƥS@QT:QJ2GZHX?yooo /// hhhľggg 222 --- --- 'dddHHH<<>> 3 ,%# ,*#.-(1-'0.( 2/)#2/*'20++20*/20*320+531,96//G7.2U8-3_:,5k:,6q:,6u:-6}:-6}:,6kfeffiTVVGJKKJI////// 5)' .-%//)%10*/20+931+?31,E8.2c;,6<+9=*:>*;>*<>*<>*<>*<>*<>*<>*****==898%%%''' 367430
>@A===(%#&)++,,*+,$"!"""<<<))) +)& 875HHH*+)%(*:::'&?*=fGbnXWWWWZ]`bdefedc_[WWW / -@);?)=X