clWidgets.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-

# ----------------------------------------------------------------------------
# pyjama - python jamendo audioplayer
# Copyright (c) 2008 Daniel Nögel
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
# ----------------------------------------------------------------------------


## @package clWidgets
# This module holds a lot of widgets
# which which are used more often.


# GUI
import pygtk
pygtk.require('2.0')
import gtk
import gobject

# Time formatting
from time import gmtime, time, sleep

# math
from math import ceil
import copy
import os

import urllib

# Benutzerklassen
import functions

from threading import Thread

# Gettext - Übersetzung
functions.translation_gettext()
#def _(string):
#    return string

## shows an error when user makes to much jamendo queries
def tofast(window):
    dia = MyDialog(_('to fast'),
                              window.get_toplevel(),
                              gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT, 
                                (gtk.STOCK_OK, gtk.RESPONSE_ACCEPT),        gtk.STOCK_DIALOG_WARNING, _('Some requests may only be send once a second\nin order not to slow down jamendo\'s database'))
    dia.run()
    dia.destroy()
    window.toolbar.on_bHistoryBack_clicked(None)

## removes some special characters from strings to be shown 
# in albumwidgets
def clear(string):
    if string == None: return string
    string = string.replace("\r", "")
    string = string.replace("\t", "")
    string = string.replace(",", "")
    string = string.replace("&", "&amp;")
#    string = string.replace("«", "")
#    string = string.replace("»", "")
#    string = functions.decode_htmlentities(string)
    return string.strip()
    
def threaded(f):
    def wrapper(*args, **kwargs):
        t = Thread(target=f, args=args, kwargs=kwargs)
        t.start()
    return wrapper
#~ @threaded
#~ class PulsingBar(gtk.ProgressBar):
    #~ def __init__(self):
        #~ self.__pulsing = False
        #~ 
        #~ gtk.ProgressBar.__init__(self)
#~ 
    #~ @threaded
    #~ def pulsing(self):
        #~ gtk.gdk.threads_enter()
        #~ self.pulse()
        #~ while gtk.events_pending(): gtk.main_iteration()
        #~ gtk.gdk.threads_leave()
        #~ return self.__pulsing
        #~ 
    #~ @threaded
    #~ def start(self):
        #~ self.__pulsing = True
        #~ gobject.timeout_add(10, self.pulsing)
#~ 
    #~ @threaded
    #~ def stop(self):
        #~ self.__pulsing = False

    

class InfoLabel(gtk.HBox):
    def __init__(self, pyjama):
        self.pyjama = pyjama
        self.markuplbCaption = "<span size=\"medium\">TEXT</span>"

        gtk.HBox.__init__(self, False)

        self.icon_size = self.pyjama.settings.get_value("PYJAMA", "info_label_icon_size", 24)

        self.lbl = gtk.Label()
        self.lbl.show()

        self.img = gtk.Image()
        self.img.show()

        self.pack_start(self.img, False, True)
        self.pack_start(self.lbl, True, True)

        size = gtk.icon_size_register("usersize1", self.icon_size, self.icon_size)

    def set_text(self, text):
#        self.pyjama.window.f.set_label(text)
        self.lbl.set_markup(self.markuplbCaption.replace("TEXT", text))

    def set_image(self, image=None, size=None):
        if image == None:
            self.img.clear()
            return

        if size is None:
            size = gtk.icon_size_from_name("usersize1")

        if image in gtk.stock_list_ids():
            self.img.set_from_stock(image, size)
            return

        if not os.path.exists(image):
            # try to find the image in pyjama's
            # image folder:
            if not os.path.exists(os.path.join(functions.install_dir(), "images", image)):
                print ("Could not find '%s'" % image)
                return -1
            else:
                image = os.path.join(functions.install_dir(), "images", image)

        try:
            pixbuf = gtk.gdk.pixbuf_new_from_file_at_size(image, self.icon_size, self.icon_size)
            self.img.set_from_pixbuf(pixbuf)
        except ValueError:
            print ("Error loading the image")
            return -2

## Context menu for TreeViewList
# When creating a ListMenu the event
# 'populate_listmenu' will be raised
class ListMenu(gtk.Menu):
    ## The Constructor
    # @param self Object Pointer
    # @param pyjama Pyjama Reference
    def __init__(self, pyjama):
        self.pyjama = pyjama
        gtk.Menu.__init__(self)

#        # Add remove button if an entry is selected:
#        model, tmpIter = pyjama.window.tvList.get_selection().get_selected()
#        if tmpIter != None:
#            #path = pyjama.window.liststore.get_path(tmpIter)[0]
#            mnu = gtk.ImageMenuItem("Remove from List")
#            self.append(mnu)
#            mnu.show()
#            mnu.connect("activate", self.cb_mnu_remove_clicked)

#            img = gtk.Image()
#            img.set_from_stock(gtk.STOCK_REMOVE, gtk.ICON_SIZE_MENU)
#            mnu.set_image(img)


        pyjama.Events.raise_event("populate_listmenu", self)

        self.show()

    def cb_mnu_remove_clicked(self, widget):
        self.pyjama.window.on_bDelete_clicked(None)


## Context menu for the playlist
# When creating a PlaylistMenu the event
# 'populate_playlistmenu' will be raised
class PlaylistMenu(gtk.Menu):
    ## The Constructor
    # @param self Object Pointer
    # @param pyjama Pyjama Reference
    def __init__(self, pyjama):
        self.pyjama = pyjama
        gtk.Menu.__init__(self)

        # Add remove button if an entry is selected:
        model, tmpIter = pyjama.window.tvPlaylist.get_selection().get_selected()
        if tmpIter != None:
            #path = pyjama.window.liststore.get_path(tmpIter)[0]

            ## Show Artist Menu
            mnu = gtk.ImageMenuItem(_("Show artist's page"))
            self.append(mnu)
            mnu.show()
            mnu.connect("activate", self.cb_mnu_artist_clicked)
            img = gtk.Image()
            pb = gtk.gdk.pixbuf_new_from_file_at_size(os.path.join(functions.install_dir(), "images", "personal.png"), 16, 16)
            img.set_from_pixbuf(pb)
            mnu.set_image(img)

            ## Show Album Menu
            mnu = gtk.ImageMenuItem(_("Show album's page"))
            self.append(mnu)
            mnu.show()
            mnu.connect("activate", self.cb_mnu_album_clicked)
            img = gtk.Image()
            pb = gtk.gdk.pixbuf_new_from_file_at_size(os.path.join(functions.install_dir(), "images", "cd.png"), 16, 16)
            img.set_from_pixbuf(pb)
            mnu.set_image(img)

            x = gtk.SeparatorMenuItem()
            x.show()
            self.append(x)


            pyjama.Events.raise_event("populate_playlistmenu", self)


            x = gtk.SeparatorMenuItem()
            x.show()
            self.append(x)

            ## Remove Menu
            mnu = gtk.ImageMenuItem(_("Remove from Playlist"))
            self.append(mnu)
            mnu.show()
            mnu.connect("activate", self.cb_mnu_remove_clicked)
            img = gtk.Image()
            img.set_from_stock(gtk.STOCK_REMOVE, gtk.ICON_SIZE_MENU)
            mnu.set_image(img)


        self.show()

    def cb_mnu_artist_clicked(self, widget):
        model, tmpIter = self.pyjama.window.tvPlaylist.get_selection().get_selected()
        if tmpIter != None:
            path = model.get_path(tmpIter)
            if path != (): path = path[0]

            track = self.pyjama.player.playlist[path]

            artistdetails = self.pyjama.db.artistinfos(track.artist_id)
            self.pyjama.layouts.show_layout("artist", artistdetails)

    def cb_mnu_album_clicked(self, widget):
        model, tmpIter = self.pyjama.window.tvPlaylist.get_selection().get_selected()
        if tmpIter != None:
            path = model.get_path(tmpIter)
            if path != (): path = path[0]
            track = self.pyjama.player.playlist[path]

            albumdetails = self.pyjama.jamendo.albuminfos(track.album_id)
            if not albumdetails: return
            self.pyjama.layouts.show_layout("album", albumdetails)

    def cb_mnu_remove_clicked(self, widget):
        self.pyjama.window.on_bDelete_clicked(None)

## Dialog Class
class MyDialog(gtk.Dialog):
    def __init__(self, caption, toplevel, flags, buttons, image, desc, sep=True, allow_resize=False):
            gtk.Dialog.__init__(self, caption, toplevel, flags, buttons)
            img = gtk.Image()
            img.set_from_stock(image, gtk.ICON_SIZE_DIALOG)
            hbox = gtk.HBox()
            self.vbox.pack_start(hbox)
            hbox.pack_start(img)
            label = gtk.Label()
            label.set_single_line_mode(False)
            label.set_line_wrap(True)
            label.set_markup(desc)
            hbox.pack_start(label)

            self.set_has_separator(sep)
            self.set_resizable(allow_resize)

            self.show_all()

## Process Dialog
# This dialog can be used to show a dialog
# with a progressbar in it
class ProcessDialog(gtk.Dialog):
    def __init__(self, pyjama, caption):
        gtk.Dialog.__init__(self, caption)

        self.set_modal(True)
#        self.set_size_request(400, 300)

        self.progressbar = gtk.ProgressBar()
        self.label = gtk.Label()
        self.label.set_line_wrap(True)
        self.label.set_single_line_mode(False)

        self.vbox.pack_start(self.label, False, True)
        self.vbox.pack_start(self.progressbar, False, True)

        self.show_all()

    def set_status(self, percentage=None, text=None):
        if percentage is not None:
            self.progressbar.set_fraction(percentage/100)
        if text is not None:
            self.progressbar.set_text(text)

    def set_description(self, desc):
        self.label.set_markup(desc)

## Treeview on the bottom with artist-album-tracks fields
class TreeViewList(gtk.TreeView):

    #   columns
    (
      COLUMN_ARTIST,
      COLUMN_ALBUM,
      COLUMN_TRACKNUM,
      COLUMN_TRACK,
      COLUMN_LICENSE,
      COLUMN_ARTISTID,
      COLUMN_ALBUMID,
      COLUMN_TRACKID,
      COLUMN_LICENSEURL
    ) = range(9)

    def __init__(self):
        # create model
        model = self.__create_model()

        # create tree view
        gtk.TreeView.__init__(self, model)
        self.set_rules_hint(True)
        self.set_rubber_banding(True)
        self.set_show_expanders(True)
        #self.set_reorderable(True)
        self.get_selection().set_mode(gtk.SELECTION_SINGLE)#gtk.SELECTION_MULTIPLE
        self.__add_columns(self)

        self.show()

    def get_item(self, path):
        model = self.get_model()
        retIter = model.get_iter(path)
        ret = model.get(retIter, 0, 1, 2, 3, 4, 5, 6, 7, 8)
        return ret
        

    def clear(self):
        model = self.get_model()
        model.clear()


    def add_item(self, item):
        model = self.get_model()
        #articles.append(new_item)
        if item[self.COLUMN_TRACKNUM] != "":
            item[self.COLUMN_TRACKNUM] = "%02d" % int(item[self.COLUMN_TRACKNUM])

        iter = model.append()
        model.set (iter,
            self.COLUMN_ARTIST, item[self.COLUMN_ARTIST],
            self.COLUMN_ALBUM, item[self.COLUMN_ALBUM],
            self.COLUMN_TRACKNUM, item[self.COLUMN_TRACKNUM],
            self.COLUMN_TRACK, item[self.COLUMN_TRACK],
            self.COLUMN_LICENSE, "",
            self.COLUMN_ARTISTID, item[self.COLUMN_ARTISTID],
            self.COLUMN_ALBUMID, item[self.COLUMN_ALBUMID],
            self.COLUMN_TRACKID, item[self.COLUMN_TRACKID],
            self.COLUMN_LICENSEURL, item[self.COLUMN_LICENSE]
       )

    def __create_model(self):

        # create list store
        model = gtk.ListStore(
            gobject.TYPE_STRING,
            gobject.TYPE_STRING,
            gobject.TYPE_STRING,
            gobject.TYPE_STRING,
            gobject.TYPE_STRING,
            gobject.TYPE_INT,
            gobject.TYPE_INT,
            gobject.TYPE_INT,
            gobject.TYPE_STRING
       )
       
#        # add items
#        for item in articles:
#            iter = model.append()

#            model.set (iter,
#                  COLUMN_ARTIST, item[COLUMN_ARTIST],
#                  COLUMN_ALBUM, item[COLUMN_ALBUM],
#                  COLUMN_TRACK, item[COLUMN_TRACK]
#           )
        return model


    def __add_columns(self, treeview):

        model = treeview.get_model()

        # artist column
        renderer = gtk.CellRendererText()
        renderer.set_data("column", self.COLUMN_ARTIST)

        column = gtk.TreeViewColumn(_("Artist"), renderer, text=self.COLUMN_ARTIST)
        treeview.append_column(column)
        column.set_sort_column_id(0)
        column.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
        column.set_resizable(True)
        column.set_fixed_width(150)



        # album column
        renderer = gtk.CellRendererText()
        renderer.set_data("column", self.COLUMN_ALBUM)

        column = gtk.TreeViewColumn(_("Album"), renderer, text=self.COLUMN_ALBUM)
        treeview.append_column(column)
        column.set_sort_column_id(1)
        column.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
        column.set_resizable(True)
        column.set_fixed_width(150)

        # tracknum column
        renderer = gtk.CellRendererText()
        renderer.set_data("column", self.COLUMN_TRACKNUM)

        column = gtk.TreeViewColumn("#", renderer, text=self.COLUMN_TRACKNUM)
        treeview.append_column(column)
        column.set_sort_column_id(2)
        column.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
        column.set_resizable(True)
        column.set_fixed_width(40)

        # track column
        renderer = gtk.CellRendererText()
        renderer.set_data("column", self.COLUMN_TRACK)

        column = gtk.TreeViewColumn(_("Track"), renderer, text=self.COLUMN_TRACK)
        treeview.append_column(column)
        column.set_sort_column_id(3)
        column.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
        column.set_resizable(True)
        column.set_fixed_width(150)
        
#        # license column
#        renderer = gtk.CellRendererText()
#        renderer.set_data("column", self.COLUMN_LICENSE)

#        column = gtk.TreeViewColumn(_("Licence"), renderer, text=self.COLUMN_LICENSE)
#        treeview.append_column(column)
#        column.set_sort_column_id(4)
#        column.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
#        column.set_resizable(True)
#        column.set_fixed_width(100)

        # license column
        renderer = gtk.CellRendererPixbuf()
        renderer.set_data("column", self.COLUMN_LICENSE)
#        renderer.set_property('cell-background', 'yellow')

        column = gtk.TreeViewColumn(_("Licence"), renderer)
        treeview.append_column(column)
#        column.set_sort_column_id(4)
        column.set_cell_data_func(renderer, self.make_pb)
        column.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
        column.set_resizable(True)
        column.set_fixed_width(100)

    def make_pb(self, tvcolumn, cell, model, iter):
        url = model.get_value(iter, self.COLUMN_LICENSEURL)
        if url is None or url == "":
#            pb = gtk.gdk.pixbuf_new_from_file_at_size(img_file, -1, 20)
            cell.set_property('pixbuf', None)
            return

        if "creativecommons" in url:
            try:
                attribution = url.split("/")[4]
                img_file = os.path.join(functions.install_dir(), "images", "license_images", "cc_small", "%s.png" % attribution)
                if os.path.exists(img_file):
                    pb = gtk.gdk.pixbuf_new_from_file_at_size(img_file, -1, 20)
    #            pb = self.render_icon(stock, gtk.ICON_SIZE_MENU, None)
                    cell.set_property('pixbuf', pb)
                else:
                    return
            except:
                return
        elif "nolicense" in url:
            img_file = os.path.join(functions.install_dir(), "images", "license_images", "pd.png")
            if os.path.exists(img_file):
                pb = gtk.gdk.pixbuf_new_from_file_at_size(img_file, -1, 20)
                cell.set_property('pixbuf', pb)
        elif "artlibre" in url:
            img_file = os.path.join(functions.install_dir(), "images", "license_images",
 "artlibre.png")
            if os.path.exists(img_file):
                pb = gtk.gdk.pixbuf_new_from_file_at_size(img_file, -1, 20)
                cell.set_property('pixbuf', pb)

## widget showing stars as raiting for an album
class Rating(gtk.HBox):
    def __init__(self):
        gtk.HBox.__init__(self)
        self.img=[]
        for img in range(0, 10):
            self.img.append(gtk.Image())
            pixbuf = gtk.gdk.pixbuf_new_from_file_at_size(os.path.join(functions.install_dir(), "images", "star.png"), 16, 16)
            #pixbuf = self.img[img].render_icon(gtk.STOCK_ABOUT, gtk.ICON_SIZE_MENU, detail=None)
            self.img[img].set_from_pixbuf(pixbuf)
            self.pack_start(self.img[img], True, True, 0)
            self.img[img].show()
            
    def set_rating(self, rating):
        for img in self.img:
            img.hide()
            
        rating = int(ceil(float(rating)))
        
        for img in range(0, rating):
            self.img[img].show()

## my statusbar widget
class StatusBar(gtk.HBox):
    def __init__(self, *argv):
        self.statusbars = {}

        gtk.HBox.__init__(self, False)
        
        for item in argv:
            self.statusbars[item] = {'statusbar':gtk.Statusbar()} 
            self.statusbars[item]['conid'] = self.statusbars[item]['statusbar'].get_context_id("Status")
            self.statusbars[item]['msgid'] = self.statusbars[item]['statusbar'].push(self.statusbars[item]['conid'], "")
            self.statusbars[item]['curtext'] =  None
            if item != argv[len(argv)-1]:
                self.statusbars[item]['statusbar'].set_has_resize_grip(False)
                self.statusbars[item]['sep'] = gtk.VSeparator()
                self.pack_start(self.statusbars[item]['statusbar'], True, True, 0)
                self.pack_start(self.statusbars[item]['sep'], False, False, 0)
                self.statusbars[item]['statusbar'].show()
                self.statusbars[item]['sep'].show()
            else:
                self.statusbars[item]['statusbar'].set_has_resize_grip(True)
                self.pack_start(self.statusbars[item]['statusbar'], False, True, 0)
                self.statusbars[item]['statusbar'].show()
#                self.progressBar = gtk.ProgressBar()
#                self.progressBar.set_size_request(30,5)
#                self.progressBar.hide()
#                self.statusbars[item]['statusbar'].add(self.progressBar)

    def set_text(self, statusbar, text):
        if self.statusbars[statusbar]['curtext'] != text:
            self.statusbars[statusbar]['msgid'] = self.statusbars[statusbar]['statusbar'].push(self.statusbars[statusbar]['conid'], text)
            self.statusbars[statusbar]['statusbar'].set_tooltip_text(text)
            self.statusbars[statusbar]['curtext'] = text

## ComboBox for setting results per page
class ResultsPerPageCombo(gtk.ComboBox):
    def __init__(self):
        liststore = gtk.ListStore(gobject.TYPE_STRING)
        gtk.ComboBox.__init__(self,liststore)
        cell = gtk.CellRendererText()

        ## Used to tell apart user generated
        # and auto computed changes of the
        # active item
        self.auto_setting_item = False

        self.pack_start(cell, True)
        self.add_attribute(cell, 'text', 0)
        self.set_tooltip_text(_("How many results should be shown?"))

        self.cbResultsPerPage = gtk.combo_box_new_text()

        self.modelist = ["10", "20", "30", "40", "50", "60", "70", "80", "90", "100"]
        for mode in self.modelist:
            self.append_text(mode)
        self.set_active(0)

    def set_item(self, mode):
        self.auto_setting_item = True
        self.set_property("active", self.modelist.index(str(mode)))
        self.auto_setting_item = False

## holds some basic jamendo order keywords
class OrderCombo(gtk.ComboBox):
    def __init__(self):
        liststore = gtk.ListStore(gobject.TYPE_STRING)
        gtk.ComboBox.__init__(self, liststore)
        cell = gtk.CellRendererText()

        ## Used to tell apart user generated
        # and auto computed changes of the
        # active item
        self.auto_setting_item = False

        self.pack_start(cell, True)
        self.add_attribute(cell, 'text', 0)
        self.set_tooltip_text(_("Select how to order results"))
        
        self.modelist = ["rating", "ratingweek", "ratingmonth", "date", "downloaded", "listened", "starred", "playlisted"]
        for mode in self.modelist:
            self.append_text(mode)
        self.set_active(1)
        
    def set_item(self, mode):
        self.auto_setting_item = True
        self.set_active(self.modelist.index(mode))
        self.auto_setting_item = False

## holds some pre-selected tags
class TagsCombo(gtk.ComboBoxEntry): #Entry
    def __init__(self, pyjama):
        liststore = gtk.ListStore(gobject.TYPE_STRING)
        gtk.ComboBoxEntry.__init__(self, liststore, ) #Entry

        ## Used to tell apart user generated
        # and auto computed changes of the
        # active item
        self.auto_setting_item = False

        cell = gtk.CellRendererText()
        self.pack_start(cell, False)
        self.set_wrap_width(4)
        self.set_tooltip_text(_("Select tags to show"))

        self.set_model(liststore)
#        self.add_attribute(cell, 'text', 0)     

        self.entry = self.child


        default = "ambient experimental instrumental electro alternativ hiphop guitar metal pop punk rock techno triphop world trance progressive gothic hardcore minimal funk dance psychedelic 8bit"
        lst = default.split(" ")
        lst.sort()
        default = " ".join(lst)
        #~ if pyjama.settings.config.has_option("JAMENDO", "TAGs") == False:
        tags = pyjama.settings.get_value("JAMENDO", "newtags", default)
            #~ pyjama.settings.set_value("JAMENDO", "TAGs", default)
        #~ else:
            #~ tags = pyjama.settings.get_value("JAMENDO", "TAGs", default)
#        if not ("--all--") in tags: tags = ("--all-- %s") % tags
        if not _("--all--") in tags: tags = "%s %s" % (_("--all--") , tags)
#        if not _("--custom--") in tags: tags = _("%s --custom--") % tags
        tags = tags.split(" ")
        while "" in tags: tags.remove("")
        self.modelist = tags


        for mode in self.modelist:
            #self.append_text(mode)
            liststore.append([mode])

        self.set_active(0)    
        
    def set_item(self, mode):
        self.auto_setting_item = True
        try:
            self.set_active(self.modelist.index(mode))
        except ValueError:
            # This should not happen at all - but it did once ;)
            self.set_active(0)

        self.auto_setting_item = False

## A label sensible to mouse movements
class MouseLabel(gtk.Label):
    def __init__(self,t):
        gtk.Label.__init__(self, t)

        eventbox = gtk.EventBox()
        eventbox.add(self)
        eventbox.add_events (gtk.gdk.BUTTON_RELEASE)
        boat = gtk.gdk.Cursor(gtk.gdk.WATCH)
        eventbox.window.set_cursor(boat)
        eventbox.connect("realize", self.on_realize)

    def on_realize(self, widget):
        print "asd"
    #     self.set_cursor(watch)

## A button with a StockItem on it
class StockButton(gtk.Button):
    def __init__(self, stock, size=gtk.ICON_SIZE_MENU, text=None):
        gtk.Button.__init__(self, text)

        pixbuf = self.render_icon(stock, size, detail=None)
        self.img = gtk.Image()
        self.img.set_from_pixbuf(pixbuf)
        #set_from_stock(stock_id, size)
        self.set_image(self.img)
        
       
        self.tag = None
        
    def setimage(self, stock, size=gtk.ICON_SIZE_MENU):
        pixbuf = self.render_icon(stock, size, detail=None)
        #self.img = gtk.Image()
        self.img.set_from_pixbuf(pixbuf)
        self.set_image(self.img)


## A Button with an image from a file
class ImageButton(gtk.Button):
    def __init__(self, sFile, w, h=None, text=None):
        gtk.Button.__init__(self, text)
        self.img = gtk.Image()

        # if h is None, assume w being a stock size
        # convert stock size to pixel
        if h is None:
            w, h = gtk.icon_size_lookup(w)
        self.setimage(sFile, w, h)

    def setimage(self, sFile, w, h):
        if not os.path.exists(sFile):
            if os.path.exists(os.path.join(functions.install_dir(), "images", sFile)):
                sFile = os.path.join(functions.install_dir(), "images", sFile)
        pixbuf = gtk.gdk.pixbuf_new_from_file_at_size(sFile, w, h)
        self.img.set_from_pixbuf(pixbuf)
        #set_from_stock(stock_id, size)
        self.set_image(self.img)

    def setstock(self, stock, size=gtk.ICON_SIZE_MENU):
        pixbuf = self.render_icon(stock, size, detail=None)
        self.img.set_from_pixbuf(pixbuf)
        self.set_image(self.img)

class MyLinkButton(gtk.Button):
    def __init__(self, uri, text=""):
        gtk.Button.__init__(self)
        self.lbl = gtk.Label()
        self.lbl.show()
        self.add(self.lbl)
        self.lbl.set_markup("<u><span foreground='blue'>%s</span></u>" % text)
        self.text = text
        self.uri = uri
        self.set_relief(gtk.RELIEF_NONE)

    def set_label(self, text):
        self.lbl.set_markup("<u><span foreground='blue'>%s</span></u>" % text)
        self.text = text

    def get_text(self):
        return self.text

## Widget showing cover, artist name and album name from an album id
# also having a hover-menu
target = [
    ('STRING', 0, 0),
    ('text/plain', 0, 0),
    ('application/x-rootwin-drop', 0, 1)
]

class AlbumInfo(gtk.Frame):
    def __init__(self, parent, album, small=False):
        self.imagewidth = 100
        self.imageheight = 100
        self.album = album
        self.par = parent
        self.over_button = True
        gtk.Frame.__init__(self)
        self.set_label_align(0.5, 0.5)
        self.set_shadow_type(gtk.SHADOW_ETCHED_OUT)
        if small:
            self.set_size_request(100,110) #(150,160) before controls
        else:
            self.set_size_request(150,160) #(150,160) before controls
        
        # Album
        self.lAlbum = MyLinkButton((album['album_name']), clear(album['album_name'][:20]))         
        self.lAlbum.set_tooltip_text(album['album_name'])
        self.lAlbum.show()
        self.set_label_widget(self.lAlbum)
        self.lAlbum.connect("clicked", self.lAlbum_clicked)
        
        self.hbox = gtk.HBox(homogeneous=False, spacing=0)
        self.vbox = gtk.VBox(homogeneous=False, spacing=0)

        self.eventFrame = gtk.EventBox()
        self.add(self.eventFrame)
        self.eventFrame.add(self.hbox)
        #self.add(self.hbox) #==> eventFrame
        
        self.hbox.pack_start(self.vbox)
        self.vbox.set_size_request(100,150)
        self.hbox.show()
        self.vbox.show()

        # ControlBox        
        self.vbControl = gtk.VBox()
        self.hbox.pack_start(self.vbControl)
        self.vbControl.hide()
        # Play
        self.bControlPlay = StockButton(gtk.STOCK_MEDIA_PLAY)
        self.bControlPlay.set_tooltip_text(_("Append this album on playlist and play it"))
        self.vbControl.pack_start(self.bControlPlay, False, True, 0)
        self.bControlPlay.connect("clicked", self.on_bControlPlay)
        self.bControlPlay.show()
        # Add
        self.bControlAdd = StockButton(gtk.STOCK_ADD)
        self.bControlAdd.set_tooltip_text(_("Append this album on playlist"))
        self.vbControl.pack_start(self.bControlAdd, False, True, 0)
        self.bControlAdd.connect("clicked", self.on_bControlAdd)
        self.bControlAdd.show()

        # Star
        # will be implemented via plugin
#        self.bControlStar = ImageButton(os.path.join(functions.install_dir(), "images", "star.png"), 16, 16)
#        self.bControlStar.set_tooltip_text(_("Add this album to favorites [not implemented, yet]"))
#        self.vbControl.pack_start(self.bControlStar, False, True, 10)
#        self.bControlStar.connect("clicked", self.on_bControlStar)
#        self.bControlStar.show()

        # Event-Box
        self.eventFrame.set_above_child(False) # ???
        self.eventFrame.add_events (gtk.gdk.ENTER_NOTIFY_MASK)
        self.eventFrame.add_events (gtk.gdk.LEAVE_NOTIFY_MASK)
        self.eventFrame.connect("enter-notify-event", self.show_vbControl)
        self.eventFrame.connect("leave-notify-event", self.hide_vbControl)
        self.eventFrame.connect("button_release_event", self.image_clicked, album)
        self.eventFrame.show()
        
        # Image
        imagepath = self.par.get_album_image(album['album_id'],100)

        self.image = gtk.Image()
        self.vbox.pack_start(self.image, False, False, 0)#, 25, 1)
        self.image.set_from_file(imagepath)
        self.image.show()
        #self.eventbox = gtk.EventBox()
        #self.eventbox.add(self.image)
        #self.eventbox.set_above_child(False)
        #self.eventbox.add_events (gtk.gdk.BUTTON_RELEASE)
        #self.eventbox.connect("button_release_event", self.image_clicked, album)
        #self.eventbox.connect("enter-notify-event", self.show_vbControl)
        #self.eventbox.connect("leave-notify-event", self.hide_vbControl)
        #self.eventbox.show()
        #self.vbox.pack_start(self.eventbox, False, False, 0)#, 25, 1)
        self.__setcolor(self.eventFrame) # ???

        #
        # Drag & Drop
        #
#        self.eventFrame.drag_source_set(gtk.gdk.BUTTON1_MASK | gtk.gdk.BUTTON3_MASK,target, gtk.gdk.ACTION_COPY | gtk.gdk.ACTION_MOVE)
        #self.image.drag_source_set_icon(get_colormap(), drag_icon, drag_mask)
#        self.eventFrame.connect('drag_data_get', self.source_drag_data_get)
#        self.eventFrame.connect('drag_data_delete', self.source_drag_data_delete)

        # Artist
        artist = album['artist_name']
        self.lArtist = MyLinkButton(clear(artist), clear(artist)) #gtk.Label()
        self.lArtist.set_tooltip_text(artist)
        self.lArtist.connect("clicked", self.lArtist_clicked)
        self.vbox.pack_start(self.lArtist, False, False, 0)#, 10, 110)
        self.lArtist.show()

        if self.par.debug_extreme:
            print ("Created AlbumInfo for %s[...]") % str(album['album_name'][:20])


        self.par.Events.raise_event("albuminfo_created", self)

    def source_drag_data_get(self, btn, context, selection_data, info, time):
        print "start dragging"
        if info == 1:
            print 'I was dropped on the rootwin'
        else:
            selection_data.set(selection_data.target, 8, "I'm Data!")

    def source_drag_data_delete(self, btn, context, data):
        print 'Delete the data!'

    def lArtist_clicked(self, ev1="", ev2=""):
        print self.album['artist_id'], "!!!"
        artistdetails = self.par.db.artistinfos(self.album['artist_id'])
        self.par.layouts.show_layout("artist", artistdetails)

    def lAlbum_clicked(self, ev1="", ev2=""):
        #print ev2
        #print self.album['album_id']
        albumdetails = self.par.jamendo.albuminfos(self.album['album_id'])
        if not albumdetails: return
        self.par.layouts.show_layout("album", albumdetails)

    def image_clicked(self, ev, ev2, ev3):
        x,y = self.image.get_pointer()
        if x > 0 and x < 100 and y > 0 and y < 100:
            #print self.album
            #self.par.layout['top'].hide()
            #print self.par.jamendo.albuminfos(self.album['album_id'])
            self.lAlbum_clicked()
        
    def __setcolor(self, widget):
        if self.par.nocolor:
            return None 
        style = widget.get_style()
        color = widget.get_colormap()
        bg = color.alloc_color(self.par.window.bgcolor)
        fg = color.alloc_color(0, 0, 0, 0)
        style.bg[gtk.STATE_NORMAL] = bg
        style.fg[gtk.STATE_NORMAL] = fg
        widget.set_style(style)
        
    def show_vbControl(self, ev1, ev2):
        self.vbControl.show()

    
    def hide_vbControl(self, ev1, ev2):
        x,y = self.vbControl.get_pointer()
        if x > 0 and x < 35 and y > 0 and y < 90: return None
        self.vbControl.hide()


    def on_bControlPlay(self, ev1):
        tracks = self.par.db.albumtracks(self.album['album_id'])
        track_count = len(tracks)

        if track_count == 0:
            print ("Album not in database, yet.")
            #print album['public_date']
            dia = MyDialog(_('Album non existant.'),
                              self.par.window.get_toplevel(),
                              gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT, 
                                (gtk.STOCK_OK, gtk.RESPONSE_ACCEPT), gtk.STOCK_DIALOG_WARNING, _('This album is not in the database.\nPerhaps Jamendo did not unloack that album, yet\n or you are using a old local database.'))
            dia.run()
            dia.destroy()
            return None
        self.par.appendtracks(tracks, play=True)
        
    def on_bControlAdd(self, ev1):
        tracks = self.par.db.albumtracks(self.album['album_id'])
        track_count = len(tracks)

        if track_count == 0:
            print ("Album not in database, yet.")
            #print album['public_date']
            dia = MyDialog(_('Album non existant.'),
                              self.par.window.get_toplevel(),
                              gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT, 
                                (gtk.STOCK_OK, gtk.RESPONSE_ACCEPT), gtk.STOCK_DIALOG_WARNING, _('This album is not in the database.\nPerhaps Jamendo did not unloack that album, yet\n or you are using a old local database.'))
            dia.run()
            dia.destroy()
            return None

        self.par.appendtracks(tracks)

class EqualizerBox(gtk.HBox):
    def __init__(self, pyjama):
        self.pyjama = pyjama

        gtk.HBox.__init__(self)

        ## Number of eq-bands
        self.n = self.pyjama.player.equalizer_bands

        ## used to store eq-values for each band
        self.values = []
        for i in range(self.n):
            val = self.pyjama.settings.get_value("SOUND", "band%i" % i, 0.0, float)
            self.values.append(val)

        ## also stores eq-values for each band - stored for discrard-fct
        # won't changed
        self.start_values = copy.copy(self.values)

        if self.n==10:
            labels=('29 Hz','59 Hz','119 Hz','227 Hz','474 Hz','947 Hz',
                '1.98 kHz','3.7 kHz','7.5 kHz','15.0 kHz')
        elif self.n==3:
            labels=('100 Hz','1.1 kHz','11.0 kHz')
        else:
            labels=[]
            for a in range(self.n):
                labels.append("")

        ## Adjustments
        self.adjs={} 

        self.show()

        frame = gtk.Frame("Equalizer")
        frame.show()
        self.pack_start(frame, False, False, 20)

        hbox_bottom = gtk.HBox()
        hbox_bottom.show()

        frame.add(hbox_bottom)
        for i in range(self.n):
            self.adjs[i]=gtk.Adjustment(value=self.values[i],
                                        lower=-24, upper=12, 
                                        step_incr=0.1)
            self.adjs[i].connect("value_changed", self.cb_eq_value_changed,i)
            scale=gtk.VScale(self.adjs[i])
            scale.set_inverted(True)
            scale.set_size_request(-1, 200)
            scale.show()
            vbox=gtk.VBox()
            vbox.pack_start(scale)
            vbox.pack_start(gtk.Label(labels[i]), False, True, 5)
            button=gtk.Button("clear")
            #button.set_relief(gtk.RELIEF_NONE)
            button.connect("clicked", self.cb_eq_clear_clicked,i)
            button.show()
            
            vbox.pack_start(button, False, False, 0)
            vbox.show_all()
            hbox_bottom.pack_start(vbox, False, False, 3)

    def cb_eq_clear_clicked(self, widget, num):
        self.values[num]=0
        self.adjs[num].set_value(0)

        self.pyjama.player.set_equalizer(self.values)
                
    def cb_eq_value_changed(self, widget, num):
        self.values[num]=widget.get_value()

        self.pyjama.player.set_equalizer(self.values)

    def save(self):
        for i in range(self.n):
            self.pyjama.settings.set_value("SOUND", "band%i" % i, self.values[i], float)

    def discard(self):
        self.pyjama.player.set_equalizer(self.start_values)

    def dialog(self):
        dia = gtk.Dialog()
        dia.vbox.pack_start(self)

        dia.set_modal(True)
        dia.set_title("Equalizer")
        dia.set_icon_from_file(os.path.join(functions.install_dir(), "images", "view-media-equalizer.png"))


        dia.add_button(gtk.STOCK_CANCEL, -2)
        dia.add_button(gtk.STOCK_OK, -1)


        ret = dia.run()
        if ret == -1:
            self.save()
        else:
            self.discard()
        dia.destroy()