This file is indexed.

/usr/share/kde4/apps/plasma/plasmoids/veromix-plasmoid/contents/code/SinkChannelWidget.py is in plasma-widget-veromix 0.18.3-1.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
# -*- coding: utf-8 -*-
# Copyright (C) 2009-2012 Nik Lutz <nik.lutz@gmail.com>
#
# 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/>.

from PyKDE4.plasma import Plasma
from PyQt4.QtCore import *
from PyQt4.QtGui import *
from PyKDE4.kdeui import *

from LabelSlider import LabelSlider

class SinkChannelWidget(QGraphicsWidget):

    def __init__(self, veromix, sink):
        QGraphicsWidget.__init__(self)
        self.veromix = veromix
        self.sink = sink
        self.sliders = []
        self.text = ""
        self.bold_text = ""
        self.init()

    def init(self):
        self.init_arrangement()
        self.create_channel_sliders()
        self.compose_arrangement()

    def compose_arrangement(self):
        self.setContentsMargins(0,0,0,0)
        self.layout.setContentsMargins(0,0,0,0)
        self.layout.addItem(self.label)
        self.layout.addItem(self.slider_widget)
        self.adjustSize()

    def init_arrangement(self):
        self.layout = QGraphicsLinearLayout(Qt.Vertical)
        self.setSizePolicy(QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed, True))
        self.layout.setSizePolicy(QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed, True))
        self.setLayout(self.layout)

        self.label = Plasma.Label()
        self.label.setPreferredHeight(self.sink.mute.size().height())
        self.label.setSizePolicy(QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed, True))

    def create_channel_sliders(self):
        self.slider_layout = QGraphicsLinearLayout(Qt.Vertical)
        self.slider_layout.setContentsMargins(0,2,0,0)

        self.slider_widget = QGraphicsWidget()
        self.slider_widget.setLayout(self.slider_layout)
        self.slider_widget.setContentsMargins(0,0,0,0)

    def create_sliders(self):
        for channel in self.sink.pa_sink.getChannels():
            slider = LabelSlider()
            slider.setOrientation(Qt.Horizontal)
            slider.setText(channel.get_name())
            slider.setMaximum(self.veromix.get_max_volume_value())
            slider.setValue(channel.get_volume())
            slider.volumeChanged.connect(self.on_slider_cb)
            self.sliders.append(slider)
            self.slider_layout.addItem(slider)
            slider.installEventFilter(self.event_filter)

    def remove_sliders(self):
        for slider in self.sliders:
            self.slider_layout.removeItem(slider)
            del slider
        del self.sliders
        self.sliders = []

## FIXME
    def setText(self, text):
        if text:
            self.text = text
        self.label.setText( "<b>"+self.bold_text + "</b> " + self.text)

    def setBoldText(self,text):
        if text:
            self.bold_text = text
        self.setText(self.text)

    def update_with_info(self, info):
        self.set_slider_values()

    def set_slider_values(self):
        channels = self.sink.pa_sink.getChannels()
        if len(channels) != len(self.sliders):
            self.remove_sliders()
            self.create_sliders()
        for i in range(0,len(channels)):
            name = channels[i].get_name()
            if name != "None":
                self.sliders[i].setBoldText("")
                self.sliders[i].setText(name)
            self.sliders[i].setValueFromPulse(channels[i].get_volume())

    def on_slider_cb(self, value):
        vol = []
        for slider in self.sliders:
            vol.append(slider.value())
            slider.update_plasma_timestamp()
        self.sink.set_channel_volumes(vol)

    def setMaximum(self, value):
        for slider in self.sliders:
            slider.setMaximum(value)

    def wheelEvent(self, event):
        # dont touch the sliders, they will get the new values
        # via the pa-callback
        # else we get infinite loops
        self.sink.on_step_volume(event.delta() > 0)

    def installEventFilter(self, filter):
        if filter:
            self.event_filter = filter
        for slider in self.sliders:
            slider.installEventFilter(filter)
        self.label.installEventFilter(filter)
        self.slider_widget.installEventFilter(filter)
        QGraphicsWidget.installEventFilter(self,filter)

    def set_focus(self):
        # FIXME
        self.sliders[0].set_focus()