rem
stringlengths 0
322k
| add
stringlengths 0
2.05M
| context
stringlengths 8
228k
|
|---|---|---|
self.query = query
|
enc = get_encoding(self.root_url) self.query = query.decode("utf-8").encode(enc)
|
def start(self, query, limit=10): """Start the search and return a list of covers"""
|
real_url = '%s?%s' % (search_url, urllib.urlencode(search_paras)) request = urllib2.Request(real_url) request.add_header('Accept-Encoding', 'gzip') url_sock = urllib2.urlopen(request) data = url_sock.read() if url_sock.headers.get('content-encoding') == 'gzip': xml_data = gzip.GzipFile(fileobj = StringIO(data)).read() else: xml_data = data url_sock.close() dom = minidom.parseString(xml_data)
|
data, enc = get_url(search_url, get=search_paras) dom = minidom.parseString(data)
|
def __get_search_page(self, page, query): """Returns the XML dom of a search result page. Starts with 1."""
|
rel_url = self.url + '/release/'
|
rel_url = self.url + '/release/' + id
|
def __parse_release(self, id, name): """Parse the release page and add the cover to the list."""
|
real_url = '%s%s?%s' % (rel_url, id ,urllib.urlencode(rel_paras)) request = urllib2.Request(real_url) request.add_header('Accept-Encoding', 'gzip') url_sock = urllib2.urlopen(request) if url_sock.headers.get('content-encoding') == 'gzip': xml_data = gzip.GzipFile(fileobj = StringIO(url_sock.read())).read() else: xml_data = url_sock.read() url_sock.close() dom = minidom.parseString(xml_data)
|
data, enc = get_url(rel_url, get=rel_paras) dom = minidom.parseString(data)
|
def __parse_release(self, id, name): """Parse the release page and add the cover to the list."""
|
real_url = '%s?%s' % (url, urllib.urlencode(parameters)) url_sock = urllib.urlopen(real_url) dom = minidom.parseString(url_sock.read()) url_sock.close()
|
data, enc = get_url(url, get=parameters) dom = minidom.parseString(data)
|
def __parse_page(self, page, query): """Gets all item tags and calls the item parsing function for each"""
|
query = query.decode('utf-8').encode('latin-1')
|
enc = get_encoding(self.root_url) query = query.decode('utf-8').encode(enc)
|
def start(self, query, limit=10): """Start the search and returns the covers"""
|
self.parse_url(self.root_url + link, enc = 'latin-1')
|
self.parse_url(self.root_url + link)
|
def __parse_all_covers(self): """Reads all URLs and adds the covers to the list"""
|
self.parse_url(self.root_url + '/search.php', get = params, enc = 'latin-1')
|
self.parse_url(self.root_url + '/search.php', get=params)
|
def __parse_page(self, page, query): """Parses the search result page and saves the data to self.data"""
|
url_sock = urllib2.urlopen(url)
|
request = urllib2.Request(url) request.add_header('User-Agent', USER_AGENT) url_sock = urllib2.urlopen(request)
|
def __set_async(self, url): """manages various stuff like fast switching of covers (aborting old HTTP requests), managing the image cache etc."""
|
url_sock = urllib2.urlopen(url)
|
request = urllib2.Request(url) request.add_header('Accept-Encoding', 'gzip') request.add_header('User-Agent', USER_AGENT) url_sock = urllib2.urlopen(request)
|
def get_size_of_url(url): url_sock = urllib2.urlopen(url) size = url_sock.headers.get('content-length') url_sock.close() if size: size = int(size) / 1024.0 if size < 1024: return '%.2f KB' % size else: return '%.2f MB' % size / 1024 else: return ''
|
util.decode(row[VALUE])))
|
util.decode(row[ORIGVALUE]), util.decode(row[VALUE])))
|
def __save_files(self, save, revert, model, library): updated = {} deleted = {} added = {} renamed = {} for row in model: if row[EDITED] and not (row[DELETED] or row[RENAMED]): if row[ORIGVALUE] is not None: updated.setdefault(row[TAG], []) updated[row[TAG]].append((util.decode(row[VALUE]), util.decode(row[ORIGVALUE]))) else: added.setdefault(row[TAG], []) added[row[TAG]].append(util.decode(row[VALUE])) if row[EDITED] and row[DELETED]: if row[ORIGVALUE] is not None: deleted.setdefault(row[TAG], []) deleted[row[TAG]].append(util.decode(row[ORIGVALUE]))
|
for old_tag, value in values:
|
for old_tag, old_value, new_value in values:
|
def __save_files(self, save, revert, model, library): updated = {} deleted = {} added = {} renamed = {} for row in model: if row[EDITED] and not (row[DELETED] or row[RENAMED]): if row[ORIGVALUE] is not None: updated.setdefault(row[TAG], []) updated[row[TAG]].append((util.decode(row[VALUE]), util.decode(row[ORIGVALUE]))) else: added.setdefault(row[TAG], []) added[row[TAG]].append(util.decode(row[VALUE])) if row[EDITED] and row[DELETED]: if row[ORIGVALUE] is not None: deleted.setdefault(row[TAG], []) deleted[row[TAG]].append(util.decode(row[ORIGVALUE]))
|
value = util.unescape(value)
|
old_value = util.unescape(old_value) new_value = util.unescape(new_value)
|
def __save_files(self, save, revert, model, library): updated = {} deleted = {} added = {} renamed = {} for row in model: if row[EDITED] and not (row[DELETED] or row[RENAMED]): if row[ORIGVALUE] is not None: updated.setdefault(row[TAG], []) updated[row[TAG]].append((util.decode(row[VALUE]), util.decode(row[ORIGVALUE]))) else: added.setdefault(row[TAG], []) added[row[TAG]].append(util.decode(row[VALUE])) if row[EDITED] and row[DELETED]: if row[ORIGVALUE] is not None: deleted.setdefault(row[TAG], []) deleted[row[TAG]].append(util.decode(row[ORIGVALUE]))
|
if not is_special(value): song.remove(old_tag, value) save_rename.append((new_tag, value)) elif is_missing(value): value = strip_missing(value) song.remove(old_tag, value) save_rename.append((new_tag, value))
|
if not is_special(old_value): song.remove(old_tag, old_value) save_rename.append((new_tag, new_value)) elif is_missing(old_value): value = strip_missing(old_value) song.remove(old_tag, old_value) save_rename.append((new_tag, new_value))
|
def __save_files(self, save, revert, model, library): updated = {} deleted = {} added = {} renamed = {} for row in model: if row[EDITED] and not (row[DELETED] or row[RENAMED]): if row[ORIGVALUE] is not None: updated.setdefault(row[TAG], []) updated[row[TAG]].append((util.decode(row[VALUE]), util.decode(row[ORIGVALUE]))) else: added.setdefault(row[TAG], []) added[row[TAG]].append(util.decode(row[VALUE])) if row[EDITED] and row[DELETED]: if row[ORIGVALUE] is not None: deleted.setdefault(row[TAG], []) deleted[row[TAG]].append(util.decode(row[ORIGVALUE]))
|
value = cget('plugins', 'animosd_' + key)
|
def tuple_to_str(t): return ' '.join(map(str, t))
|
|
PLUGIN_VERSION = "0.22"
|
PLUGIN_VERSION = "1.0"
|
def Label(text): l = gtk.Label(text) l.set_alignment(0.0, 0.5) return l
|
cstring = " color.red//256, color.green//256, color.blue//256) config.set("plugins", "animosd_text", cstring) self.conf.text = cstring
|
color = map(__coltofloat, (color.red, color.green, color.blue)) config.set("plugins", "animosd_text", "%f %f %f" % (color[0], color[1], color[2])) self.conf.text = tuple(color)
|
def set_text(button): color = button.get_color() cstring = "#%02x%02x%02x" % ( color.red//256, color.green//256, color.blue//256) config.set("plugins", "animosd_text", cstring) self.conf.text = cstring
|
cstring = " color.red//256, color.green//256, color.blue//256, button.get_alpha()//256) config.set("plugins", "animosd_fill", cstring) self.conf.fill = cstring
|
color = map(__coltofloat, (color.red, color.green, color.blue, button.get_alpha())) config.set("plugins", "animosd_fill", "%f %f %f %f" % (color[0], color[1], color[2], color[3])) self.conf.fill = tuple(color)
|
def set_fill(button): color = button.get_color() cstring = "#%02x%02x%02x%02x" % ( color.red//256, color.green//256, color.blue//256, button.get_alpha()//256) config.set("plugins", "animosd_fill", cstring) self.conf.fill = cstring
|
self.conf.pos = 0.5, value
|
self.conf.pos_y = value
|
def change_position(button): value = button.get_active() / 2.0 config.set("plugins", "animosd_pos_y", str(value)) self.conf.pos = 0.5, value
|
cb.set_active(int(self.conf.pos[1] * 2.0))
|
cb.set_active(int(self.conf.pos_y * 2.0))
|
def set_string(window): value = window.child.text config.set("plugins", "animosd_string", value) self.conf.string = value
|
b = gtk.ColorButton(color=gtk.gdk.color_parse(self.conf.text))
|
b = gtk.ColorButton(color=gtk.gdk.Color(*map(__floattocol, self.conf.text)))
|
def set_string(window): value = window.child.text config.set("plugins", "animosd_string", value) self.conf.string = value
|
b = gtk.ColorButton(color=gtk.gdk.color_parse(self.conf.fill[:7]))
|
b = gtk.ColorButton(color=gtk.gdk.Color(*map(__floattocol, self.conf.fill[0:3])))
|
def set_string(window): value = window.child.text config.set("plugins", "animosd_string", value) self.conf.string = value
|
b.set_alpha(int(self.conf.fill[-2:], base=16))
|
b.set_alpha(__floattocol(self.conf.fill[3]))
|
def set_string(window): value = window.child.text config.set("plugins", "animosd_string", value) self.conf.string = value
|
pos = 0.5, 0.0
|
pos_x = 0.5 pos_y = 0.0
|
def set_string(window): value = window.child.text config.set("plugins", "animosd_string", value) self.conf.string = value
|
border = 4 step = 32 ms = 80
|
border = 8 fadetime = 1.5 ms = 40
|
def set_string(window): value = window.child.text config.set("plugins", "animosd_string", value) self.conf.string = value
|
text = " outline = " shadow = " fill = " bcolor = "
|
text = (1.0, 0.8125, 0.586) outline = (0.125, 0.125, 0.125) shadow = (0.0, 0.0, 0.0) fill = (0.25, 0.25, 0.25, 0.5) bcolor = (0.0, 0.0, 0.0)
|
def set_string(window): value = window.child.text config.set("plugins", "animosd_string", value) self.conf.string = value
|
window = self.__window = gtk.Window(gtk.WINDOW_POPUP) window.set_type_hint(gtk.gdk.WINDOW_TYPE_HINT_NOTIFICATION)
|
self.__current_window = None def str_to_tuple(s): return tuple(map(float, s.split())) def tuple_to_str(t): return ' '.join(map(str, t)) config_map = [ ('text', config.get, str_to_tuple, tuple_to_str), ('fill', config.get, str_to_tuple, tuple_to_str), ('font', config.get, None, str), ('delay', config.getint, None, str), ('pos_y', config.getfloat, None, str), ('string', config.get, None, str), ] for key, cget, getconv, setconv in config_map: try: value = cget('plugins', 'animosd_' + key) if getconv is not None: value = getconv(value) except: if (value is not None and value.startswith(' ((key == 'text' and len(value) == 7) or \ (key == 'fill' and len(value) == 9)): colors = [value[1:3], value[3:5], value[5:7]] if key == 'fill': colors.append(value[7:9]) colors = [int(c, 16) / 255.0 for c in colors] config.set('plugins', 'animosd_' + key, setconv(colors)) else: config.set('plugins', 'animosd_' + key, setconv(getattr(self.conf, key))) else: setattr(self.conf, key, value) def plugin_single_song(self, song): self.plugin_on_song_started(song) def plugin_on_song_started(self, song): if self.__current_window is not None: if self.__current_window.is_composited(): self.__current_window.fade_out() else: self.__current_window.hide() self.__current_window.destroy() if song is None: self.__current_window = None return window = OSDWindow(self.conf, song)
|
def __init__(self): window = self.__window = gtk.Window(gtk.WINDOW_POPUP) window.set_type_hint(gtk.gdk.WINDOW_TYPE_HINT_NOTIFICATION) window.add_events(gtk.gdk.BUTTON_PRESS_MASK) window.connect('button-press-event', self.__buttonpress) darea = self.__darea = gtk.DrawingArea() window.add(self.__darea) darea.show() darea.realize() layout = self.__layout = window.create_pango_layout("") layout.set_justify(False) layout.set_alignment(pango.ALIGN_CENTER) layout.set_wrap(pango.WRAP_WORD) self.__step = 0 # 0=invisible; 255=fully visible self.__stepby = 0 self.__song = None self.__next = None self.__screen = gtk.gdk.screen_get_default() geom = gtk.gdk.Screen.get_monitor_geometry(self.__screen, 0) self.__screenwidth = geom.width self.__screenheight = geom.height self.__coverwidth = min(120, self.__screenwidth // 8) self.__width = self.__height = self.__coverwidth + 2 * self.conf.border self.__delayhide = None
|
darea = self.__darea = gtk.DrawingArea() window.add(self.__darea) darea.show() darea.realize() layout = self.__layout = window.create_pango_layout("") layout.set_justify(False) layout.set_alignment(pango.ALIGN_CENTER) layout.set_wrap(pango.WRAP_WORD) self.__step = 0 self.__stepby = 0 self.__song = None self.__next = None self.__screen = gtk.gdk.screen_get_default() geom = gtk.gdk.Screen.get_monitor_geometry(self.__screen, 0) self.__screenwidth = geom.width self.__screenheight = geom.height self.__coverwidth = min(120, self.__screenwidth // 8) self.__width = self.__height = self.__coverwidth + 2 * self.conf.border self.__delayhide = None for key, value in [ ("text", " ("fill", " ("font", "Sans 22")]: try: value = config.get("plugins", "animosd_" + key) except: config.set("plugins", "animosd_" + key, value) setattr(self.conf, key, value) try: self.conf.delay = config.getint("plugins", "animosd_delay") except: config.set("plugins", "animosd_delay", str(self.conf.delay)) try: self.conf.pos = 0.5, config.getfloat("plugins", "animosd_pos_y") except: config.set("plugins", "animosd_pos_y", str(self.conf.pos[1])) try: self.conf.string = config.get("plugins", "animosd_string") except: config.set("plugins", "animosd_string", self.conf.string) def plugin_single_song(self, song): self.plugin_on_song_started(song) def plugin_on_song_started(self, song): self.__next = song gobject.idle_add(self.show) def wait_until_hidden(self): while self.__stepby < 0: gtk.main_iteration() def hide(self): if self.__step <= 0: return if self.__delayhide is not None: gobject.source_remove(self.__delayhide) self.__delayhide = None if self.__stepby == 0: self.__stepby = -self.conf.step gobject.timeout_add(self.conf.ms, self.render) def show(self): if self.__step > 0: self.hide() return if self.__next is not None: self.__song = self.__next self.__next = None if self.__song is None: return if self.__step >= 255: return self.render_setup(self.__song) if self.__stepby == 0: self.__stepby = self.conf.step gobject.timeout_add(self.conf.ms, self.render) def render_setup(self, song): cover = self.__cover = song.find_cover() if cover is not None: try: self.__cover = gtk.gdk.pixbuf_new_from_file_at_size( cover.name, self.__coverwidth, self.__coverwidth) cw = self.__cover.get_width() ch = self.__cover.get_height() self.__coverx = self.conf.border + (self.__coverwidth - cw) // 2 self.__covery = self.conf.border + (self.__coverwidth - ch) // 2 except: from traceback import print_exc; print_exc() self.__cover = None tw = (self.__screenwidth - 2 * (self.conf.border + self.conf.margin)) if self.__cover is not None: tw -= self.__coverwidth + self.conf.border layout = self.__layout layout.set_font_description(pango.FontDescription(self.conf.font)) layout.set_markup(XMLFromPattern(self.conf.string) % song) layout.set_width(pango.SCALE * tw) self.__textsize = layout.get_pixel_size() layout.set_width(pango.SCALE * min(self.__textsize[0], tw)) self.__textsize = layout.get_pixel_size() w = self.__textsize[0] + 2 * self.conf.border h = max(self.__cover and self.__coverwidth or 0, self.__textsize[1]) + 2 * self.conf.border if self.__cover is not None: w += self.__coverwidth + self.conf.border self.__covery = (h - ch) // 2 darea = self.__darea darea.set_size_request(w, h) self.__width = w self.__height = h sw, sh = self.__screenwidth, self.__screenheight m = self.conf.margin x = int((sw - w) * self.conf.pos[0]) x = self.__winx = max(m, min(sw - m - w, x)) y = int((sh - h) * self.conf.pos[1]) y = self.__winy = max(m, min(sh - m - h, y)) self.__textx = self.conf.border if self.__cover is not None: self.__textx += self.__coverwidth + self.conf.border self.__texty = (h - self.__textsize[1]) // 2 root = gtk.gdk.Screen.get_root_window(self.__screen) self.__bg = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB, 0, 8, w, h) self.__bg.get_from_drawable(root, root.get_colormap(), x, y, 0, 0, w, h) mask = gtk.gdk.Pixmap(darea.window, w, h, 1) maskoff = gtk.gdk.GC(mask) maskoff.set_colormap(darea.window.get_colormap()) maskoff.set_foreground(gtk.gdk.Color(pixel=0)) mask.draw_rectangle(maskoff, True, 0, 0, w, h) maskon = maskoff del maskoff maskon.set_foreground(gtk.gdk.Color(pixel=-1)) dareacmap = darea.get_colormap() img = gtk.gdk.Pixmap(darea.window, w, h) bg_gc = gtk.gdk.GC(img) bg_gc.copy(darea.style.fg_gc[gtk.STATE_NORMAL]) bg_gc.set_colormap(darea.window.get_colormap()) if self.conf.fill is not None: bg_gc.set_foreground(dareacmap.alloc_color(self.conf.fill[:7])) img.draw_rectangle(bg_gc, True, 0, 0, w, h) mask.draw_rectangle(maskon, True, 0, 0, w, h) try: alpha = int(self.conf.fill[7:], 16) except (ValueError,TypeError): alpha = 0 buf = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB, 0, 8, w, h) buf.get_from_drawable(img, img.get_colormap(), 0, 0, 0, 0, w, h) if self.conf.fill is not None: self.__bg.composite(buf, 0, 0, w, h, 0, 0, 1, 1, gtk.gdk.INTERP_NEAREST, 255-alpha) img.draw_pixbuf(darea.style.fg_gc[gtk.STATE_NORMAL], buf, 0, 0, 0, 0) if self.conf.bcolor is not None: bg_gc.set_foreground(dareacmap.alloc_color(self.conf.bcolor)) img.draw_rectangle(bg_gc, False, 0, 0, w - 1, h - 1) mask.draw_rectangle(maskon, False, 0, 0, w - 1, h - 1) fg_gc = gtk.gdk.GC(img) fg_gc.copy(darea.style.fg_gc[gtk.STATE_NORMAL]) fg_gc.set_colormap(dareacmap) tx = self.__textx ty = self.__texty if self.conf.shadow is not None: fg_gc.set_foreground(dareacmap.alloc_color(self.conf.shadow)) img.draw_layout(fg_gc, tx + 2, ty + 2, layout) if self.conf.fill is None: mask.draw_layout(maskon, tx + 2, ty + 2, layout) if self.conf.outline is not None: fg_gc.set_foreground(dareacmap.alloc_color(self.conf.outline)) for dx,dy in [(-1,-1), (-1, 0), (-1, 1), ( 0,-1), ( 0, 1), ( 1,-1), ( 1, 0), ( 1, 1)]: img.draw_layout(fg_gc, tx + dx, ty + dy, layout) if self.conf.fill is None: mask.draw_layout(maskon, tx + dx, ty + dy, layout) fg_gc.set_foreground(dareacmap.alloc_color(self.conf.text)) img.draw_layout(fg_gc, tx, ty, layout) if self.conf.fill is None: mask.draw_layout(maskon, tx, ty, layout) if self.__cover is not None: if self.conf.shadow is not None: fg_gc.set_foreground(dareacmap.alloc_color(self.conf.shadow)) img.draw_rectangle(bg_gc, True, self.__coverx + 2, self.__covery + 2, cw, ch) mask.draw_rectangle(maskon, True, self.__coverx + 2, self.__covery + 2, cw, ch) if self.conf.outline is not None: fg_gc.set_foreground(dareacmap.alloc_color(self.conf.outline)) img.draw_rectangle(bg_gc, False, self.__coverx - 1, self.__covery - 1, cw + 1, ch + 1) mask.draw_rectangle(maskon, False, self.__coverx - 1, self.__covery - 1, cw + 1, ch + 1) img.draw_pixbuf(darea.style.fg_gc[gtk.STATE_NORMAL], self.__cover, 0, 0, self.__coverx, self.__covery) mask.draw_rectangle(maskon, True, 0, 0, self.__coverx, self.__covery) self.__img = img self.__window.shape_combine_mask(mask, 0, 0) self.__window.move(x, y) self.__window.resize(w, h) def render(self): w = self.__width h = self.__height x = self.__winx y = self.__winy darea = self.__darea self.__step = max(0, min(255, self.__step + self.__stepby)) if 0 < self.__step < 255: buf = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB, 0, 8, w, h) buf.get_from_drawable(self.__img, self.__img.get_colormap(), 0, 0, 0, 0, w, h) self.__bg.composite(buf, 0, 0, w, h, 0, 0, 1, 1, gtk.gdk.INTERP_NEAREST, 255-self.__step) img = gtk.gdk.Pixmap(darea.window, w, h) img.draw_pixbuf(darea.style.fg_gc[gtk.STATE_NORMAL], buf, 0, 0, 0, 0)
|
window.connect('fade-finished', self.__fade_finished) self.__current_window = window window.set_opacity(0.0) window.show() window.fade_in() def start_fade_out(self, window): window.fade_out() return False def __buttonpress(self, window, event): window.hide() if self.__current_window is window: self.__current_window = None window.destroy() def __fade_finished(self, window, fade_in): if fade_in: gobject.timeout_add(self.conf.delay, self.start_fade_out, window)
|
def __init__(self): window = self.__window = gtk.Window(gtk.WINDOW_POPUP) window.set_type_hint(gtk.gdk.WINDOW_TYPE_HINT_NOTIFICATION) window.add_events(gtk.gdk.BUTTON_PRESS_MASK) window.connect('button-press-event', self.__buttonpress) darea = self.__darea = gtk.DrawingArea() window.add(self.__darea) darea.show() darea.realize() layout = self.__layout = window.create_pango_layout("") layout.set_justify(False) layout.set_alignment(pango.ALIGN_CENTER) layout.set_wrap(pango.WRAP_WORD) self.__step = 0 # 0=invisible; 255=fully visible self.__stepby = 0 self.__song = None self.__next = None self.__screen = gtk.gdk.screen_get_default() geom = gtk.gdk.Screen.get_monitor_geometry(self.__screen, 0) self.__screenwidth = geom.width self.__screenheight = geom.height self.__coverwidth = min(120, self.__screenwidth // 8) self.__width = self.__height = self.__coverwidth + 2 * self.conf.border self.__delayhide = None
|
img = self.__img darea.window.set_back_pixmap(img, False) darea.queue_draw_area(0, 0, w, h) if self.__step <= 0: del self.__bg self.__window.hide() self.__stepby = 0 self.__step = 0 self.__song = None if self.__next is not None: gobject.timeout_add(self.conf.ms, self.show) return gobject.idle_add(self.__window.show) if self.__step >= 255: self.__stepby = 0 self.__step = 255 self.__delayhide = gobject.timeout_add(self.conf.delay, self.hide) return return True def __buttonpress(self, *args): self.__stepby = self.__step = 0 self.__window.hide()
|
window.hide() if self.__current_window is window: self.__current_window = None gobject.timeout_add(1000, window.destroy)
|
def render(self): w = self.__width h = self.__height x = self.__winx y = self.__winy darea = self.__darea self.__step = max(0, min(255, self.__step + self.__stepby))
|
else: return ngettext("%d time", "%d times", i) % i
|
else: return ngettext("%(n)d time", "%(n)d times", i) % {"n": i}
|
def counter(i): if i == 0: return _("Never") else: return ngettext("%d time", "%d times", i) % i
|
parent.window.set_cursor(None)
|
if parent.window: parent.window.set_cursor(None)
|
def __disconnect(self, sig, parent): parent.window.set_cursor(None) parent.disconnect(sig)
|
self.__update_icon()
|
def enabled(self): global gtk_216 filename = os.path.join(const.IMAGEDIR, "quodlibet.") if gtk_216: self.__icon = gtk.StatusIcon() else: self.__icon = EggTrayIconWrapper() self.__update_icon()
|
|
"""A AlbumLibrary listens to a SongLibrary and sorts it's songs into albums. The library behaves like a dictionary: The keys are album_keys of
|
"""An AlbumLibrary listens to a SongLibrary and sorts its songs into albums. The library behaves like a dictionary: the keys are album_keys of
|
def reload(self, item, changed=None, removed=None): """Reload a song.""" re_add = [] print_d("Reloading %r" % item.key, self) for library in self.libraries.itervalues(): try: del(library._contents[item.key]) except KeyError: pass else: re_add.append(library) try: library = re_add[0] except IndexError: return # Rely on the first library in the list to do the actual # load, then just inform the other libraries what happened. was_changed, was_removed = library._load(item) if was_removed: for library in re_add: library.emit('removed', [item]) elif was_changed: for library in re_add: library._contents[item.key] = item library.emit('changed', [item])
|
if not (store["a"] and store["t"]):
|
if not (store.get("a") and store.get("t")):
|
def _format_song(self, song): """Returns a dict with the keys formatted as required by spec.""" store = { "l": str(song("~#length")), "n": str(song("~#track")), "b": song.comma("album"), "m": song("musicbrainz_trackid") }
|
self.check_config()
|
def __init__(self): self.nowplaying_song = None self.nowplaying_sent = False self.sessionid = None
|
|
def check_config(self):
|
def _check_config(self):
|
def check_config(self): user = config_get('username') passw = md5(config_get('password')).hexdigest() url = config_get_url() if not user or not passw or not url: self.quick_dialog("Please visit the Preferences window to set " "QLScrobbler up. Until then, songs will not be " "submitted.", gtk.MESSAGE_INFO) self.broken = True elif (self.username, self.password, self.base_url)!=(user, passw, url): print "kk" self.username, self.password, self.base_url = (user, passw, url) self.broken = False self.handshake_sent = False self.offline = (config_get('offline') == "true") self.changed()
|
self.quick_dialog("Please visit the Preferences window to set "
|
if self.queue and not self.broken: self.quick_dialog("Please visit the Plugins window to set "
|
def check_config(self): user = config_get('username') passw = md5(config_get('password')).hexdigest() url = config_get_url() if not user or not passw or not url: self.quick_dialog("Please visit the Preferences window to set " "QLScrobbler up. Until then, songs will not be " "submitted.", gtk.MESSAGE_INFO) self.broken = True elif (self.username, self.password, self.base_url)!=(user, passw, url): print "kk" self.username, self.password, self.base_url = (user, passw, url) self.broken = False self.handshake_sent = False self.offline = (config_get('offline') == "true") self.changed()
|
print "kk"
|
def check_config(self): user = config_get('username') passw = md5(config_get('password')).hexdigest() url = config_get_url() if not user or not passw or not url: self.quick_dialog("Please visit the Preferences window to set " "QLScrobbler up. Until then, songs will not be " "submitted.", gtk.MESSAGE_INFO) self.broken = True elif (self.username, self.password, self.base_url)!=(user, passw, url): print "kk" self.username, self.password, self.base_url = (user, passw, url) self.broken = False self.handshake_sent = False self.offline = (config_get('offline') == "true") self.changed()
|
|
self.changed()
|
def check_config(self): user = config_get('username') passw = md5(config_get('password')).hexdigest() url = config_get_url() if not user or not passw or not url: self.quick_dialog("Please visit the Preferences window to set " "QLScrobbler up. Until then, songs will not be " "submitted.", gtk.MESSAGE_INFO) self.broken = True elif (self.username, self.password, self.base_url)!=(user, passw, url): print "kk" self.username, self.password, self.base_url = (user, passw, url) self.broken = False self.handshake_sent = False self.offline = (config_get('offline') == "true") self.changed()
|
|
self.queue.check_config()
|
self.queue.changed()
|
def destroyed(*args): self.queue.check_config()
|
self.pack_start(gtk.Label(_("Lyrics provided by %s.") %( "http://lyricwiki.org")), expand=False)
|
def __init__(self, song): super(LyricsPane, self).__init__(spacing=12) self.set_border_width(12) view = gtk.TextView() sw = gtk.ScrolledWindow() sw.add(view) refresh = qltk.Button(_("_Download"), gtk.STOCK_CONNECT) save = gtk.Button(stock=gtk.STOCK_SAVE) delete = gtk.Button(stock=gtk.STOCK_DELETE) add = gtk.Button(stock=gtk.STOCK_EDIT) view.set_wrap_mode(gtk.WRAP_WORD) sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
|
|
bbox.pack_start(refresh)
|
def __init__(self, song): super(LyricsPane, self).__init__(spacing=12) self.set_border_width(12) view = gtk.TextView() sw = gtk.ScrolledWindow() sw.add(view) refresh = qltk.Button(_("_Download"), gtk.STOCK_CONNECT) save = gtk.Button(stock=gtk.STOCK_SAVE) delete = gtk.Button(stock=gtk.STOCK_DELETE) add = gtk.Button(stock=gtk.STOCK_EDIT) view.set_wrap_mode(gtk.WRAP_WORD) sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
|
|
if os.path.exists(lyricname): buffer.set_text(file(lyricname).read()) else: buffer.set_text(_("No lyrics found.\n\nYou can click the " "Download button to have Quod Libet search " "for lyrics online. You can also enter them " "yourself and click save."))
|
if os.path.exists(lyricname): buffer.set_text(file(lyricname).read()) else: buffer.set_text(_("No lyrics found for this song."))
|
def __init__(self, song): super(LyricsPane, self).__init__(spacing=12) self.set_border_width(12) view = gtk.TextView() sw = gtk.ScrolledWindow() sw.add(view) refresh = qltk.Button(_("_Download"), gtk.STOCK_CONNECT) save = gtk.Button(stock=gtk.STOCK_SAVE) delete = gtk.Button(stock=gtk.STOCK_DELETE) add = gtk.Button(stock=gtk.STOCK_EDIT) view.set_wrap_mode(gtk.WRAP_WORD) sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
|
cover['cover'] = cover['thumbnail'].replace('/thumbs/', '/')
|
id = cover['thumbnail'].split("/")[-1].split(".")[0] cover['cover'] = self.root_url + "/res/exe/GetElement.php?ID=" + id
|
def __extract_from_list(self): """Extracts all the needed information from the already parsed search result page and adds the found cover to the list."""
|
url_sock = urllib2.urlopen(url) while not self.stop_loading: tmp = url_sock.read(1024 * 10) if not tmp: break pbloader.write(tmp) data_store.write(tmp) url_sock.close() if not self.stop_loading: raw_data = data_store.getvalue() self.data_cache.insert(0, (url, raw_data)) while 1: cache_sizes = [len(data[1]) for data in self.data_cache] if sum(cache_sizes) > self.max_cache_size: del self.data_cache[-1] else: break
|
try: url_sock = urllib2.urlopen(url) except urllib2.HTTPError: print_w(_("[albumart] HTTP Error: %s") % url) else: while not self.stop_loading: tmp = url_sock.read(1024 * 10) if not tmp: break pbloader.write(tmp) data_store.write(tmp) url_sock.close() if not self.stop_loading: raw_data = data_store.getvalue() self.data_cache.insert(0, (url, raw_data)) while 1: cache_sizes = [len(data[1]) for data in self.data_cache] if sum(cache_sizes) > self.max_cache_size: del self.data_cache[-1] else: break
|
def __set_async(self, url): """manages various stuff like fast switching of covers (aborting old HTTP requests), managing the image cache etc."""
|
self.connect('window-state-event', self.__window_state_changed) self.__hidden_state = 0
|
def delayed_song_set(): song = library.get(config.get("memory", "song")) seek_pos = config.getint("memory", "seek") config.set("memory", "seek", 0) player.setup(self.playlist, song, seek_pos)
|
|
def __window_state_changed(self, window, event): assert window is self self.__window_state = event.new_window_state
|
def __window_state_changed(self, window, event): assert window is self self.__window_state = event.new_window_state
|
|
self.__hidden_state = self.__window_state if self.__hidden_state & gtk.gdk.WINDOW_STATE_MAXIMIZED: self.unmaximize()
|
def hide(self): self.__hidden_state = self.__window_state if self.__hidden_state & gtk.gdk.WINDOW_STATE_MAXIMIZED: self.unmaximize() super(QuodLibetWindow, self).hide() map(gtk.Window.hide, qltk.Window.childs)
|
|
if self.__hidden_state & gtk.gdk.WINDOW_STATE_MAXIMIZED: self.maximize()
|
def present(self): super(QuodLibetWindow, self).present() if self.__hidden_state & gtk.gdk.WINDOW_STATE_MAXIMIZED: self.maximize() map(gtk.Window.present, qltk.Window.childs)
|
|
if self.__hidden_state & gtk.gdk.WINDOW_STATE_MAXIMIZED: self.maximize()
|
def show(self): super(QuodLibetWindow, self).show() if self.__hidden_state & gtk.gdk.WINDOW_STATE_MAXIMIZED: self.maximize() map(gtk.Window.show, qltk.Window.childs)
|
|
song['performers'] = '\n'.join(feats)
|
feat = [] for value in feats: values = value.split(', ') if len(values) > 1: values += values.pop().split(' & ') feat += values song['performer'] = '\n'.join(feat)
|
def __save(self, widget=None, response=None): """Writes values to Song objects.""" self._qthread.stop() if response != gtk.RESPONSE_ACCEPT: self.destroy() return
|
self.failUnless(Query(" self.failUnless(Query("
|
self.failIf(Query(" self.failIf(Query("
|
def test_numcmp(self): self.failUnless(Query("#(track = 0)").search(self.s1)) self.failUnless(Query("#(notatag = 0)").search(self.s1)) self.failUnless(Query("#(track = 12)").search(self.s2))
|
(library, player, False))
|
(library, player))
|
def __create_menu(self, player, library): ag = gtk.ActionGroup('QuodLibetWindowActions')
|
def select_browser(self, activator, current, library, player, restore):
|
def select_browser(self, activator, current, library, player, restore=False):
|
def select_browser(self, activator, current, library, player, restore): if isinstance(current, gtk.RadioAction): current = current.get_current_value() Browser = browsers.get(current) config.set("memory", "browser", Browser.__name__) if self.browser: container = self.browser.__container self.browser.unpack(container, self.songpane) if self.browser.accelerators: self.remove_accel_group(self.browser.accelerators) container.destroy() self.browser.destroy() self.browser = Browser(library, player) self.browser.connect('songs-selected', self.__browser_cb) if restore: self.browser.restore() self.browser.activate() self.browser.finalize(restore) if self.browser.reordered: self.songlist.enable_drop() elif self.browser.dropped: self.songlist.enable_drop(False) else: self.songlist.disable_drop() if self.browser.accelerators: self.add_accel_group(self.browser.accelerators)
|
pos = self.get_position() config.set('memory', 'position', '%s %s' % pos)
|
def hide(self): pos = self.get_position() config.set('memory', 'position', '%s %s' % pos) super(QuodLibetWindow, self).hide() map(gtk.Window.hide, qltk.Window.childs)
|
|
self.hide()
|
def destroy(self, *args): # For saving the window position self.hide() # The tray icon plugin tries to unhide QL because it gets disabled # on Ql exit. The window should be hidden after destroy gets called. self.show = lambda: None self.present = self.show super(QuodLibetWindow, self).destroy()
|
|
protocols = ['ipod']
|
def create_device(self, backend_id, device_id, protocols): """backend_id is the string that gets passed to the backend so it can identify the device. device_id should be a something including the device serial (so it's unique) and maybe the model name.""" device = None
|
|
entry_names = ['url', 'username', 'password', 'titlepat', 'artistpat']
|
entry_names = ['url', 'username', 'password', 'artistpat', 'titlepat']
|
def destroyed(*args): self.queue.changed()
|
self.model.remove(len(self.model) - 1)
|
itr = self.model.get_iter_from_string(str(len(self.model) - 1)) self.model.remove(itr)
|
def update_remote_album(self, remote_album): """Updates the TreeView, handling results with a different number of tracks than the album being tagged.""" for i in range(len(self.model), len(remote_album)): self.model.append((None, )) for i in range(len(self.model), len(remote_album), -1): if self.model[-1][0] is not None: break self.model.remove(len(self.model) - 1) self.remote_album = remote_album has_artists = bool(filter(lambda t: t.artist, remote_album)) self.get_column(3).set_visible(has_artists) self.columns_autosize() self.queue_draw()
|
util.format_time(sum([t.get("~
|
util.format_time(sum([t("~
|
def format(self): return "<b>%s</b>\n<small>%s (%s)</small>" % ( util.escape(self.name), ngettext("%d song", "%d songs", len(self)) % len(self), util.format_time(sum([t.get("~#length") for t in self if isinstance(t, AudioFile)])))
|
gtk.main_iteration()
|
gtk.main_iteration(block=False)
|
def __expanded(self, iter, path, model): window = self.window if window: window.set_cursor(gtk.gdk.Cursor(gtk.gdk.WATCH)) gtk.main_iteration() try: try: if model is None: return while model.iter_has_child(iter): model.remove(model.iter_children(iter)) folder = model[iter][0] for path in util.listdir(folder): try: for filename in util.listdir(path): if os.path.isdir(filename): niter = model.append(iter, [path]) model.append(niter, ["dummy"]) break else: model.append(iter, [path]) except OSError: pass if not model.iter_has_child(iter): return True except OSError: pass finally: if window: window.set_cursor(None)
|
return widget and widget.get_ancestor(gtk.Window)
|
parent = widget and widget.get_toplevel() if parent and (parent.flags() & gtk.TOPLEVEL): return parent else: return None
|
def get_top_parent(widget): """Return the ultimate parent of a widget; the assumption that code using this makes is that it will be a gtk.Window, i.e. the widget is fully packed when this is called.""" return widget and widget.get_ancestor(gtk.Window)
|
if not isinstance(title, unicode):
|
if not isinstance(s, unicode):
|
def human_sort_key(s): if not isinstance(title, unicode): s = s.decode("utf-8") s = unicodedata.normalize('NFD', s.lower()) return split_numeric(s)
|
util.decode(row[VALUE])))
|
util.decode(row[VALUE]), util.decode(row[ORIGVALUE])))
|
def __save_files(self, save, revert, model, library): updated = {} deleted = {} added = {} renamed = {} for row in model: if row[EDITED] and not (row[DELETED] or row[RENAMED]): if row[ORIGVALUE] is not None: updated.setdefault(row[TAG], []) updated[row[TAG]].append((util.decode(row[VALUE]), util.decode(row[ORIGVALUE]))) else: added.setdefault(row[TAG], []) added[row[TAG]].append(util.decode(row[VALUE])) if row[EDITED] and row[DELETED]: if row[ORIGVALUE] is not None: deleted.setdefault(row[TAG], []) deleted[row[TAG]].append(util.decode(row[ORIGVALUE]))
|
for old_tag, value in values:
|
for old_tag, new_value, old_value in values:
|
def __save_files(self, save, revert, model, library): updated = {} deleted = {} added = {} renamed = {} for row in model: if row[EDITED] and not (row[DELETED] or row[RENAMED]): if row[ORIGVALUE] is not None: updated.setdefault(row[TAG], []) updated[row[TAG]].append((util.decode(row[VALUE]), util.decode(row[ORIGVALUE]))) else: added.setdefault(row[TAG], []) added[row[TAG]].append(util.decode(row[VALUE])) if row[EDITED] and row[DELETED]: if row[ORIGVALUE] is not None: deleted.setdefault(row[TAG], []) deleted[row[TAG]].append(util.decode(row[ORIGVALUE]))
|
if not is_special(value): song.remove(old_tag, value) save_rename.append((new_tag, value)) elif is_missing(value): value = strip_missing(value) song.remove(old_tag, value) save_rename.append((new_tag, value))
|
if not is_special(new_value): song.remove(old_tag, old_value) save_rename.append((new_tag, new_value)) elif is_missing(new_value): value = strip_missing(old_value) song.remove(old_tag, old_value) save_rename.append((new_tag, new_value))
|
def __save_files(self, save, revert, model, library): updated = {} deleted = {} added = {} renamed = {} for row in model: if row[EDITED] and not (row[DELETED] or row[RENAMED]): if row[ORIGVALUE] is not None: updated.setdefault(row[TAG], []) updated[row[TAG]].append((util.decode(row[VALUE]), util.decode(row[ORIGVALUE]))) else: added.setdefault(row[TAG], []) added[row[TAG]].append(util.decode(row[VALUE])) if row[EDITED] and row[DELETED]: if row[ORIGVALUE] is not None: deleted.setdefault(row[TAG], []) deleted[row[TAG]].append(util.decode(row[ORIGVALUE]))
|
f = open(file_path, 'w')
|
f = open(file_path, 'wb')
|
def __save(self, *data): """save the cover, spawn the program to edit it if selected"""
|
self.__show_window()
|
def disabled(self): global gtk_216 if self.__w_sig_map and window.handler_is_connected(self.__w_sig_map): window.disconnect(self.__w_sig_map) if self.__w_sig_del and window.handler_is_connected(self.__w_sig_del): window.disconnect(self.__w_sig_del) if self.__icon: self.__icon.set_visible(False) try: self.__icon.destroy() except AttributeError: pass self.__icon = None self.__show_window()
|
|
menu = gtk.Menu()
|
if sys.platform == "win32": if self.__menu: self.__menu.destroy() self.__menu = None self.__menu = menu = gtk.Menu()
|
def __button_right(self, icon, button, time): global gtk_216 menu = gtk.Menu()
|
if gtk_216:
|
if sys.platform == "win32": menu.popup(None, None, None, button, time, self.__icon) elif gtk_216:
|
def set_rating(value): song = player.song if song is None: return else: song["~#rating"] = value watcher.changed([song])
|
model, rows = self.get_selection().get_selected_rows()
|
selection = self.get_selection() if selection is None: return [] model, rows = selection.get_selected_rows()
|
def get_selected_songs(self): model, rows = self.get_selection().get_selected_rows() return [model[row][0] for row in rows]
|
(GnomeDep('gtk+', '2.20', '[^"]*-bundle_.*_win32.zip'), ZipInst('gtk')),
|
(GnomeDep('gtk+', '2.16', '[^"]*-bundle_.*_win32.zip'), ZipInst('gtk')), (GnomeDep('glib', '2.24', 'glib_[^"]*_win32.zip'), ZipInst('gtk')),
|
def do_setup(rev): PYVER='2.6' deps = [ (PythonDep('Python', PYVER), MSIInst('Python')), (OnePageDep('setuptools', None, 'http://pypi.python.org/pypi/setuptools', '[^"]*setuptools[^"]*tar.gz[^"#]*'), SetuptoolsInst()), (SFDep('gnuwin32', None, 'unrar-[1234567890.]*-bin.zip'), ZipInst('Python')), (SFDep('innounp', None, 'innounp[1234567890.]*.rar'), UnrarInst('Python')), (GnomeDep('libglade', '2.6', '[^"]*libglade_[^"]*win32.zip'), ZipInst('gtk')), (OnePageDep('libbzip2', None, 'http://ftp.gnome.org/pub/gnome/binaries/win32/dependencies/', '[^"]*libbzip2_[^"]*.zip[^"#]*'), ZipInst('gtk')), (GnomeDep('libcroco', '0.6', '[^"]*libcroco_[^"]*win32.zip'), ZipInst('gtk')), (GnomeDep('libgsf', '1.14', '[^"]*libgsf_[^"]*win32.zip'), ZipInst('gtk')), (GnomeDep('librsvg', '2.26', '[^"]*librsvg_[^"]*win32.zip'), ZipInst('gtk')), (GnomeDep('librsvg', '2.26', '[^"]*svg-gdk-pixbuf-loader_[^"]*win32.zip'), ZipInst('gtk')), (GnomeDep('pycairo', '1.8', '[^"]*win32-py%s.exe' % PYVER), EasyInstallExeInst()), (GnomeDep('pygobject', '2.20', '[^"]*win32-py%s.exe' % PYVER), EasyInstallExeInst()), (GnomeDep('pygtk', '2.16', '[^"]*glade.win32-py%s.exe' % PYVER), EasyInstallExeInst()), (OnePageDep('GStreamer', None, 'http://www.gstreamer-winbuild.ylatuya.es/doku.php?id=download', '[^"]*GStreamerWinBuild-[1234567890.]*.exe'), InnoInst('gstreamer')), (OnePageDep('pygst', None, 'http://www.gstreamer-winbuild.ylatuya.es/doku.php?id=download', '[^"]*Pygst-[^"]*-Python%s[^"]*' % PYVER.replace('.', '')), InnoInst('Python')), (SFDep('py2exe', None, 'py2exe-[1234567890.]*.win32-py%s.exe' % PYVER), EasyInstallExeInst()), (SFDep('pywin32', None, 'pywin32-[1234567890.]*.win32-py%s.exe' % PYVER), EasyInstallExeInst()), (EasyInstallDep('mutagen'), EasyInstallInst()), (EasyInstallDep('feedparser'), EasyInstallInst()), (EasyInstallDep('python-musicbrainz2'), EasyInstallInst()), (GnomeDep('gtk+', '2.20', '[^"]*-bundle_.*_win32.zip'), ZipInst('gtk')), #OnePageStep('NSIS', None, re='[^"]*nsis-[1234567890.]*-setup.exe[^"]*', # page='http://nsis.sourceforge.net/Download', args=['/S']), ] fmt = '%-20s %-15s %s' print print fmt % ('Package', 'Newest', 'Selected') for (dep, inst) in deps: print fmt % (dep.name, dep.versions[0], dep.filename) print 'Hit enter to continue...' raw_input() print '\nFetching unfetched dependencies...' for (dep, inst) in deps: if not dep.fetched: fn = join(CACHEDIR, dep.filename) with open(fn + '.tmp', 'wb') as fp: [fp.write(data) for data in urlfetch(dep.url)] os.rename(fn + '.tmp', fn) print '\nStarting installation...' new_paths = [join(TDIR, 'Python' + d) for d in ['', r'\bin', r'\scripts']] new_paths += [join(TDIR, 'gstreamer'), join(TDIR, r'gstreamer\bin')] new_paths += [join(TDIR, 'gtk'), join(TDIR, r'gtk\bin')] print os.environ['PATH'] #subprocess.check_call(['path', ';'.join(new_paths + ['%PATH%'])]) os.environ['PATH'] = ';'.join(new_paths + [os.environ['PATH']]) print os.environ['PATH'] for (dep, inst) in deps: print 'Installing %s' % dep.name inst.install(dep) old_path = os.getcwd() repo_path = join(TDIR, 'ql') print 'Cloning this repo into temporary directory' ccall([HG_PATH, 'clone', '..', repo_path]) with chdir(join(repo_path, 'quodlibet')): print 'Updating to revision %s' % rev ccall([HG_PATH, 'pull']) ccall([HG_PATH, 'up', rev]) print 'Assembling Windows binary' ccall(['python', 'setup.py', 'py2exe']) dist_path = join(TDIR, r'ql\quodlibet\dist') # You must have a license to restribute the resulting installer #for file in ['Microsoft.VC90.CRT.manifest', 'msvcr90.dll']: # shutil.copy(join(TDIR, 'Python', file), dist_path) # Copy required files from GStreamer distribution gst_path = join(TDIR, 'gstreamer') for file in filter(lambda f: f.endswith('.dll'), os.listdir(join(gst_path, 'bin'))): if not os.path.isfile(join(dist_path, file)): shutil.copy(join(gst_path, 'bin', file), dist_path) for dir in ['lib', 'share', 'etc']: copytree2(join(gst_path, dir), join(dist_path, dir)) # Copy required files from GTK+ gtk_path = join(TDIR, 'gtk') # Generate pixbuf loaders file target = os.path.join(gtk_path, 'etc', 'gtk-2.0', 'gdk-pixbuf.loaders') process = subprocess.Popen(['gdk-pixbuf-query-loaders.exe'], shell=False, stdout=subprocess.PIPE) text = process.communicate()[0] text = re.compile('".*\/(.*?)\.dll"').sub('\"lib/gtk-2.0/2.10.0/loaders/\\1.dll\"', text) f = open(target, 'wb') f.write(text) f.close() for file in filter(lambda f: f.endswith('.dll'), os.listdir(join(gtk_path, 'bin'))): if not os.path.isfile(join(dist_path, file)): shutil.copy(join(gtk_path, 'bin', file), dist_path) for dir in ['lib/gtk-2.0', 'share/locale', 'share/themes', 'etc']: copytree2(join(gtk_path, dir), join(dist_path, dir)) built_locales = join(os.getcwd(), r'..\quodlibet\build\share\locale') # Prune GTK locales without a corresponding QL one: for locale in os.listdir(join(dist_path, r'share\locale')): if not os.path.isdir(join(built_locales, locale)): shutil.rmtree(join(dist_path, r'share\locale', locale)) # Copy over QL locales for locale in os.listdir(built_locales): dest = join(dist_path, r'share\locale', locale, 'LC_MESSAGES') if not os.path.isdir(dest): os.makedirs(dest) shutil.copy(join(built_locales, locale, r'LC_MESSAGES\quodlibet.mo'), dest) # Set the theme shutil.copy(join(dist_path, r'share\themes\MS-Windows\gtk-2.0\gtkrc'), join(dist_path, r'etc\gtk-2.0')) print "\n\nIf you have a license for redistributing the MSVC runtime," print "you should drop it in %s now." % join(TDIR, r'ql\quodlibet\dist') print "Otherwise just hit enter." raw_input() # Finally, run that installer script. subprocess.check_call([NSIS_PATH, join(TDIR, r'ql\junk\win_installer.nsi')]) shutil.copy(join(TDIR, r'ql\junk\quodlibet-LATEST.exe'), 'quodlibet-%s-installer.exe' % rev.replace('quodlibet-', ''))
|
print_w(_("%r is not a supported device.") % path)
|
print_w(_("%r is not a supported device.") % device_id)
|
def create_device(self, backend_id, device_id, protocols): """backend_id is the string that gets passed to the backend so it can identify the device. device_id should be a something including the device serial (so it's unique) and maybe the model name.""" klass = get_by_protocols(protocols) if klass: device = klass(backend_id, device_id) return device else: print_w(_("%r is not a supported device.") % path)
|
self.window.input_shape_combine_region(self.__empty_region, 0, 0) self.__leave_event = widget.connect('leave-notify-event', self.__undisplay)
|
gobject.idle_add(self.__connect_leave, priority=gobject.PRIORITY_DEFAULT)
|
def __expose(self, widget, event): w, h = self.get_size_request() self.style.paint_flat_box(self.window, gtk.STATE_NORMAL, gtk.SHADOW_OUT, None, self, "tooltip", 0, 0, w, h) self.window.input_shape_combine_region(self.__empty_region, 0, 0) self.__leave_event = widget.connect('leave-notify-event', self.__undisplay)
|
except TypeError: return
|
except TypeError: return self.__undisplay()
|
def __motion(self, view, event): # trigger over row area, not column headers if event.window is not view.get_bin_window(): return self.__undisplay() suppress = (gtk.gdk.CONTROL_MASK | gtk.gdk.SHIFT_MASK | gtk.gdk.SUPER_MASK | gtk.gdk.HYPER_MASK | gtk.gdk.META_MASK) if event.get_state() & suppress: return self.__undisplay()
|
self.__target = view
|
self.__disconnect_leave() self.__view = view
|
def __motion(self, view, event): # trigger over row area, not column headers if event.window is not view.get_bin_window(): return self.__undisplay() suppress = (gtk.gdk.CONTROL_MASK | gtk.gdk.SHIFT_MASK | gtk.gdk.SUPER_MASK | gtk.gdk.HYPER_MASK | gtk.gdk.META_MASK) if event.get_state() & suppress: return self.__undisplay()
|
custom.headers = config.get("browsers", "panes").split("\t")
|
custom.headers = headers
|
def __init__(self, parent=None): if self.is_not_unique(): return super(Preferences, self).__init__() self.set_transient_for(qltk.get_top_parent(parent))
|
for t in config.get("browsers", "panes").split("\t"):
|
for t in headers:
|
def __init__(self, parent=None): if self.is_not_unique(): return super(Preferences, self).__init__() self.set_transient_for(qltk.get_top_parent(parent))
|
current = config.get("browsers", "panes").split("\t") if current == gpa.headers: gpa.set_active(True) elif current == pa.headers: pa.set_active(True)
|
if headers == gpa.headers: gpa.set_active(True) elif headers == pa.headers: pa.set_active(True)
|
def __init__(self, parent=None): if self.is_not_unique(): return super(Preferences, self).__init__() self.set_transient_for(qltk.get_top_parent(parent))
|
panes = config.get("browsers", "panes").split("\t"); panes.reverse()
|
panes = Preferences.get_headers() panes.reverse()
|
def refresh_panes(self): try: hbox = self.get_children()[1] except IndexError: pass # first call else: hbox.destroy()
|
def __count_cdf(column, cell, model, iter): try: cell.set_property('text', "(%d)" % (len(model[iter][1]))) except TypeError: cell.set_property('text', '') __count_cdf = staticmethod(__count_cdf) def __text_cdf(column, cell, model, iter): cell.markup = model[iter][0]
|
@staticmethod def __count_cdf(column, cell, model, iter, display_pattern): type, songs = model[iter] if type != ALL: cell.markup = display_pattern(songs) else: cell.markup = ""
|
def __count_cdf(column, cell, model, iter): try: cell.set_property('text', "(%d)" % (len(model[iter][1]))) except TypeError: cell.set_property('text', '')
|
__text_cdf = staticmethod(__text_cdf) def __init__(self, mytag, next, library):
|
@staticmethod def __text_cdf(column, cell, model, iter, markup): type, songs = model[iter] if type == SONGS: if markup: cell.markup = songs.key cell.set_property('markup', cell.markup) else: cell.markup = None cell.set_property('text', songs.key) else: if type == ALL: cell.markup = ALL_MARKUP else: cell.markup = UNKNOWN_MARKUP cell.set_property('markup', cell.markup) def __init__(self, prefs, next, library):
|
def __text_cdf(column, cell, model, iter): cell.markup = model[iter][0] cell.set_property('markup', cell.markup)
|
if '<' in mytag: p = Pattern(mytag) self.__format = lambda song: p.format_list(song) self.tags = p.real_tags(cond=False) title = pattern(mytag) else: title = tag(mytag) self.tags = util.tagsplit(mytag) if mytag[:2] == "~ self.__format = lambda song: [unicode(song(mytag))] else: self.__format = lambda song: song.list_separate(mytag)
|
title, self.tags, self.__format, \ self.__markup, disp_format = self.__parse_prefs(prefs)
|
def __init__(self, mytag, next, library): super(PanedBrowser.Pane, self).__init__() self.set_fixed_height_mode(True)
|
model = gtk.ListStore(str, object)
|
self.__model = model = gtk.ListStore(int, object)
|
def __init__(self, mytag, next, library): super(PanedBrowser.Pane, self).__init__() self.set_fixed_height_mode(True)
|
column = gtk.TreeViewColumn(title)
|
self.__key_cache = {} column = gtk.TreeViewColumn() label = gtk.Label(title) label.set_use_markup(True) column.set_widget(label) label.show()
|
def __init__(self, mytag, next, library): super(PanedBrowser.Pane, self).__init__() self.set_fixed_height_mode(True)
|
column.set_cell_data_func(self.__render, self.__text_cdf)
|
column.set_cell_data_func(self.__render, self.__text_cdf, self.__markup)
|
def __init__(self, mytag, next, library): super(PanedBrowser.Pane, self).__init__() self.set_fixed_height_mode(True)
|
column.set_cell_data_func(self.__render_count, self.__count_cdf)
|
column.set_cell_data_func(self.__render_count, self.__count_cdf, disp_format)
|
def __init__(self, mytag, next, library): super(PanedBrowser.Pane, self).__init__() self.set_fixed_height_mode(True)
|
self.__sig = selection.connect('changed', self.__changed) self.connect_object('destroy', self.__destroy, model) self.connect('popup-menu', self.__popup_menu, library)
|
self.__sig = selection.connect('changed', self.__selection_changed) s = self.connect('popup-menu', self.__popup_menu, library) self.connect_object('destroy', self.disconnect, s)
|
def __init__(self, mytag, next, library): super(PanedBrowser.Pane, self).__init__() self.set_fixed_height_mode(True)
|
songs = sorted(self.__get_songs(), key=lambda s: s.sort_key)
|
songs = self.__get_selected_songs(sort=True)
|
def __drag_data_get(self, view, ctx, sel, tid, etime): songs = sorted(self.__get_songs(), key=lambda s: s.sort_key) if tid == 1: filenames = [song("~filename") for song in songs] sel.set("text/x-quodlibet-songs", 8, "\x00".join(filenames)) else: sel.set_uris([song("~uri") for song in songs])
|
def __human_sort_key(self, text): try: return self.__sort_cache[text]
|
@staticmethod def __parse_prefs(row_pattern): """ Row pattern format: 'categorize_pattern:display_pattern' * display_pattern is optional (fallback: ~ * patterns, tied and normal tags. * display patterns can have function prefixes for numerical tags. * ':' has to be escaped ('\:') TODO: sort pattern, filter query """ parts = re.split(r"(?<!\\):", row_pattern) parts = map(lambda p: p.replace("\:", ":"), parts) is_numeric = lambda s: s[:2] == "~ is_pattern = lambda s: '<' in s f_round = lambda s: (isinstance(s, float) and "%.2f" % s) or s disp = (len(parts) >= 2 and parts[1]) or "\<i\>(<~ cat = parts[0] if is_pattern(cat): title = pattern(cat, esc=True) try: pc = XMLFromPattern(cat) except ValueError: pc = XMLFromPattern("") tags = pc.real_tags(cond=False) format = pc.format_list format_markup = True else: title = tag(cat) tags = util.tagsplit(cat) format_markup = False if is_numeric(cat): format = lambda song: [unicode(f_round(song(cat)))] else: format = lambda song: song.list_separate(cat) if is_pattern(disp): try: pd = XMLFromPattern(disp) except ValueError: pd = XMLFromPattern("") format_display = pd.format else: if is_numeric(disp): format_display = lambda coll: unicode(f_round(coll(disp))) else: format_display = lambda coll: util.escape(coll.comma(disp)) return title, tags, format, format_markup, format_display def __get_format_keys(self, song): try: return self.__key_cache[song]
|
def __human_sort_key(self, text): try: return self.__sort_cache[text] except KeyError: self.__sort_cache[text] = util.human_sort_key(text) return self.__sort_cache[text]
|
menu = SongsMenu(library, sorted(self.__get_songs(), key=lambda s: s.sort_key), parent=self)
|
songs = self.__get_selected_songs(sort=True) menu = SongsMenu(library, songs, parent=self)
|
def __popup_menu(self, view, library): menu = SongsMenu(library, sorted(self.__get_songs(), key=lambda s: s.sort_key), parent=self) menu.show_all() return view.popup_menu(menu, 0, gtk.get_current_event_time())
|
def __destroy(self, model): self.set_model(None) model.clear() def __changed(self, selection, jump=False): model, rows = selection.get_selected_rows() if jump and rows: self.scroll_to_cell(rows[0][0], use_align=True, row_align=0.5) songs = self.__get_songs() if not songs: return self.__next.fill(songs)
|
def __selection_changed(self, selection): self.__next.fill(self.__get_selected_songs())
|
def __destroy(self, model): self.set_model(None) model.clear()
|
model = self.get_model()
|
model = self.__model songs = set(songs)
|
def _remove(self, songs, remove_if_empty=True): self.inhibit() model = self.get_model() to_remove = [] for row in model: data = row[1] if data is None: continue for song in songs: if song in data: data.remove(song) if not model[row.iter][1]: to_remove.append(row.iter) if remove_if_empty: for iter in to_remove: try: del(self.__sort_cache[model[iter][0]]) except KeyError: pass model.remove(iter) if len(model) == 1 and model[0][1] is None: model.clear() elif to_remove and len(model) == 2: model.remove(model.get_iter(0)) self.uninhibit()
|
data = row[1] if data is None: continue for song in songs: if song in data: data.remove(song) if not model[row.iter][1]: to_remove.append(row.iter)
|
type, data = row if type == ALL: continue data.songs -= songs data.finalize() model.row_changed(row.path, row.iter) if not data.songs: to_remove.append(row.iter)
|
def _remove(self, songs, remove_if_empty=True): self.inhibit() model = self.get_model() to_remove = [] for row in model: data = row[1] if data is None: continue for song in songs: if song in data: data.remove(song) if not model[row.iter][1]: to_remove.append(row.iter) if remove_if_empty: for iter in to_remove: try: del(self.__sort_cache[model[iter][0]]) except KeyError: pass model.remove(iter) if len(model) == 1 and model[0][1] is None: model.clear() elif to_remove and len(model) == 2: model.remove(model.get_iter(0)) self.uninhibit()
|
try: del(self.__sort_cache[model[iter][0]])
|
try: del(self.__sort_cache[model[iter][1].key])
|
def _remove(self, songs, remove_if_empty=True): self.inhibit() model = self.get_model() to_remove = [] for row in model: data = row[1] if data is None: continue for song in songs: if song in data: data.remove(song) if not model[row.iter][1]: to_remove.append(row.iter) if remove_if_empty: for iter in to_remove: try: del(self.__sort_cache[model[iter][0]]) except KeyError: pass model.remove(iter) if len(model) == 1 and model[0][1] is None: model.clear() elif to_remove and len(model) == 2: model.remove(model.get_iter(0)) self.uninhibit()
|
if len(model) == 1 and model[0][1] is None:
|
if len(model) == 1 and model[0][0] == ALL:
|
def _remove(self, songs, remove_if_empty=True): self.inhibit() model = self.get_model() to_remove = [] for row in model: data = row[1] if data is None: continue for song in songs: if song in data: data.remove(song) if not model[row.iter][1]: to_remove.append(row.iter) if remove_if_empty: for iter in to_remove: try: del(self.__sort_cache[model[iter][0]]) except KeyError: pass model.remove(iter) if len(model) == 1 and model[0][1] is None: model.clear() elif to_remove and len(model) == 2: model.remove(model.get_iter(0)) self.uninhibit()
|
try: model, rows = self.get_selection().get_selected_rows() except (AttributeError, TypeError): return False else: if not rows or model[rows[0]][1] is None: return True
|
model, rows = self.get_selection().get_selected_rows() if not rows or model[rows[0]][0] == ALL: return True keys = self.__get_format_keys(song) if not keys and model[rows[-1]][0] == UNKNOWN: return True for row in rows: if model[row][1].key in keys: return True return False def _add(self, songs): collection = {} unknown = SongSelection("") human_sort = self.__human_sort_key for song in songs: keys = self.__get_format_keys(song) if not keys: unknown.songs.add(song) for key in keys: try: collection[key][0].songs.add(song) except KeyError: collection[key] = (SongSelection(key), human_sort(key)) collection[key][0].songs.add(song) items = sorted(collection.iteritems(), key=lambda s: s[1][1], reverse=True) model = self.__model if not len(model): insert = model.insert if unknown.songs: insert(0, [UNKNOWN, unknown]) for key, (val, sort_key) in items: insert(0, [SONGS, val]) if len(model) > 1: insert(0, [ALL, None]) return key = None val = None sort_key = None for row in self.__model: type, data = row if type != SONGS: continue if key is None: if not items: break key, (val, sort_key) = items.pop(-1) if key == data.key: data.songs |= val.songs data.finalize() model.row_changed(row.path, row.iter) key = None elif sort_key < human_sort(data.key): model.insert_before(row.iter, row=[SONGS, val]) key = None if key: items.append((key, (val, sort_key))) if items: if model[-1][0] == UNKNOWN: for key, (val, srt) in reversed(items): model.insert(len(model) - 1, row=[SONGS, val])
|
def _matches(self, song): try: model, rows = self.get_selection().get_selected_rows() except (AttributeError, TypeError): return False else: if not rows or model[rows[0]][1] is None: return True else: for row in rows: if model[row][0][:1] == "<": if not bool(self.__format(song)): return True else: value = util.unescape(model[row][0]) if value in self.__format(song): return True else: return False
|
for row in rows: if model[row][0][:1] == "<": if not bool(self.__format(song)): return True else: value = util.unescape(model[row][0]) if value in self.__format(song): return True else: return False def _add(self, songs): self.inhibit() model = self.get_model() values = {} new = {} for row in model: value = row[0] data = row[1] if value[:1] != "<": value = util.unescape(value).decode('utf-8') values[value] = data elif data is not None: values[""] = data for song in songs: for val in (self.__format(song) or [""]): if val in values: values[val].add(song) else: if val not in new: new[val] = set() new[val].add(song) if new: human = self.__human_sort_key keys = sorted(new.keys(), key=human) if keys[0] == "": unknown = new[""] keys.pop(0) else: unknown = set() for row in model: if row[0][0] == "<": continue elif not keys: break value = util.unescape(row[0]).decode('utf-8') if human(value) > human(keys[0]): key = keys.pop(0) model.insert_before( row.iter, row=[util.escape(key), new[key]])
|
for key, (val, srt) in items: model.append(row=[SONGS, val]) if len(model) > 1 and model[0][0] != ALL: model.insert(0, [ALL, None]) if unknown.songs: last_row = model[-1] type, data = last_row if type == UNKNOWN: data.songs |= unknown.songs data.finalize() model.row_changed(last_row.path, last_row.iter)
|
def _matches(self, song): try: model, rows = self.get_selection().get_selected_rows() except (AttributeError, TypeError): return False else: if not rows or model[rows[0]][1] is None: return True else: for row in rows: if model[row][0][:1] == "<": if not bool(self.__format(song)): return True else: value = util.unescape(model[row][0]) if value in self.__format(song): return True else: return False
|
if "" in values: for key in keys: model.insert( len(model)-1, row=[util.escape(key), new[key]]) else: for key in keys: model.append(row=[util.escape(key), new[key]]) if unknown: model.append(row=[UNKNOWN, new[""]]) if (len(values) + len(new)) > 1 and model[(0,)][1] is not None: model.insert(0, row=["<b>%s</b>" % _("All"), None]) self.uninhibit()
|
model.append(row=[UNKNOWN, unknown])
|
def _add(self, songs): self.inhibit() model = self.get_model() values = {} new = {} for row in model: value = row[0] data = row[1] if value[:1] != "<": value = util.unescape(value).decode('utf-8') values[value] = data elif data is not None: values[""] = data
|
model = self.get_model()
|
model = self.__model
|
def fill(self, songs): restore = self.__restore_values selected = (restore and restore.pop(0)) or self.get_selected() model = self.get_model() if len(model) == len(selected): selected = None self.inhibit() model.clear() self._add(songs) self.uninhibit() if selected: self.set_selected(selected, jump=True) else: self.set_selected(None, jump=True)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.