コード例 #1
0
    def createConfigurationInterface(self, parent):
        self.launchers_config = Launcher_Config(self)
        p = parent.addPage(self.launchers_config, "Launchers")
        p.setIcon(kdeui.KIcon("preferences-other"))

        self.appearance_config = Appearance_Config(self)
        p2 = parent.addPage(self.appearance_config, "Appearance")
        p2.setIcon(kdeui.KIcon("preferences-color"))
        self.connect(parent, SIGNAL("okClicked()"), self.configAccepted)
        self.connect(parent, SIGNAL("cancelClicked()"), self.configDenied)
コード例 #2
0
 def createConfigurationInterface(self, parent):
     ##The dictionary backend configuration
     self.backend_config = Dict_Backend_Config(self)
     p = parent.addPage(self.backend_config, "Backend")
     p.setIcon(kdeui.KIcon("accessories-dictionary"))
     ##The appearance configuration part
     self.appearance_config = Appearance_Config(self)
     p2 = parent.addPage(self.appearance_config, "Appearance")
     p2.setIcon(kdeui.KIcon("preferences-desktop-color"))
     ##Final bits
     self.connect(parent, SIGNAL("okClicked()"), self.configAccepted)
     self.connect(parent, SIGNAL("cancelClicked()"), self.configDenied)
コード例 #3
0
class TextLaunch(plasmascript.Applet):
    def __init__(self,parent,args=None):
        plasmascript.Applet.__init__(self,parent)
        self.default_launchers = pickle.dumps([
            Launcher("Web", "konqueror", "Konqueror Web Browser"),
            Launcher("Terminal", "konsole", "Konsole X11 terminal"),
            Launcher("Home", "dolphin ~", "Home directory")
            ])
        self.mylayout = None
        self.parent=parent
       
    def init(self):
        self.setHasConfigurationInterface(True)
        #Get configuration
        self.configuration = self.config()
        self.launchers = str(self.configuration.readEntry("launchers", self.default_launchers).toString())
        self.launchers = pickle.loads(self.launchers)
        self.use_fixed_width = (self.configuration.readEntry("use_fixed_width", False).toBool())
        self.fixed_width = self.configuration.readEntry("fixed_width", 100).toInt()[0]
        self.layout_orientation = self.configuration.readEntry("layout_orientation", Qt.Horizontal).toInt()[0]
        self.background_type = self.configuration.readEntry("background_type", "default").toString()
        #basic setup
        self.setAspectRatioMode(Plasma.IgnoreAspectRatio)
        self.theme = Plasma.Svg(self)
        self.theme.setImagePath("widgets/background")
        self.set_background()
        self.refresh_launchers()


    def createConfigurationInterface(self, parent):
        self.launchers_config = Launcher_Config(self)
        p = parent.addPage(self.launchers_config, "Launchers")
        p.setIcon(kdeui.KIcon("preferences-other"))

        self.appearance_config = Appearance_Config(self)
        p2 = parent.addPage(self.appearance_config, "Appearance")
        p2.setIcon(kdeui.KIcon("preferences-color"))
        self.connect(parent, SIGNAL("okClicked()"), self.configAccepted)
        self.connect(parent, SIGNAL("cancelClicked()"), self.configDenied)

    def showConfigurationInterface(self):
        self.dialog = kdeui.KPageDialog()
        self.dialog.setFaceType(kdeui.KPageDialog.List)
        self.dialog.setButtons(kdeui.KDialog.ButtonCode(kdeui.KDialog.Ok |kdeui.KDialog.Cancel))
        self.createConfigurationInterface(self.dialog)
        self.dialog.resize(640, 400)
        self.dialog.show()

    def configAccepted(self):
        self.launchers = self.launchers_config.get_launcher_list()
        self.use_fixed_width = self.appearance_config.get_use_fixed_width()
        self.fixed_width = self.appearance_config.get_fixed_width()
        self.layout_orientation = self.appearance_config.get_layout_orientation()
        self.background_type = self.appearance_config.get_background_type()
        
        self.refresh_launchers()
        self.set_background()
        #save data
        self.configuration.writeEntry("launchers", QVariant(pickle.dumps(self.launchers)))
        self.configuration.writeEntry("use_fixed_width", QVariant(self.use_fixed_width))
        self.configuration.writeEntry("fixed_width", QVariant(self.fixed_width))
        self.configuration.writeEntry("layout_orientation", QVariant(self.layout_orientation))
        self.configuration.writeEntry("background_type", QVariant(self.background_type))
        
        
    def configDenied(self):
        pass

    def set_background(self):
        if self.background_type == QString("translucent"):
            self.setBackgroundHints(Plasma.Applet.TranslucentBackground)
        else:
            self.setBackgroundHints(Plasma.Applet.DefaultBackground)

    def refresh_launchers(self):
        if self.mylayout:
            self.remove_buttons()
        self.mylayout = QGraphicsLinearLayout(self.layout_orientation, self.applet)

        for a_launcher in self.launchers:
            button = Plasma.ToolButton()
            button.setText(a_launcher.button_text)
            #Tooltips
            tt_data = Plasma.ToolTipContent(a_launcher.button_text, a_launcher.tooltip_text, QIcon())
            Plasma.ToolTipManager.self().setContent(button, tt_data)

            #fixed width or not:
            if self.use_fixed_width:
                button.nativeWidget().setFixedWidth(self.fixed_width)
            #adjust button height?
            #button.nativeWidget().setFixedHeight(20)

            #connect and add
            self.connect(button, SIGNAL("clicked()"), a_launcher.execute)
            self.mylayout.addItem(button)
        self.mylayout.setContentsMargins(0,0,0,0)
        self.setLayout(self.mylayout)

    def remove_buttons(self):
        while self.mylayout.count() != 0:
            self.mylayout.removeItem(self.mylayout.itemAt(0))
コード例 #4
0
class PythonDictionary(plasmascript.Applet):
    def __init__(self,parent,args=None):
        plasmascript.Applet.__init__(self, parent)
        self.determine_capabilities()
        self.definition = []
        self.word = None
        self.engines = {}
        if self.has_engine:
            self.engines["dict-dataengine"] = self.define_via_dict_dataengine
        if self.has_dict_client:
            self.engines["dict-client"] = self.define_via_dict_client
        if self.has_python_dictclient:
            self.engines["python-dictclient"] = self.define_via_python_dict_client
        self.height = 60
        
    def init(self):
        #configuration
        self.setHasConfigurationInterface(True)
        #open config file
        configuration = self.config()
        #configurations settings
        self.chosen_engine = unicode(configuration.readEntry("engine", self.engines.keys()[-1]).toString())
        self.server = unicode(configuration.readEntry("server", "dict.org").toString())
        self.width = int(configuration.readEntry("width", "200").toString())
        self.text_color = unicode(configuration.readEntry("textColor", "#000000").toString())
        self.force_bw_definition = configuration.readEntry("force_bw_definition", False).toBool()

        #configure non-configurable settings
        self.setAspectRatioMode(Plasma.IgnoreAspectRatio)
        self.theme = Plasma.Svg(self)
        self.theme.setImagePath("widgets/background")
        self.setBackgroundHints(Plasma.Applet.DefaultBackground)

        self.layout = QGraphicsLinearLayout(Qt.Horizontal, self.applet)
        self.combobox = Plasma.ComboBox()
        self.combobox.nativeWidget().setEditable(True)
        self.combobox.setFocusPolicy(Qt.ClickFocus)
        self.combobox.nativeWidget().setContextMenuPolicy(Qt.NoContextMenu)
        self.update_text_color()

        self.lineEdit = self.combobox.nativeWidget().lineEdit()
        
        self.connect(self.combobox.nativeWidget(), SIGNAL("returnPressed()"), self.lookup_word)
        self.connect(self.combobox.nativeWidget(), SIGNAL("activated()"), self.focusWidget)
        self.lineEdit.installEventFilter(self)
        self.lineEdit.setFont(Plasma.Theme.defaultTheme().font(Plasma.Theme.DesktopFont))
        self.layout.addItem(self.combobox)
        self.setLayout(self.layout)
        self.set_combo_width(self.width)

##END INIT METHOD###

###FOCUS FIX###
# These methods fix the problem with getting a focus to the combobox
# when there are active windows open.
    def focusWidget(self):
        #adapted from Run Command Applet.
        # thanks Michal Dutkiewicz aka Emdek <*****@*****.**>
        if self.scene():
            parentView = None
            possibleParentView = None
            for view in self.scene().views():
                if view.sceneRect().intersects(self.sceneBoundingRect()) or view.sceneRect().contains(self.scenePos()):
                    if view.isActiveWindow():
                        parentView = view
                        break
                    else:
                        possibleParentView = view
            if not parentView:
                parentView = possibleParentView
            if parentView:
                kdeui.KWindowSystem.forceActiveWindow(parentView.winId())
        self.raise_()
        self.combobox.nativeWidget().setFocus()
        QTimer.singleShot(250, self.combobox.nativeWidget(), SLOT("setFocus()"))
    def mousePressEvent(self, event):
        if event.button() == Qt.LeftButton:
            self.focusWidget()

    def eventFilter(self, myobject, event):
        if (event.type() ==QEvent.MouseButtonPress):
            self.focusWidget()
        return False

###END FOCUS FIX ###     
    def determine_capabilities(self):
    ## Check to see if python-dictclient is an option:
        self.has_python_dictclient = has_python_dictclient
    ## Check to see if there is a local instance of dict client:
        self.has_dict_client = (subprocess.call(["which", "dict"]) == 0)
    ## Use the engine as a last resort (no offense...)
        self.has_engine =  True
        
    def de_markup(self, text):
        regex = re.compile('<[^>]*>')
        return regex.sub('', text).strip().replace("\r", "\n")

    def ping(self):
        KMessageBox.information(None, "ping", "ping")
###WORD LOOKUP METHODS###

    def lookup_word(self, word=None):
        if word is None:
            self.word = unicode(self.combobox.text())
        else:
            self.word = word
        self.combobox.nativeWidget().setCurrentItem("")
        #TODO: timeout this next call
        self.engines[self.chosen_engine]()
               

        
    ###show the messagebox
    def show_definitions(self, match=False):
        dialog_data = {}
        if len(self.definition) > 0:
            dialog_data["is_match"] = match
            dialog_data["summary"] = self.definition[0]
            dialog_data["definition"] = self.definition[1:]
            dialog_data["title"] = "Definition of %s" % self.word
            self.definition_dialog(dialog_data)
            self.definition = []
        else:
            kdeui.KMessageBox.information(self.combobox.nativeWidget(), "There was some kind of weird problem, you shouldn't be seeing this.  Please report to the author.", "Definition of %s" % self.word)

    def definition_dialog(self, data):
        self.def_dialog = kdeui.KDialog()
        self.def_dialog.force_bw_definition = self.force_bw_definition
        self.def_dialog.setWindowTitle(data["title"])
        if not data["is_match"]:
            self.def_widget = Definition_View_Tabbed(self.def_dialog, data)
        else:
            self.def_widget = Match_View_Widget(self, data)
        self.def_dialog.setButtons(kdeui.KDialog.ButtonCode(kdeui.KDialog.Close))
        self.def_dialog.setMainWidget(self.def_widget)
        self.def_dialog.show()

    def define_via_dict_client(self):
        #code for using the CLI dict command
        is_match = False
        if self.word.isalnum():
            command = "dict -f"
            if self.server is not None:
                command += " -h %s" % self.server
            command += " %s" % self.word
        
            defs = subprocess.Popen([command], shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
            defs = list(defs.stdout) + list(defs.stderr)
            #Reformat that rather ungainly dict output into distinct definitions
            #Unicode fix here and a few lines down from kozakmamay; thanks!
            self.definition = [unicode(defs.pop(0), "utf-8")] #the first line is the summary
            is_match = re.search('perhaps you mean', self.definition[0]) is not None
            if not is_match:
                a_def = ""
                while defs:
                    line = unicode(defs.pop(0), "utf-8")
                    if not re.match("  ", line):
                        if a_def: #if it's not empty, add the current defintion to the list
                            self.definition.append(a_def)
                        a_def = line.split("\t")[-1]
                    else: #two leading spaces indicate a definition line
                        a_def += line
                self.definition.append(a_def) #get the last line.  Yeah, this is ugly.

            else: #if it's a match
                while defs:
                    self.definition.append(defs.pop(0).split("\t")[-1].strip()) 
        else:
            self.definition = ["Invalid Word."]


        self.show_definitions(is_match)

    def define_via_python_dict_client(self):
        #code for using the python-dictclient library
        conn = dictclient.Connection(self.server)
        defs = conn.define("*", self.word)
        num_defs = len(defs)
        is_match = False
        if (num_defs==0):
            #no defs, matching
            defs = conn.match("*","soundex", self.word)
            defs = ["%s\n" % x.getword()  for x in defs]
            perhaps = ", perhaps you mean:"
            is_match =True
        else:
            defs = ["%s:\n\n%s\n" % (x.getdb().getdescription() ,x.getdefstr()) for x in defs]
            perhaps = "."
            #Prepare the output
        s = (num_defs !=1) and "s" or ""
        self.definition.append("%d definition%s found%s\n"%(num_defs, s, perhaps))

        self.definition += defs
        self.show_definitions(is_match)
        
    def define_via_dict_dataengine(self):
        #code for using the plasma dataengine (currently broken)
        self.dict_engine = self.dataEngine("dict")
        mydef = self.dict_engine.connectSource(QString(self.word), self)
        #Once connectSource is called, dataUpdated() will do the rest...

    @pyqtSignature("dataUpdated(const QString &, const Plasma::DataEngine::Data &)")
    def dataUpdated(self, sourceName, data):
        """
        This implementation bears some explanation.  When we call connectSource() in define_via_dict_dataengine(),
        the dataengine will immediately call dataUpdated() with bad data: our word as a source, and an empty set for results.
        Once it actually hears back from the server, we'll get back a single definition with markup, OR and empty set of markup tags if
        no definition was found.  Ugh.

        So, first we filter for no definitions, and do nothing if there are none.  Then, if we get one, we remove the tags and see if there's
        anything left.  If not, we tell the user there was no definition found.  Otherwise, we print the tag-stripped definition (since I don't
        know how to get the KMessageBox.informationList to use the tags).

        If there's a better way to implement this, I'm open to suggestion...
        """
        if sourceName == self.word:
            num_defs = len(data)
            s = (num_defs != 1) and "s" or ""
            self.definition = ["%d definition%s found.\n" % (num_defs, s)]
            if num_defs > 0:
                text = self.de_markup(unicode(data[QString("text")].toString()))
                if text != "":
                    self.definition += ["WordNet"]
                    self.definition += [text]
                else:
                    self.definition = ["No definitions found."]
                self.show_definitions()


### CONFIGURATION RELATED CODE ########
    def createConfigurationInterface(self, parent):
        ##The dictionary backend configuration
        self.backend_config = Dict_Backend_Config(self)
        p = parent.addPage(self.backend_config, "Backend")
        p.setIcon(kdeui.KIcon("accessories-dictionary"))
        ##The appearance configuration part
        self.appearance_config = Appearance_Config(self)
        p2 = parent.addPage(self.appearance_config, "Appearance")
        p2.setIcon(kdeui.KIcon("preferences-desktop-color"))
        ##Final bits
        self.connect(parent, SIGNAL("okClicked()"), self.configAccepted)
        self.connect(parent, SIGNAL("cancelClicked()"), self.configDenied)
        
    def showConfigurationInterface(self):
        self.dialog = kdeui.KPageDialog()
        self.dialog.setFaceType(kdeui.KPageDialog.List)
        self.dialog.setButtons(kdeui.KDialog.ButtonCode(kdeui.KDialog.Ok | kdeui.KDialog.Cancel))
        self.createConfigurationInterface(self.dialog)
        self.dialog.resize(640,480)
        self.dialog.show()

    def configDenied(self):
        configuration = self.config()
        self.width = int(configuration.readEntry("width", "200").toString())
        self.set_combo_width(self.width)

    def configAccepted(self):
        self.chosen_engine = self.backend_config.get_backend()
        self.server = self.backend_config.get_server_url()
        self.text_color = self.appearance_config.get_text_color()
        self.update_text_color()
        self.width = self.appearance_config.get_width()
        self.set_combo_width(self.width)
        self.force_bw_definition = self.appearance_config.get_force_bw_defs()

        configuration = self.config()
        configuration.writeEntry("engine", QVariant(self.chosen_engine))
        configuration.writeEntry("server", QVariant(self.server))
        configuration.writeEntry("width", QVariant(self.width))
        configuration.writeEntry("textColor", QVariant(self.text_color))
        configuration.writeEntry("force_bw_definition", QVariant(self.force_bw_definition))

        ##appearance related
    def set_combo_width(self, width):
        if self.containment().containmentType() == Plasma.Containment.PanelContainment:
            self.combobox.nativeWidget().setMinimumWidth(width)
            self.boundingRect().setWidth(width)
        else:
            self.resize(width, self.height)
            self.combobox.nativeWidget().setMinimumWidth(width-40)

    def update_text_color(self):
        self.combobox.setStyleSheet("color: %s;"% self.text_color)
コード例 #5
0
ファイル: main.py プロジェクト: alandmoore/kliqtune-plasmoid
class KliQTune(plasmascript.Applet):
    def __init__(self,parent,args=None):
        plasmascript.Applet.__init__(self,parent)
        self.default_launchers = pickle.dumps([
                Launcher("The WIR", "http://74.112.209.3/stream", "WYIR, Evansville, IN.  This plugin was built for streams, like this one."),
                Launcher("Lykwyd Chykyn", "http://www.alandmoore.com/lc/aud/m3u.php", "You can also play M3U files on the web, or locally.  Here's some random music from Alan D. Moore, the author of this plasma widget."),
                Launcher("CD", "cdda:/", "You can play Compact Discs too!  Just put the disc in, wait for it to spin up, then click this button.", "media-optical-audio")
                ])
        self.mylayout = None
        self.parent=parent
        self.buttons = []

    def init(self):
        self.setHasConfigurationInterface(True)
        #Get configuration
        self.configuration = self.config()
        self.launchers = str(self.configuration.readEntry("launchers", self.default_launchers).toString())
        self.launchers = pickle.loads(self.launchers)
        self.use_fixed_width = (self.configuration.readEntry("use_fixed_width", False).toBool())
        self.fixed_width = self.configuration.readEntry("fixed_width", 100).toInt()[0]
        self.layout_orientation = self.configuration.readEntry("layout_orientation", Qt.Horizontal).toInt()[0]
        self.background_type = self.configuration.readEntry("background_type", "default").toString()
        self.show_volume = (self.configuration.readEntry("show_volume", True).toBool())
        self.last_volume = (self.configuration.readEntry("last_volume", 75).toInt())[0]
        self.use_icons = (self.configuration.readEntry("use_icons", True).toBool())
        print self.fixed_width
        
        #basic setup
        self.setAspectRatioMode(Plasma.IgnoreAspectRatio)
        self.theme = Plasma.Svg(self)
        self.theme.setImagePath("widgets/background")
        self.set_background()
        self.media_object = Phonon.MediaObject(self)
        self.active_button= None
        self.audio_out = Phonon.AudioOutput(Phonon.MusicCategory, self)
        #Add the widgets to the layout
        self.refresh_launchers()
        self.setLayout(self.mylayout)
        self.volume_change(self.last_volume)
        
        self.connect(self.media_object, SIGNAL("metaDataChanged()"), self.update_metadata)
        Phonon.createPath(self.media_object, self.audio_out)

    def createConfigurationInterface(self, parent):
        self.launchers_config = Launcher_Config(self)
        p = parent.addPage(self.launchers_config, "Launchers")
        p.setIcon(kdeui.KIcon("preferences-other"))

        self.appearance_config = Appearance_Config(self)
        p2 = parent.addPage(self.appearance_config, "Appearance")
        p2.setIcon(kdeui.KIcon("preferences-color"))
        self.connect(parent, SIGNAL("okClicked()"), self.configAccepted)
        self.connect(parent, SIGNAL("cancelClicked()"), self.configDenied)

    def showConfigurationInterface(self):
        self.dialog = kdeui.KPageDialog()
        self.dialog.setFaceType(kdeui.KPageDialog.List)
        self.dialog.setButtons(kdeui.KDialog.ButtonCode(kdeui.KDialog.Ok |kdeui.KDialog.Cancel))
        self.createConfigurationInterface(self.dialog)
        self.dialog.resize(800, 500)
        self.dialog.show()

    def configAccepted(self):
        self.launchers = self.launchers_config.get_launcher_list()
        self.use_fixed_width = self.appearance_config.get_use_fixed_width()
        self.fixed_width = self.appearance_config.get_fixed_width()
        self.layout_orientation = self.appearance_config.get_layout_orientation()
        self.background_type = self.appearance_config.get_background_type()
        self.show_volume = self.appearance_config.get_show_volume()
        self.use_icons = self.appearance_config.get_use_icons()

        self.refresh_launchers()
        self.set_background()
        #save data
        self.configuration.writeEntry("launchers", QVariant(pickle.dumps(self.launchers)))
        self.configuration.writeEntry("use_fixed_width", QVariant(self.use_fixed_width))
        self.configuration.writeEntry("fixed_width", QVariant(self.fixed_width))
        self.configuration.writeEntry("layout_orientation", QVariant(self.layout_orientation))
        self.configuration.writeEntry("background_type", QVariant(self.background_type))
        self.configuration.writeEntry("show_volume", QVariant(self.show_volume))
        self.configuration.writeEntry("use_icons", QVariant(self.use_icons))

    def configDenied(self):
        pass

    def set_background(self):
        if self.background_type == QString("translucent"):
            self.setBackgroundHints(Plasma.Applet.TranslucentBackground)
        else:
            self.setBackgroundHints(Plasma.Applet.DefaultBackground)

    def create_volume_slider(self):
        self.volume_slider = Plasma.Slider()
        self.volume_slider.setOrientation(Qt.Horizontal)
        self.volume_slider.setRange(0, 100)
        self.volume_slider.setValue(self.last_volume)
        if self.use_fixed_width and self.layout_orientation == Qt.Vertical:
            self.volume_slider.nativeWidget().setFixedWidth(self.fixed_width)
        self.volume_tooltip = Plasma.ToolTipContent("Volume", "%d %%"% self.audio_out.volume(), QIcon()) 
        Plasma.ToolTipManager.self().setContent(self.volume_slider, self.volume_tooltip)
        self.connect(self.volume_slider, SIGNAL("valueChanged(int)"), self.volume_change)
        self.connect(self.audio_out, SIGNAL("volumeChanged(float)"), self.change_slider)

    def refresh_launchers(self):
        if self.mylayout:
            self.remove_buttons()
        self.mylayout = QGraphicsLinearLayout(self.layout_orientation, self.applet)
        if self.show_volume:
            self.create_volume_slider()
            self.mylayout.addItem(self.volume_slider)
        self.buttons = []
        for a_launcher in self.launchers:
            self.buttons.append(LauncherButton(a_launcher))

            #Tooltips
            self.buttons[-1].update_tooltip_metadata("")

            #fixed width or not:
            if self.use_fixed_width:
                self.buttons[-1].nativeWidget().setFixedWidth(self.fixed_width)
            #icon, if set
            if a_launcher.icon is not None and self.use_icons:
                self.buttons[-1].setIcon(kdeui.KIcon(a_launcher.icon))
            #connect and add
            self.connect(self.buttons[-1], SIGNAL("clicked()"), self.play)
            self.mylayout.addItem(self.buttons[-1])
            
        #Add off button
        self.offbutton = Plasma.ToolButton()
        self.offbutton.setText("  Off  ")
        Plasma.ToolTipManager.self().setContent(self.offbutton, Plasma.ToolTipContent("Off", "Stop the music!", kdeui.KIcon("media-playback-stop")))
        if self.use_fixed_width:
            self.offbutton.nativeWidget().setFixedWidth(self.fixed_width)
        if self.use_icons:
            self.offbutton.setIcon(kdeui.KIcon("media-playback-stop"))
        self.connect(self.offbutton, SIGNAL("clicked()"), self.stop)
        self.mylayout.addItem(self.offbutton)

        self.mylayout.setContentsMargins(0,0,0,0)
        
    def remove_buttons(self):
        while self.mylayout.count() != 0:
            self.mylayout.removeItem(self.mylayout.itemAt(0))
    
    def play(self):
        self.stop()
        self.active_button = self.sender()
        m_url = self.active_button.launcher.media_url
        self.active_button.update_tooltip_metadata("<br /><i>Loading...</i>")
        self.active_button.activate()
        self.media_object.setCurrentSource(Phonon.MediaSource(m_url))
        self.media_object.play()

    def stop(self):
        for button in self.buttons:
            button.deactivate()
            button.update_tooltip_metadata("")
        self.media_object.stop()

    def volume_change(self, volume):
        """volume is an integer from 0 to 100."""
        self.audio_out.setVolume(float(volume)/100.0)
        if self.show_volume:
            self.volume_tooltip.setSubText("%d %%" % volume)
            Plasma.ToolTipManager.self().setContent(self.volume_slider, self.volume_tooltip)
            Plasma.ToolTipManager.self().show(self.volume_slider)
        self.configuration.writeEntry("last_volume", QVariant(volume))
    def change_slider(self, volume_percent):
        self.volume_tooltip.setSubText("%d %%" % volume_percent * 100)
        Plasma.ToolTipManager.self().setContent(self.volume_slider, self.volume_tooltip)
        self.volume_slider.setValue(volume_percent * 100)

    def update_metadata(self):
        metadata = self.media_object.metaData()
        output = ""
        for key, data in metadata.iteritems():
            if data != [QString("")]:
                output += "<br />%s:  %s" % (key, data[0])
        self.active_button.update_tooltip_metadata(output)