def find_app_icon(uri=True):
"""Find suitable bleeter application icon
# Test mocks
>>> from mock import Mock
>>> glib.get_user_cache_dir = Mock(return_value="test/xdg_cache_home")
>>> sys.prefix = ""
>>> sys.path.insert(0, "non-existent-path")
>>> find_app_icon()
'file://test/xdg_cache_home/bleeter/bleeter.png'
>>> find_app_icon(False)
'test/xdg_cache_home/bleeter/bleeter.png'
# Test with no personal icon
>>> glib.get_user_cache_dir = Mock(return_value="None")
>>> find_app_icon()
Traceback (most recent call last):
...
EnvironmentError: Can't find application icon!
# Test with local icon
>>> sys.path.insert(0, "")
>>> find_app_icon() #doctest: +ELLIPSIS
'file://.../bleeter/bleeter.png'
:param bool uri: Return a URI for the path
:rtype: ``str``
:return: Path to the application icon
"""
icon_locations = [
"%s/bleeter.png" % os.path.abspath(sys.path[0]),
"%s/bleeter/bleeter.png" % glib.get_user_cache_dir(),
"%s/share/pixmaps/bleeter.png" % sys.prefix,
]
for icon in icon_locations:
if os.path.exists(icon):
return "%s%s" % ("file://" if uri else "", icon)
raise EnvironmentError("Can't find application icon!")
def __init__(self, ui_dir, files):
# Will store here associations between file names and list of wpt images
self._wptmap = {}
self.localtz = LocalTimezone()
self.recent = gtk.recent_manager_get_default()
self.wTree = gtk.Builder()
self.wTree.set_translation_domain('gpxviewer')
self.wTree.add_from_file("%sgpxviewer.ui" % ui_dir)
signals = {
"on_windowMain_destroy": self.quit,
"on_menuitemQuit_activate": self.quit,
"on_menuitemOpen_activate": self.openGPX,
"on_menuitemZoomIn_activate": self.zoomMapIn,
"on_buttonZoomIn_clicked": self.zoomMapIn,
"on_menuitemZoomOut_activate": self.zoomMapOut,
"on_buttonZoomOut_clicked": self.zoomMapOut,
"on_menuitemAbout_activate": self.openAboutDialog,
"on_checkmenuitemShowSidebar_toggled": self.showSidebarToggled,
"on_menuitemShowStatistics_activate": self.showStatistics,
"on_buttonTrackAdd_clicked": self.buttonTrackAddClicked,
"on_buttonTrackDelete_clicked": self.buttonTrackDeleteClicked,
"on_buttonTrackInspect_clicked": self.buttonTrackInspectClicked,
}
self.mainWindow = self.wTree.get_object("windowMain")
self.mainWindow.set_icon_from_file("%sgpxviewer.svg" % ui_dir)
self.mainWindow.set_title(_("GPX Viewer"))
i = self.wTree.get_object("checkmenuitemCenter")
i.connect("toggled", self.autoCenterToggled)
self.autoCenter = i.get_active()
self.ui_dir = ui_dir
self.map = osmgpsmap.GpsMap(
tile_cache=os.path.join(
glib.get_user_cache_dir(),
'gpxviewer', 'tiles'))
self.map.layer_add(
osmgpsmap.GpsMapOsd(
show_dpad=False,
show_zoom=False,
show_scale=True,
show_coordinates=False))
self.wTree.get_object("hbox_map").pack_start(self.map, True, True)
sb = self.wTree.get_object("statusbar1")
#move zoom control into apple like slider
self.zoomSlider = MapZoomSlider(self.map)
self.zoomSlider.show_all()
a = gtk.Alignment(0.5,0.5,1.0,1.0)
a.set_padding(0,0,0,4)
a.add(self.zoomSlider)
a.show_all()
sb.pack_end(a, False, False, padding=4)
#animate a spinner when downloading tiles
try:
self.spinner = gtk.Spinner()
self.spinner.props.has_tooltip = True
self.spinner.connect("query-tooltip", self.onSpinnerTooltip)
self.map.connect("notify::tiles-queued", self.updateTilesQueued)
self.spinner.set_size_request(*gtk.icon_size_lookup(gtk.ICON_SIZE_MENU))
sb.pack_end(self.spinner, False, False)
except AttributeError:
self.spinner = None
self.wTree.connect_signals(signals)
#add open with external tool submenu items and actions
programs = {
'josm':N_('JOSM Editor'),
'merkaartor':N_('Merkaartor'),
}
submenu_open_with = gtk.Menu()
for prog,progname in programs.iteritems():
submenuitem_open_with = gtk.MenuItem(_(progname))
submenu_open_with.append(submenuitem_open_with)
submenuitem_open_with.connect("activate", self.openWithExternalApp, prog)
submenuitem_open_with.show()
self.wTree.get_object('menuitemOpenBy').set_submenu(submenu_open_with)
self.trackManager = _TrackManager()
self.trackManager.connect("track-added", self.onTrackAdded)
self.trackManager.connect("track-removed", self.onTrackRemoved)
self.wTree.get_object("menuitemHelp").connect("activate", lambda *a: show_url("https://answers.launchpad.net/gpxviewer"))
self.wTree.get_object("menuitemTranslate").connect("activate", lambda *a: show_url("https://translations.launchpad.net/gpxviewer"))
self.wTree.get_object("menuitemReportProblem").connect("activate", lambda *a: show_url("https://bugs.launchpad.net/gpxviewer/+filebug"))
self.tv = gtk.TreeView(self.trackManager.model)
self.tv.get_selection().connect("changed", self.onSelectionChanged)
self.tv.append_column(
gtk.TreeViewColumn(
"Track Name",
gtk.CellRendererText(),
text=self.trackManager.NAME_IDX
)
)
self.wTree.get_object("scrolledwindow1").add(self.tv)
self.sb = self.wTree.get_object("vbox_sidebar")
self.hideSpinner()
self.hideTrackSelector()
self.lazyLoadFiles(files)
self.map.show()
self.mainWindow.show()
import os
import glib
import shutil
PROGRAM_NAME = "deepin-individuation"
homedir = os.path.expanduser("~")
lastdir = homedir
data_home = glib.get_user_data_dir()
data_home = os.path.join(data_home, PROGRAM_NAME)
config_home = glib.get_user_config_dir()
config_home = os.path.join(config_home, PROGRAM_NAME)
cache_home = glib.get_user_cache_dir()
cache_home = os.path.join(cache_home, PROGRAM_NAME)
data_dirs = os.getenv("XDG_DATA_DIRS")
if data_dirs == None:
data_dirs = "/usr/local/share/:/usr/share/"
data_dirs = [os.path.join(d, PROGRAM_NAME) for d in data_dirs.split(":")]
config_dirs = os.getenv("XDG_CONFIG_DIRS")
if config_dirs == None:
config_dirs = "/etc/xdg"
config_dirs = [os.path.join(d, PROGRAM_NAME) for d in config_dirs.split(":")]
program_dir = os.path.split(os.path.dirname(os.path.realpath(__file__)))[0]
cancel_all = False
quiting = False
temporary = []
pause = False
verbose = True
isdaemon = False
DBUS_INTERFACE = 'org.freedesktop.ITmagesEngine'
DBUS_PATH = '/org/freedesktop/ITmagesEngine'
MIMETYPES = ('image/jpeg', 'image/png', 'image/gif')
RESP_CANCELLED = '''<response><status>cancelled</status>separator<reason>Action cancelled</reason></response>'''
USERCONFIGDIR = os.path.join(glib.get_user_config_dir(), "itmagesd")
TEMPFOLDER = os.path.join(glib.get_user_cache_dir(), 'itmages', 'pictures')
tempfile.tempdir = TEMPFOLDER
stat.temporary.append(TEMPFOLDER)
SOCKNAME = tempfile.mktemp('.socket')
DAEMON_CONF = os.path.join(USERCONFIGDIR, "service.xml")
if not os.path.exists(TEMPFOLDER):
os.makedirs(TEMPFOLDER)
if not os.path.exists(USERCONFIGDIR):
os.makedirs(USERCONFIGDIR)
class Messages:
UNSUPPORTED = "Is unsupported argument type."
CAN_NOT_BE_PUT = "This file can not be put to queue."
ITEM_EXISTS = "This file is already exists in queue."
import stat
import string
import threading
import urllib
import urlparse
import glib
from mopidy import compat, exceptions
from mopidy.compat import queue
from mopidy.utils import encoding
logger = logging.getLogger(__name__)
XDG_DIRS = {
'XDG_CACHE_DIR': glib.get_user_cache_dir(),
'XDG_CONFIG_DIR': glib.get_user_config_dir(),
'XDG_DATA_DIR': glib.get_user_data_dir(),
'XDG_MUSIC_DIR': glib.get_user_special_dir(glib.USER_DIRECTORY_MUSIC),
}
# XDG_MUSIC_DIR can be none, so filter out any bad data.
XDG_DIRS = dict((k, v) for k, v in XDG_DIRS.items() if v is not None)
def get_or_create_dir(dir_path):
if not isinstance(dir_path, bytes):
raise ValueError('Path is not a bytestring.')
dir_path = expand_path(dir_path)
if os.path.isfile(dir_path):
raise OSError('A file with the same name as the desired dir, '
import os
import sys
import glib
import logging
APP_NAME = 'Gnotwify'
APP_SHORT_NAME = 'gnotwify'
SRV_NAME = 'twitter'
CONFIG_DIR = os.path.join(glib.get_user_config_dir(), APP_SHORT_NAME)
DATA_DIR = os.path.join(glib.get_user_data_dir(), APP_SHORT_NAME)
CACHE_DIR = os.path.join(glib.get_user_cache_dir(), APP_SHORT_NAME)
CURRENT_DIR = os.path.realpath(os.path.dirname(sys.argv[0]))
CONFIG_FILE = os.path.join(CONFIG_DIR, APP_SHORT_NAME + '.cfg')
LOG_FILENAME = os.path.join(CACHE_DIR, APP_SHORT_NAME + '.log')
LOG_LEVELS = {'debug': logging.DEBUG,
'info': logging.INFO,
'warning': logging.WARNING,
'error': logging.ERROR,
'critical': logging.CRITICAL}
logging.basicConfig(level=logging.INFO,
datefmt='%H:%M',
format='[%(asctime)s][%(levelname)s:%(name)s] %(message)s')
from libgnotwify.Message import Message
from libgnotwify.Gnotwify import Gnotwify, GnotwifyError
import os
import glib
import shutil
PROGRAM_NAME = "deepin-individuation"
homedir = os.path.expanduser("~")
lastdir = homedir
data_home = glib.get_user_data_dir()
data_home = os.path.join(data_home, PROGRAM_NAME)
config_home = glib.get_user_config_dir()
config_home = os.path.join(config_home, PROGRAM_NAME)
cache_home = glib.get_user_cache_dir()
cache_home = os.path.join(cache_home, PROGRAM_NAME)
data_dirs = os.getenv("XDG_DATA_DIRS")
if data_dirs == None:
data_dirs = "/usr/local/share/:/usr/share/"
data_dirs = [os.path.join(d, PROGRAM_NAME) for d in data_dirs.split(":")]
config_dirs = os.getenv("XDG_CONFIG_DIRS")
if config_dirs == None:
config_dirs = "/etc/xdg"
config_dirs = [os.path.join(d, PROGRAM_NAME) for d in config_dirs.split(":")]
program_dir = os.path.split(os.path.dirname(os.path.realpath(__file__)))[0]
if (isinstance(pykka.__version__, basestring)
and not SV('1.0') <= SV(pykka.__version__) < SV('2.0')):
sys.exit(
u'Mopidy requires Pykka >= 1.0, < 2, but found %s' % pykka.__version__)
import os
import platform
from subprocess import PIPE, Popen
import glib
__version__ = '0.8.1'
DATA_PATH = os.path.join(str(glib.get_user_data_dir()), 'mopidy')
CACHE_PATH = os.path.join(str(glib.get_user_cache_dir()), 'mopidy')
SETTINGS_PATH = os.path.join(str(glib.get_user_config_dir()), 'mopidy')
SETTINGS_FILE = os.path.join(SETTINGS_PATH, 'settings.py')
def get_version():
try:
return get_git_version()
except EnvironmentError:
return __version__
def get_git_version():
process = Popen(['git', 'describe'], stdout=PIPE, stderr=PIPE)
if process.wait() != 0:
raise EnvironmentError('Execution of "git describe" failed')
version = process.stdout.read().strip()
if version.startswith('v'):
import gobject
from gtk import gdk
import clutter
import clutter.x11
gobject.threads_init()
clutter.threads_init()
log = logging.getLogger('flickrsaver')
log.setLevel(logging.DEBUG)
API_KEY = "59b92bf5694c292121537c3a754d7b85"
flickr = flickrapi.FlickrAPI(API_KEY)
""" Where we keep photos """
cache_dir = os.path.join(glib.get_user_cache_dir(), 'flickrsaver')
class PhotoSource(object):
def get_photo(self):
""" Return the (filename, fp) of a photo from the source, where
fp is an open file descriptor. """
raise NotImplementedError
class FlickrSource(PhotoSource):
""" Flickr photo source """
common_args = {'extras': 'url_s,url_m,url_z,url_l,url_o',
'per_page': 500}
def __init__(self):
""" Flickr photo source """
import platform
import sys
if not (2, 6) <= sys.version_info < (3,):
sys.exit(u'Mopidy requires Python >= 2.6, < 3')
import glib
import os
from subprocess import PIPE, Popen
VERSION = (0, 6, 0)
DATA_PATH = os.path.join(glib.get_user_data_dir(), 'mopidy')
CACHE_PATH = os.path.join(glib.get_user_cache_dir(), 'mopidy')
SETTINGS_PATH = os.path.join(glib.get_user_config_dir(), 'mopidy')
SETTINGS_FILE = os.path.join(SETTINGS_PATH, 'settings.py')
def get_version():
try:
return get_git_version()
except EnvironmentError:
return get_plain_version()
def get_git_version():
process = Popen(['git', 'describe'], stdout=PIPE, stderr=PIPE)
if process.wait() != 0:
raise EnvironmentError('Execution of "git describe" failed')
version = process.stdout.read().strip()
if version.startswith('v'):
version = version[1:]
return version
from __future__ import unicode_literals
import logging
import os
import re
# pylint: disable = W0402
import string
# pylint: enable = W0402
import sys
import urllib
import glib
logger = logging.getLogger('mopidy.utils.path')
XDG_CACHE_DIR = glib.get_user_cache_dir().decode('utf-8')
XDG_CONFIG_DIR = glib.get_user_config_dir().decode('utf-8')
XDG_DATA_DIR = glib.get_user_data_dir().decode('utf-8')
XDG_MUSIC_DIR = glib.get_user_special_dir(glib.USER_DIRECTORY_MUSIC)
if XDG_MUSIC_DIR:
XDG_MUSIC_DIR = XDG_MUSIC_DIR.decode('utf-8')
XDG_DIRS = {
'XDG_CACHE_DIR': XDG_CACHE_DIR,
'XDG_CONFIG_DIR': XDG_CONFIG_DIR,
'XDG_DATA_DIR': XDG_DATA_DIR,
'XDG_MUSIC_DIR': XDG_MUSIC_DIR,
}
DATA_PATH = os.path.join(unicode(XDG_DATA_DIR), 'mopidy')
SETTINGS_PATH = os.path.join(unicode(XDG_CONFIG_DIR), 'mopidy')
SETTINGS_FILE = os.path.join(unicode(SETTINGS_PATH), 'settings.py')
def getUserCachePrefix ():
return join(get_user_cache_dir(), pychess)
def __init__(self, FILECHOSEN, FILENAME, DESTDIR, CONTAINERCHOICE, AUDIOCODECVALUE, VIDEOCODECVALUE, PRESET,
OHEIGHT, OWIDTH, FRATENUM, FRATEDEN, ACHANNELS, MULTIPASS, PASSCOUNTER, OUTPUTNAME,
TIMESTAMP, ROTATIONVALUE, AUDIOPASSTOGGLE, VIDEOPASSTOGGLE, INTERLACED, INPUTVIDEOCAPS):
gobject.GObject.__init__(self)
# Choose plugin based on Container name
self.container = CONTAINERCHOICE
self.audiocaps = AUDIOCODECVALUE
if self.container != False:
self.containercaps = gst.Caps(codecfinder.containermap[CONTAINERCHOICE])
# special case mp3 which is a no-container format with a container (id3mux)
else:
if self.audiocaps.intersect(gst.Caps("audio/mpeg, mpegversion=1, layer=3")):
self.containercaps=gst.Caps("application/x-id3")
self.container=gst.Caps("application/x-id3")
# Choose plugin based on Codec Name
# or switch to remuxing mode if any of the values are set to 'pastr'
self.stoptoggle=False
self.videocaps = VIDEOCODECVALUE # "novid" means we have a video file input, but do not want it
# while False means we don't have any video
self.audiopasstoggle = AUDIOPASSTOGGLE
self.interlaced = INTERLACED
self.videopasstoggle = VIDEOPASSTOGGLE
self.inputvideocaps = INPUTVIDEOCAPS
self.doaudio= False
self.preset = PRESET
self.oheight = OHEIGHT
self.owidth = OWIDTH
self.fratenum = FRATENUM
self.frateden = FRATEDEN
self.achannels = ACHANNELS
self.blackborderflag = False
self.multipass = MULTIPASS
self.passcounter = PASSCOUNTER
self.outputfilename = OUTPUTNAME
self.timestamp = TIMESTAMP
self.rotationvalue = int(ROTATIONVALUE)
self.vbox = {}
# switching width and height around for rotationchoices where it makes sense
if self.rotationvalue == 1 or self.rotationvalue == 3:
nwidth = self.oheight
nheight = self.owidth
self.oheight = nheight
self.owidth = nwidth
# if needed create a variable to store the filename of the multipass \
# statistics file
if self.multipass != False:
self.cachefile = (str (glib.get_user_cache_dir()) + "/" + \
"multipass-cache-file" + self.timestamp + ".log")
# gather preset data if relevant
if self.preset != "nopreset":
height, width, num, denom, pixelaspectratio = self.provide_presets()
for acap in self.audiocaps:
acap["channels"] = self.channels
for vcap in self.videocaps:
vcap["height"] = int(height)
vcap["width"] = int(width)
vcap["framerate"] = gst.Fraction(num, denom)
if pixelaspectratio != gst.Fraction(0, 0):
vcap["pixel-aspect-ratio"] = pixelaspectratio
# Create transcoding pipeline
self.pipeline = gst.Pipeline("TranscodingPipeline")
self.pipeline.set_state(gst.STATE_PAUSED)
self.uridecoder = gst.element_factory_make("uridecodebin", "uridecoder")
self.uridecoder.set_property("uri", FILECHOSEN)
self.uridecoder.connect("pad-added", self.OnDynamicPad)
# first check if we have a container format, if not set up output for possible outputs
# should not be hardcoded
audiopreset=None
videopreset=None
if self.preset != "nopreset":
# print "got preset and will use Quality Normal"
# these values should not be hardcoded, but gotten from profile XML file
audiopreset="Quality Normal"
videopreset="Quality Normal"
if self.container==False:
if self.audiocaps.intersect(gst.Caps("audio/mpeg, mpegversion=4")):
self.audiocaps=gst.Caps("audio/mpeg, mpegversion=4, stream-format=adts")
elif self.audiocaps.intersect(gst.Caps("audio/x-flac")):
self.audiocaps=gst.Caps("audio/x-flac")
else:
self.encodebinprofile = gst.pbutils.EncodingContainerProfile ("containerformat", None , self.containercaps, None)
if self.audiocaps != False:
if self.container==False:
self.encodebinprofile = gst.pbutils.EncodingAudioProfile (gst.Caps(self.audiocaps), audiopreset, gst.caps_new_any(), 0)
else:
self.audioprofile = gst.pbutils.EncodingAudioProfile (gst.Caps(self.audiocaps), audiopreset, gst.caps_new_any(), 0)
self.encodebinprofile.add_profile(self.audioprofile)
if self.videocaps != "novid":
if (self.videocaps != False):
self.videoprofile = gst.pbutils.EncodingVideoProfile (gst.Caps(self.videocaps), videopreset, gst.caps_new_any(), 0)
self.encodebinprofile.add_profile(self.videoprofile)
self.encodebin = gst.element_factory_make ("encodebin", None)
self.encodebin.set_property("profile", self.encodebinprofile)
self.encodebin.set_property("avoid-reencoding", True)
self.pipeline.add(self.encodebin)
self.encodebin.set_state(gst.STATE_PAUSED)
if self.videopasstoggle==False:
if self.container != False:
self.videoflipper = gst.element_factory_make("videoflip")
self.videoflipper.set_property("method", self.rotationvalue)
self.pipeline.add(self.videoflipper)
self.deinterlacer = gst.element_factory_make("deinterlace")
self.pipeline.add(self.deinterlacer)
self.colorspaceconversion = gst.element_factory_make("ffmpegcolorspace")
self.pipeline.add(self.colorspaceconversion)
self.deinterlacer.link(self.colorspaceconversion)
self.colorspaceconversion.link(self.videoflipper)
self.deinterlacer.set_state(gst.STATE_PAUSED)
self.colorspaceconversion.set_state(gst.STATE_PAUSED)
self.videoflipper.set_state(gst.STATE_PAUSED)
self.remuxcaps = gst.Caps()
if self.audiopasstoggle:
self.remuxcaps.append(self.audiocaps)
if self.videopasstoggle:
self.remuxcaps.append(self.videocaps)
if self.audiopasstoggle and not self.videopasstoggle:
self.remuxcaps.append_structure(gst.Structure("video/x-raw-rgb"))
self.remuxcaps.append_structure(gst.Structure("video/x-raw-yuv"))
if self.videopasstoggle and not self.audiopasstoggle:
self.remuxcaps.append_structure(gst.Structure("audio/x-raw-float"))
self.remuxcaps.append_structure(gst.Structure("audio/x-raw-int"))
if self.videocaps=="novid":
if self.inputvideocaps != None:
self.remuxcaps.append(self.inputvideocaps)
self.remuxcaps.append_structure(gst.Structure("audio/x-raw-float"))
self.remuxcaps.append_structure(gst.Structure("audio/x-raw-int"))
if (self.audiopasstoggle) or (self.videopasstoggle) or (self.videocaps=="novid"):
self.uridecoder.set_property("caps", self.remuxcaps)
self.pipeline.add(self.uridecoder)
self.transcodefileoutput = gst.element_factory_make("filesink", \
"transcodefileoutput")
self.transcodefileoutput.set_property("location", \
(DESTDIR+"/"+self.outputfilename))
self.pipeline.add(self.transcodefileoutput)
self.encodebin.link(self.transcodefileoutput)
self.uridecoder.set_state(gst.STATE_PAUSED)
# print "setting uridcodebin to paused"
self.BusMessages = self.BusWatcher()
# we need to wait on this one before going further
self.uridecoder.connect("no-more-pads", self.noMorePads)
class Screenkey(gtk.Window):
POSITIONS = {
POS_TOP:_('Top'),
POS_CENTER:_('Center'),
POS_BOTTOM:_('Bottom'),
}
SIZES = {
SIZE_LARGE:_('Large'),
SIZE_MEDIUM:_('Medium'),
SIZE_SMALL:_('Small'),
}
MODES = {
MODE_RAW:_('Raw'),
MODE_NORMAL:_('Normal'),
}
STATE_FILE = os.path.join(glib.get_user_cache_dir(),
'screenkey.dat')
_disabled = False
def __init__(self, logger, nodetach):
gtk.Window.__init__(self)
self.timer = None
self.logger = logger
self.options = self.load_state()
if not self.options:
self.options = {
'timeout': 2.5,
'position': POS_BOTTOM,
'size': SIZE_MEDIUM,
'mode': MODE_NORMAL,
'hotkey': '<Ctrl>F1',
}
if not nodetach:
self.logger.debug("Detach from the parent.")
self.drop_tty()
self.set_skip_taskbar_hint(True)
self.set_skip_pager_hint(True)
self.set_keep_above(True)
self.set_decorated(False)
self.stick()
self.set_property('accept-focus', False)
self.set_property('focus-on-map', False)
self.set_position(gtk.WIN_POS_CENTER)
bgcolor = gtk.gdk.color_parse("black")
self.modify_bg(gtk.STATE_NORMAL, bgcolor)
self.set_opacity(0.7)
gobject.signal_new("text-changed", gtk.Label,
gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ())
self.label = gtk.Label()
self.label.set_justify(gtk.JUSTIFY_RIGHT)
self.label.set_ellipsize(pango.ELLIPSIZE_START)
self.label.connect("text-changed", self.on_label_change)
self.label.show()
self.add(self.label)
self.screen_width = gtk.gdk.screen_width()
self.screen_height = gtk.gdk.screen_height()
self.set_window_size(self.options['size'])
self.set_gravity(gtk.gdk.GRAVITY_CENTER)
self.set_xy_position(self.options['position'])
self.listenkbd = ListenKbd(self.label, logger=self.logger,
mode=self.options['mode'])
self.listenkbd.start()
menu = gtk.Menu()
show_item = gtk.CheckMenuItem(_("Show keys"))
show_item.set_active(True)
show_item.connect("toggled", self.on_show_keys)
show_item.show()
menu.append(show_item)
preferences_item = gtk.ImageMenuItem(gtk.STOCK_PREFERENCES)
preferences_item.connect("activate", self.on_preferences_dialog)
preferences_item.show()
menu.append(preferences_item)
about_item = gtk.ImageMenuItem(gtk.STOCK_ABOUT)
about_item.connect("activate", self.on_about_dialog)
about_item.show()
menu.append(about_item)
separator_item = gtk.SeparatorMenuItem()
separator_item.show()
menu.append(separator_item)
image = gtk.ImageMenuItem(gtk.STOCK_QUIT)
image.connect("activate", self.quit)
image.show()
menu.append(image)
menu.show()
try:
import appindicator
self.systray = appindicator.Indicator(APP_NAME,
'indicator-messages',
appindicator.CATEGORY_APPLICATION_STATUS)
self.systray.set_status(appindicator.STATUS_ACTIVE)
self.systray.set_attention_icon("indicator-messages-new")
self.systray.set_icon(
"preferences-desktop-keyboard-shortcuts")
self.systray.set_menu(menu)
self.logger.debug("Using AppIndicator.")
except(ImportError):
self.systray = gtk.StatusIcon()
self.systray.set_from_icon_name(
"preferences-desktop-keyboard-shortcuts")
self.systray.connect("popup-menu",
self.on_statusicon_popup, menu)
self.logger.debug("Using StatusIcon.")
self.connect("delete-event", self.quit)
keybinder.bind(self.options['hotkey'], self.hotkey_cb, show_item)
def quit(self, widget, data=None):
self.listenkbd.stop()
gtk.main_quit()
def load_state(self):
"""Load stored options"""
options = None
try:
f = open(self.STATE_FILE, 'r')
try:
options = pickle.load(f)
self.logger.debug("Options loaded.")
except:
f.close()
except IOError:
self.logger.debug("file %s does not exists." %
self.STATE_FILE)
return options
def store_state(self, options):
"""Store options"""
try:
f = open(self.STATE_FILE, 'w')
try:
pickle.dump(options, f)
self.logger.debug("Options saved.")
except:
f.close()
except IOError:
self.logger.debug("Cannot open %s." % self.STATE_FILE)
def set_window_size(self, setting):
"""Set window and label size."""
window_width = self.screen_width
window_height = -1
if setting == SIZE_LARGE:
window_height = 24 * self.screen_height / 100
if setting == SIZE_MEDIUM:
window_height = 12 * self.screen_height / 100
if setting == SIZE_SMALL:
window_height = 8 * self.screen_height / 100
attr = pango.AttrList()
attr.change(pango.AttrSize((
50 * window_height / 100) * 1000, 0, -1))
attr.change(pango.AttrFamily("Sans", 0, -1))
attr.change(pango.AttrWeight(pango.WEIGHT_BOLD, 0, -1))
attr.change(pango.AttrForeground(65535, 65535, 65535, 0, -1))
self.label.set_attributes(attr)
self.resize(window_width, window_height)
def set_xy_position(self, setting):
"""Set window position."""
window_width, window_height = self.get_size()
if setting == POS_TOP:
self.move(0, window_height * 2)
if setting == POS_CENTER:
self.move(0, self.screen_height / 2)
if setting == POS_BOTTOM:
self.move(0, self.screen_height - window_height * 2)
def on_statusicon_popup(self, widget, button, timestamp, data=None):
if button == 3:
if data:
data.show()
data.popup(None, None, gtk.status_icon_position_menu,
3, timestamp, widget)
def on_label_change(self, widget, data=None):
if not self._disabled:
if not self.get_property('visible'):
gtk.gdk.threads_enter()
self.set_xy_position(self.options['position'])
self.stick()
self.show()
gtk.gdk.threads_leave()
if self.timer:
self.timer.cancel()
self.timer = Timer(self.options['timeout'], self.on_timeout)
self.timer.start()
else:
gtk.gdk.threads_enter()
self.hide()
self.label.set_text("")
gtk.gdk.threads_leave()
def on_timeout(self):
gtk.gdk.threads_enter()
self.hide()
self.label.set_text("")
gtk.gdk.threads_leave()
def on_change_mode(self, mode):
self.listenkbd.stop()
self.listenkbd = ListenKbd(self.label, logger=self.logger,
mode=mode)
self.listenkbd.start()
def on_show_keys(self, widget, data=None):
if widget.get_active():
self._disabled = False
self.logger.debug("Screenkey enabled.")
self.listenkbd = ListenKbd(self.label, logger=self.logger,
mode=self.options['mode'])
self.listenkbd.start()
else:
self.logger.debug("Screenkey disabled.")
self._disabled = True
self.listenkbd.stop()
def hotkey_cb(self, widget, data=None):
if widget.get_active():
self.logger.debug("Hotkey Pressed: %s." % self.options['hotkey'])
self._disabled = True
widget.set_active(False)
else:
self._disabled = False
widget.set_active(True)
def on_preferences_dialog(self, widget, data=None):
prefs = gtk.Dialog(APP_NAME, None,
gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
(gtk.STOCK_CLOSE, gtk.RESPONSE_CLOSE))
def on_sb_time_changed(widget, data=None):
self.options['timeout'] = widget.get_value()
self.logger.debug("Timeout value changed.")
def on_cbox_sizes_changed(widget, data=None):
index = widget.get_active()
if index >= 0:
self.options['size'] = index
self.set_window_size(self.options['size'])
self.logger.debug("Window size changed.")
def on_cbox_modes_changed(widget, data=None):
index = widget.get_active()
if index >= 0:
self.options['mode'] = index
self.on_change_mode(self.options['mode'])
self.logger.debug("Key mode changed.")
def on_cbox_changed(widget, data=None):
index = widget.get_active()
name = widget.get_name()
if index >= 0:
self.options[name] = index
self.logger.debug("Window position changed.")
def on_entry_hotkey_changed(widget, data=None):
self.options['hotkey'] = widget.get_text()
self.logger.debug("Hotkey value Changed")
frm_main = gtk.Frame(_("Preferences"))
frm_main.set_border_width(6)
vbox_main = gtk.VBox()
frm_time = gtk.Frame(_("<b>Time</b>"))
frm_time.set_border_width(4)
frm_time.get_label_widget().set_use_markup(True)
frm_time.set_shadow_type(gtk.SHADOW_NONE)
hbox_time = gtk.HBox()
lbl_time1 = gtk.Label(_("Display for"))
lbl_time2 = gtk.Label(_("seconds"))
sb_time = gtk.SpinButton(digits=1)
sb_time.set_increments(0.5, 1.0)
sb_time.set_range(0.5, 10.0)
sb_time.set_numeric(True)
sb_time.set_update_policy(gtk.UPDATE_IF_VALID)
sb_time.set_value(self.options['timeout'])
sb_time.connect("value-changed", on_sb_time_changed)
hbox_time.pack_start(lbl_time1, expand=False,
fill=False, padding=6)
hbox_time.pack_start(sb_time, expand=False,
fill=False, padding=4)
hbox_time.pack_start(lbl_time2, expand=False,
fill=False, padding=4)
frm_time.add(hbox_time)
frm_time.show_all()
frm_aspect = gtk.Frame(_("<b>Aspect</b>"))
frm_aspect.set_border_width(4)
frm_aspect.get_label_widget().set_use_markup(True)
frm_aspect.set_shadow_type(gtk.SHADOW_NONE)
vbox_aspect = gtk.VBox(spacing=6)
hbox1_aspect = gtk.HBox()
lbl_positions = gtk.Label(_("Position"))
cbox_positions = gtk.combo_box_new_text()
cbox_positions.set_name('position')
for key, value in self.POSITIONS.items():
cbox_positions.insert_text(key, value)
cbox_positions.set_active(self.options['position'])
cbox_positions.connect("changed", on_cbox_changed)
hbox1_aspect.pack_start(lbl_positions, expand=False,
fill=False, padding=6)
hbox1_aspect.pack_start(cbox_positions, expand=False,
fill=False, padding=4)
hbox2_aspect = gtk.HBox()
lbl_sizes = gtk.Label(_("Size"))
cbox_sizes = gtk.combo_box_new_text()
cbox_sizes.set_name('size')
for key, value in self.SIZES.items():
cbox_sizes.insert_text(key, value)
cbox_sizes.set_active(self.options['size'])
cbox_sizes.connect("changed", on_cbox_sizes_changed)
hbox2_aspect.pack_start(lbl_sizes, expand=False,
fill=False, padding=6)
hbox2_aspect.pack_start(cbox_sizes, expand=False,
fill=False, padding=4)
vbox_aspect.pack_start(hbox1_aspect)
vbox_aspect.pack_start(hbox2_aspect)
frm_aspect.add(vbox_aspect)
frm_kbd = gtk.Frame(_("<b>Keys</b>"))
frm_kbd.set_border_width(4)
frm_kbd.get_label_widget().set_use_markup(True)
frm_kbd.set_shadow_type(gtk.SHADOW_NONE)
hbox_kbd = gtk.HBox()
lbl_kbd = gtk.Label(_("Mode"))
cbox_modes = gtk.combo_box_new_text()
cbox_modes.set_name('mode')
for key, value in self.MODES.items():
cbox_modes.insert_text(key, value)
cbox_modes.set_active(self.options['mode'])
cbox_modes.connect("changed", on_cbox_modes_changed)
hbox_kbd.pack_start(lbl_kbd, expand=False,
fill=False, padding=6)
hbox_kbd.pack_start(cbox_modes, expand=False,
fill=False, padding=4)
frm_kbd.add(hbox_kbd)
frm_hotkey = gtk.Frame(_("<b>Hot Keys</b>"))
frm_hotkey.set_border_width(4)
frm_hotkey.get_label_widget().set_use_markup(True)
frm_hotkey.set_shadow_type(gtk.SHADOW_NONE)
hbox_hotkey = gtk.HBox()
lbl_hotkey = gtk.Label(_("Shortcut"))
entry_hotkey = gtk.Entry()
entry_hotkey.set_text(self.options['hotkey'])
entry_hotkey.set_width_chars(10)
entry_hotkey.connect("changed", on_entry_hotkey_changed)
hbox_hotkey.pack_start(lbl_hotkey, expand=False,
fill=False, padding=6)
hbox_hotkey.pack_start(entry_hotkey, expand=False,
fill=False, padding=4)
frm_hotkey.add(hbox_hotkey)
vbox_main.pack_start(frm_time, False, False, 6)
vbox_main.pack_start(frm_aspect, False, False, 6)
vbox_main.pack_start(frm_kbd, False, False, 6)
vbox_main.pack_start(frm_hotkey, False, False, 6)
frm_main.add(vbox_main)
prefs.vbox.pack_start(frm_main)
prefs.set_destroy_with_parent(True)
prefs.set_resizable(False)
prefs.set_has_separator(False)
prefs.set_default_response(gtk.RESPONSE_CLOSE)
prefs.vbox.show_all()
response = prefs.run()
if response:
self.store_state(self.options)
prefs.destroy()
def on_about_dialog(self, widget, data=None):
about = gtk.AboutDialog()
about.set_program_name(APP_NAME)
about.set_version(VERSION)
about.set_copyright(u"2010 \u00a9 %s" % AUTHOR)
about.set_comments(APP_DESC)
about.set_documenters(
[u"Jos\xe9 Mar\xeda Quiroga <*****@*****.**>"]
)
about.set_website(APP_URL)
about.set_icon_name('preferences-desktop-keyboard-shortcuts')
about.set_logo_icon_name(
'preferences-desktop-keyboard-shortcuts'
)
about.run()
about.destroy()
def drop_tty(self):
# We fork and setsid so that we drop the controlling
# tty.
if os.fork() != 0:
os._exit(0)
os.setsid()
import os
import Queue as queue
import stat
import string
import threading
import urllib
import urlparse
import glib
logger = logging.getLogger(__name__)
XDG_DIRS = {
'XDG_CACHE_DIR': glib.get_user_cache_dir(),
'XDG_CONFIG_DIR': glib.get_user_config_dir(),
'XDG_DATA_DIR': glib.get_user_data_dir(),
'XDG_MUSIC_DIR': glib.get_user_special_dir(glib.USER_DIRECTORY_MUSIC),
}
# XDG_MUSIC_DIR can be none, so filter out any bad data.
XDG_DIRS = dict((k, v) for k, v in XDG_DIRS.items() if v is not None)
def get_or_create_dir(dir_path):
if not isinstance(dir_path, bytes):
raise ValueError('Path is not a bytestring.')
dir_path = expand_path(dir_path)
if os.path.isfile(dir_path):
raise OSError(
import os
import pickle
import json
import gtk
import sys
import glob
import shutil
import glib
PROGRAM_NAME = 'hermelin'
EXT_DIR_NAME = 'ext'
THEME_DIR_NAME = 'theme'
CONF_DIR = os.path.join(glib.get_user_config_dir(), PROGRAM_NAME)
DB_DIR = os.path.join(CONF_DIR, 'db')
CACHE_DIR = os.path.join(glib.get_user_cache_dir(), PROGRAM_NAME)
AVATAR_CACHE_DIR = os.path.join(CACHE_DIR, 'avatar')
DATA_DIRS = []
DATA_BASE_DIRS = ['/usr/local/share', '/usr/share', glib.get_user_data_dir()]
DATA_DIRS += [os.path.join(d, PROGRAM_NAME) for d in DATA_BASE_DIRS]
DATA_DIRS.append(os.path.abspath('./data'))
TEMPLATE = 'index.html'
settings = {}
def getconf():
from __future__ import unicode_literals
import logging
import os
import re
# pylint: disable = W0402
import string
# pylint: enable = W0402
import sys
import urllib
import glib
logger = logging.getLogger('mopidy.utils.path')
XDG_CACHE_DIR = glib.get_user_cache_dir().decode('utf-8')
XDG_CONFIG_DIR = glib.get_user_config_dir().decode('utf-8')
XDG_DATA_DIR = glib.get_user_data_dir().decode('utf-8')
XDG_MUSIC_DIR = glib.get_user_special_dir(glib.USER_DIRECTORY_MUSIC)
if XDG_MUSIC_DIR:
XDG_MUSIC_DIR = XDG_MUSIC_DIR.decode('utf-8')
XDG_DIRS = {
'XDG_CACHE_DIR': XDG_CACHE_DIR,
'XDG_CONFIG_DIR': XDG_CONFIG_DIR,
'XDG_DATA_DIR': XDG_DATA_DIR,
'XDG_MUSIC_DIR': XDG_MUSIC_DIR,
}
DATA_PATH = os.path.join(unicode(XDG_DATA_DIR), 'mopidy')
SETTINGS_PATH = os.path.join(unicode(XDG_CONFIG_DIR), 'mopidy')
SETTINGS_FILE = os.path.join(unicode(SETTINGS_PATH), 'settings.py')
# -*- coding: UTF-8 -*-
import os
import pickle
import json
import gtk
import sys
import glob
import shutil
import glib
PROGRAM_NAME = 'hotot'
EXT_DIR_NAME = 'ext'
CONF_DIR = os.path.join(glib.get_user_config_dir(), PROGRAM_NAME)
DB_DIR = os.path.join(CONF_DIR, 'db')
CACHE_DIR = os.path.join(glib.get_user_cache_dir(), PROGRAM_NAME)
AVATAR_CACHE_DIR = os.path.join(CACHE_DIR, 'avatar')
DATA_DIRS = []
DATA_BASE_DIRS = [
'/usr/local/share'
, '/usr/share'
, glib.get_user_data_dir()
]
DATA_DIRS += [os.path.join(d, PROGRAM_NAME) for d in DATA_BASE_DIRS]
DATA_DIRS.append(os.path.abspath('./data'))
TEMPLATE = 'index.html'
class Transcoder(gobject.GObject):
__gsignals__ = {
'ready-for-querying': (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, []),
'got-eos': (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, []),
'got-error':
(gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, (gobject.TYPE_PYOBJECT, ))
}
def __init__(self,
FILECHOSEN,
FILENAME,
DESTDIR,
CONTAINERCHOICE,
AUDIOCODECVALUE,
VIDEOCODECVALUE,
PRESET,
OHEIGHT,
OWIDTH,
FRATENUM,
FRATEDEN,
ACHANNELS,
MULTIPASS,
PASSCOUNTER,
OUTPUTNAME,
TIMESTAMP,
ROTATIONVALUE,
AUDIOPASSTOGGLE,
VIDEOPASSTOGGLE,
INTERLACED,
INPUTVIDEOCAPS,
NEW_WIDTH=None,
NEW_HEIGHT=None):
gobject.GObject.__init__(self)
self.state_label = "pause"
self.conv_flags = 0
self.name = ""
self.outputdirectory = ""
self.container = ""
# Choose plugin based on Container name
self.container = CONTAINERCHOICE
self.audiocaps = AUDIOCODECVALUE
if self.container != False:
self.containercaps = gst.Caps(
codecfinder.containermap[CONTAINERCHOICE])
# special case mp3 which is a no-container format with a container (id3mux)
else:
if self.audiocaps.intersect(
gst.Caps("audio/mpeg, mpegversion=1, layer=3")):
self.containercaps = gst.Caps("application/x-id3")
self.container = gst.Caps("application/x-id3")
# set preset directory
# gst.preset_set_app_dir("/usr/share/transmageddon/presets/")
gst.preset_set_app_dir("../presets/")
# Choose plugin based on Codec Name
# or switch to remuxing mode if any of the values are set to 'pastr'
self.stoptoggle = False
self.videocaps = VIDEOCODECVALUE # "novid" means we have a video file input, but do not want it
# while False means we don't have any video
self.audiopasstoggle = AUDIOPASSTOGGLE
self.interlaced = INTERLACED
self.videopasstoggle = VIDEOPASSTOGGLE
self.inputvideocaps = INPUTVIDEOCAPS
self.doaudio = False
self.preset = PRESET
# print "self.preset:", self.preset
self.oheight = OHEIGHT
self.owidth = OWIDTH
self.fratenum = FRATENUM
self.frateden = FRATEDEN
self.achannels = ACHANNELS
self.blackborderflag = False
self.multipass = MULTIPASS
self.passcounter = PASSCOUNTER
self.outputfilename = OUTPUTNAME
self.timestamp = TIMESTAMP
self.rotationvalue = int(ROTATIONVALUE)
self.vbox = {}
if NEW_HEIGHT != None and NEW_WIDTH != None:
self.new_width = NEW_WIDTH
self.new_height = NEW_HEIGHT
else:
if NEW_HEIGHT != 0 and NEW_WIDTH != 0:
self.new_width = int(self.owidth)
self.new_height = int(self.oheight)
if type(self.videocaps) != bool:
if self.new_height > self.new_width:
temp_value = self.new_height
self.new_height = self.new_width
self.new_width = temp_value
try:
for vcap in self.videocaps:
vcap["height"] = int(self.new_height)
vcap["width"] = int(self.new_width)
except Exception, e:
print "transcoder_engine[error]:", e
# switching width and height around for rotationchoices where it makes sense
if self.rotationvalue == 1 or self.rotationvalue == 3:
nwidth = self.oheight
nheight = self.owidth
self.oheight = nheight
self.owidth = nwidth
# if needed create a variable to store the filename of the multipass \
# statistics file
if self.multipass != False:
self.cachefile = (str (glib.get_user_cache_dir()) + "/" + \
"multipass-cache-file" + self.timestamp + ".log")
# gather preset data if relevant
if self.preset != "nopreset":
# print "preset preset preset.............."
height, width, num, denom, pixelaspectratio = self.provide_presets(
)
for acap in self.audiocaps:
acap["channels"] = self.channels
for vcap in self.videocaps:
vcap["height"] = int(height)
vcap["width"] = int(width)
vcap["framerate"] = gst.Fraction(num, denom)
if pixelaspectratio != gst.Fraction(0, 0):
vcap["pixel-aspect-ratio"] = pixelaspectratio
# Create transcoding pipeline
self.pipeline = gst.Pipeline("TranscodingPipeline")
self.pipeline.set_state(gst.STATE_PAUSED)
self.uridecoder = gst.element_factory_make("uridecodebin",
"uridecoder")
self.uridecoder.set_property("uri", FILECHOSEN)
self.uridecoder.connect("pad-added", self.OnDynamicPad)
# first check if we have a container format, if not set up output for possible outputs
# should not be hardcoded
audiopreset = None
videopreset = None
if self.preset != "nopreset":
# print "got preset and will use Quality Normal"
# these values should not be hardcoded, but gotten from profile XML file
audiopreset = "Quality Normal"
videopreset = "Quality Normal"
if self.container == False:
if self.audiocaps.intersect(gst.Caps("audio/mpeg, mpegversion=4")):
self.audiocaps = gst.Caps(
"audio/mpeg, mpegversion=4, stream-format=adts")
elif self.audiocaps.intersect(gst.Caps("audio/x-flac")):
self.audiocaps = gst.Caps("audio/x-flac")
else:
self.encodebinprofile = gst.pbutils.EncodingContainerProfile(
"containerformat", None, self.containercaps, None)
if self.audiocaps != False:
if self.container == False:
self.encodebinprofile = gst.pbutils.EncodingAudioProfile(
gst.Caps(self.audiocaps), audiopreset, gst.caps_new_any(),
0)
else:
self.audioprofile = gst.pbutils.EncodingAudioProfile(
gst.Caps(self.audiocaps), audiopreset, gst.caps_new_any(),
0)
self.encodebinprofile.add_profile(self.audioprofile)
if self.videocaps != "novid":
if (self.videocaps != False):
self.videoprofile = gst.pbutils.EncodingVideoProfile(
gst.Caps(self.videocaps), videopreset, gst.caps_new_any(),
0)
self.encodebinprofile.add_profile(self.videoprofile)
self.encodebin = gst.element_factory_make("encodebin", None)
self.encodebin.set_property("profile", self.encodebinprofile)
self.encodebin.set_property("avoid-reencoding", True)
self.pipeline.add(self.encodebin)
self.encodebin.set_state(gst.STATE_PAUSED)
if self.videopasstoggle == False:
if self.container != False:
self.videoflipper = gst.element_factory_make("videoflip")
self.videoflipper.set_property("method", self.rotationvalue)
self.pipeline.add(self.videoflipper)
self.deinterlacer = gst.element_factory_make("deinterlace")
self.pipeline.add(self.deinterlacer)
self.colorspaceconversion = gst.element_factory_make(
"ffmpegcolorspace")
self.pipeline.add(self.colorspaceconversion)
self.deinterlacer.link(self.colorspaceconversion)
self.colorspaceconversion.link(self.videoflipper)
self.deinterlacer.set_state(gst.STATE_PAUSED)
self.colorspaceconversion.set_state(gst.STATE_PAUSED)
self.videoflipper.set_state(gst.STATE_PAUSED)
self.remuxcaps = gst.Caps()
if self.audiopasstoggle:
self.remuxcaps.append(self.audiocaps)
if self.videopasstoggle:
self.remuxcaps.append(self.videocaps)
if self.audiopasstoggle and not self.videopasstoggle:
self.remuxcaps.append_structure(gst.Structure("video/x-raw-rgb"))
self.remuxcaps.append_structure(gst.Structure("video/x-raw-yuv"))
if self.videopasstoggle and not self.audiopasstoggle:
self.remuxcaps.append_structure(gst.Structure("audio/x-raw-float"))
self.remuxcaps.append_structure(gst.Structure("audio/x-raw-int"))
if self.videocaps == "novid":
if self.inputvideocaps != None:
self.remuxcaps.append(self.inputvideocaps)
self.remuxcaps.append_structure(
gst.Structure("audio/x-raw-float"))
self.remuxcaps.append_structure(
gst.Structure("audio/x-raw-int"))
if (self.audiopasstoggle) or (self.videopasstoggle) or (self.videocaps
== "novid"):
self.uridecoder.set_property("caps", self.remuxcaps)
self.pipeline.add(self.uridecoder)
self.transcodefileoutput = gst.element_factory_make("filesink", \
"transcodefileoutput")
self.transcodefileoutput.set_property("location", \
(DESTDIR+"/"+self.outputfilename))
self.pipeline.add(self.transcodefileoutput)
self.encodebin.link(self.transcodefileoutput)
self.uridecoder.set_state(gst.STATE_PAUSED)
# print "setting uridcodebin to paused"
self.BusMessages = self.BusWatcher()
# we need to wait on this one before going further
self.uridecoder.connect("no-more-pads", self.noMorePads)
