← Back to branch summary

~artfwo/indicator-cpufreq/trunk

« back to all changes in this revision

Viewing changes to indicator_cpufreq/indicator.py

  • Committer: Артём Попов
  • Date: 2010-12-16 04:46:44 UTC
  • Revision ID: artfwo@gmail.com-20101216044644-vwnebip1f43qxxp3
Initial working version.

Show diffs side-by-side

added added

removed removed

Lines of Context:
indicator_cpufreq/indicator.py
 
1
# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
 
2
### BEGIN LICENSE
 
3
# Copyright (C) 2010 Артём Попов <artfwo@gmail.com>
 
4
# This program is free software: you can redistribute it and/or modify it 
 
5
# under the terms of the GNU General Public License version 3, as published 
 
6
# by the Free Software Foundation.
 
7
# 
 
8
# This program is distributed in the hope that it will be useful, but 
 
9
# WITHOUT ANY WARRANTY; without even the implied warranties of 
 
10
# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR 
 
11
# PURPOSE.  See the GNU General Public License for more details.
 
12
# 
 
13
# You should have received a copy of the GNU General Public License along 
 
14
# with this program.  If not, see <http://www.gnu.org/licenses/>.
 
15
### END LICENSE
 
16
 
 
17
# TODO:
 
18
# import multiprocessing
 
19
# multiprocessing.cpu_count()
 
20
 
 
21
import gobject
 
22
import gtk
 
23
import appindicator
 
24
 
 
25
import locale
 
26
import dbus
 
27
 
 
28
from indicator_cpufreq import cpufreq
 
29
from indicator_cpufreq.indicator_cpufreqconfig import get_data_file
 
30
 
 
31
import gettext
 
32
from gettext import gettext as _
 
33
#gettext.textdomain('indicator-cpufreq')
 
34
 
 
35
# FIXME: replace value with user-selectable unit
 
36
FIXME_CPU = 0
 
37
 
 
38
def readable_frequency(f):
 
39
    return _("%s GHz") % locale.format(_("%.2f"), f / 1.0e6)
 
40
 
 
41
governor_names = {
 
42
    'conservative': _("Conservative"),
 
43
    'ondemand': _("Ondemand"),
 
44
    #'userspace': _("Userspace"),
 
45
    'powersave': _("Powersave"),
 
46
    'performance': _("Performance"),
 
47
}
 
48
 
 
49
def readable_governor(g):
 
50
    if governor_names.has_key(g):
 
51
        return governor_names[g]
 
52
    else:
 
53
        return g
 
54
 
 
55
class MyIndicator(appindicator.Indicator):
 
56
    def __init__(self):
 
57
        appindicator.Indicator.__init__(self, "indicator-cpufreq",
 
58
            "indicator-messages",
 
59
            appindicator.CATEGORY_HARDWARE)
 
60
        self.set_status(appindicator.STATUS_ACTIVE)
 
61
        self.set_icon(get_data_file('media', 'indicator-cpufreq.png'))
 
62
        
 
63
        menu = gtk.Menu()
 
64
        self.select_items = {}
 
65
        group = None
 
66
        
 
67
        # frequency menu items
 
68
        freqs = cpufreq.get_available_frequencies(FIXME_CPU)
 
69
        for freq in freqs:
 
70
            menu_item = gtk.RadioMenuItem(group, readable_frequency(freq))
 
71
            if group is None:
 
72
                group = menu_item
 
73
            menu.append(menu_item)
 
74
            menu_item.connect("activate", self.select_activated, 'frequency', freq)
 
75
            self.select_items[freq] = menu_item
 
76
 
 
77
        menu.append(gtk.SeparatorMenuItem())
 
78
 
 
79
        # governor menu items
 
80
        governors = cpufreq.get_available_governors(FIXME_CPU)
 
81
        for governor in governors:
 
82
            if governor == 'userspace':
 
83
                continue
 
84
            menu_item = gtk.RadioMenuItem(group, readable_governor(governor))
 
85
            menu.append(menu_item)
 
86
            menu_item.connect('activate', self.select_activated, 'governor', governor)
 
87
            self.select_items[governor] = menu_item
 
88
        
 
89
        menu.show_all()
 
90
        
 
91
        self.set_menu(menu)
 
92
        self.update_ui()
 
93
        gobject.timeout_add(1500, self.poll_timeout)
 
94
    
 
95
    def poll_timeout(self):
 
96
        self.update_ui()
 
97
        return True
 
98
    
 
99
    def update_ui(self):
 
100
        for i in self.select_items.values():
 
101
            i.handler_block_by_func(self.select_activated)
 
102
        
 
103
        fmin, fmax, governor = cpufreq.get_policy(FIXME_CPU)
 
104
        freq = cpufreq.get_freq_kernel(FIXME_CPU)
 
105
        
 
106
        ratio = min([25, 50, 75, 100], key=lambda x: abs(x - (float(freq) / fmax * 100)))
 
107
        if freq < fmax and ratio == 100:
 
108
            ratio = 75
 
109
        
 
110
        self.set_icon(get_data_file('media', 'indicator-cpufreq-%d.png' % ratio))
 
111
        
 
112
        if governor == 'userspace':
 
113
            self.select_items[freq].set_active(True)
 
114
        else:
 
115
            self.select_items[governor].set_active(True)
 
116
        
 
117
        for i in self.select_items.values():
 
118
            i.handler_unblock_by_func(self.select_activated)
 
119
       
 
120
        #self.props.label = readable_frequency(freq)
 
121
    
 
122
    def select_activated(self, menuitem, select, value):
 
123
        if menuitem.active:
 
124
            bus = dbus.SystemBus()
 
125
            proxy = bus.get_object("org.gnome.CPUFreqSelector",
 
126
                "/org/gnome/cpufreq_selector/selector",
 
127
                introspect=False)
 
128
            if select == 'frequency':
 
129
                proxy.SetFrequency(dbus.UInt32(FIXME_CPU), dbus.UInt32(value),
 
130
                    dbus_interface='org.gnome.CPUFreqSelector')
 
131
            else:
 
132
                proxy.SetGovernor(dbus.UInt32(FIXME_CPU), value,
 
133
                    dbus_interface='org.gnome.CPUFreqSelector')
 
134
    
 
135
    def can_set(self):
 
136
        pass
 
137
 
 
138
gobject.type_register(MyIndicator)
 
139
 
 
140
if __name__ == "__main__":
 
141
    ind = MyIndicator()
 
142
    gtk.main()
 
143