← Back to branch summary

~ubuntu-branches/ubuntu/vivid/mate-applets/vivid-proposed

« back to all changes in this revision

Viewing changes to cpufreq/src/cpufreq-selector/cpufreq-selector.c

  • Committer: Package Import Robot
  • Author(s): Mike Gabriel
  • Date: 2014-04-21 13:57:07 UTC
  • Revision ID: package-import@ubuntu.com-20140421135707-hh4arlnzglq9xxfo
Tags: upstream-1.8.0+dfsg1
Import upstream version 1.8.0+dfsg1

Show diffs side-by-side

added added

removed removed

Lines of Context:
cpufreq/src/cpufreq-selector/cpufreq-selector.c
 
1
/*
 
2
 * MATE CPUFreq Applet
 
3
 * Copyright (C) 2004 Carlos Garcia Campos <carlosgc@gnome.org>
 
4
 *
 
5
 *  This library is free software; you can redistribute it and/or
 
6
 *  modify it under the terms of the GNU General Public
 
7
 *  License as published by the Free Software Foundation; either
 
8
 *  version 2 of the License, or (at your option) any later version.
 
9
 *
 
10
 *  This library is distributed in the hope that it will be useful,
 
11
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 
12
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
13
 *  General Public License for more details.
 
14
 *
 
15
 *  You should have received a copy of the GNU General Public
 
16
 *  License along with this library; if not, write to the Free
 
17
 *  Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
 
18
 *
 
19
 * Authors : Carlos Garc�a Campos <carlosgc@gnome.org>
 
20
 */
 
21
 
 
22
#include <glib.h>
 
23
#include "cpufreq-selector.h"
 
24
 
 
25
#define CPUFREQ_SELECTOR_GET_PRIVATE(obj) \
 
26
        (G_TYPE_INSTANCE_GET_PRIVATE((obj), CPUFREQ_TYPE_SELECTOR, CPUFreqSelectorPrivate))
 
27
 
 
28
enum {
 
29
        PROP_0,
 
30
        PROP_CPU
 
31
};
 
32
 
 
33
struct _CPUFreqSelectorPrivate {
 
34
        guint  cpu;
 
35
};
 
36
 
 
37
static void cpufreq_selector_init         (CPUFreqSelector      *selector);
 
38
static void cpufreq_selector_class_init   (CPUFreqSelectorClass *klass);
 
39
 
 
40
static void cpufreq_selector_set_property (GObject              *object,
 
41
                                           guint                 prop_id,
 
42
                                           const GValue         *value,
 
43
                                           GParamSpec           *spec);
 
44
static void cpufreq_selector_get_property (GObject              *object,
 
45
                                           guint                 prop_id,
 
46
                                           GValue               *value,
 
47
                                           GParamSpec           *spec);
 
48
 
 
49
G_DEFINE_ABSTRACT_TYPE (CPUFreqSelector, cpufreq_selector, G_TYPE_OBJECT)
 
50
 
 
51
GQuark
 
52
cpufreq_selector_error_quark (void)
 
53
{
 
54
        static GQuark error_quark = 0;
 
55
 
 
56
        if (error_quark == 0)
 
57
                error_quark =
 
58
                        g_quark_from_static_string ("cpufreq-selector-error-quark");
 
59
 
 
60
        return error_quark;
 
61
}
 
62
 
 
63
static void
 
64
cpufreq_selector_init (CPUFreqSelector *selector)
 
65
{
 
66
 
 
67
        selector->priv = CPUFREQ_SELECTOR_GET_PRIVATE (selector);
 
68
 
 
69
        selector->priv->cpu = 0;
 
70
}
 
71
 
 
72
static void
 
73
cpufreq_selector_class_init (CPUFreqSelectorClass *klass)
 
74
{
 
75
        GObjectClass *object_class = G_OBJECT_CLASS (klass);
 
76
 
 
77
        g_type_class_add_private (klass, sizeof (CPUFreqSelectorPrivate));
 
78
 
 
79
        object_class->set_property = cpufreq_selector_set_property;
 
80
        object_class->get_property = cpufreq_selector_get_property;
 
81
 
 
82
        /* Public virtual methods */
 
83
        klass->set_frequency = NULL;
 
84
        klass->set_governor = NULL;
 
85
 
 
86
        /* Porperties */
 
87
        g_object_class_install_property (object_class,
 
88
                                         PROP_CPU,
 
89
                                         g_param_spec_uint ("cpu",
 
90
                                                            NULL,
 
91
                                                            NULL,
 
92
                                                            0,
 
93
                                                            G_MAXUINT,
 
94
                                                            0,
 
95
                                                            G_PARAM_CONSTRUCT_ONLY |
 
96
                                                            G_PARAM_READWRITE));
 
97
}
 
98
 
 
99
static void
 
100
cpufreq_selector_set_property (GObject      *object,
 
101
                               guint         prop_id,
 
102
                               const GValue *value,
 
103
                               GParamSpec   *spec)
 
104
{
 
105
        CPUFreqSelector *selector = CPUFREQ_SELECTOR (object);
 
106
 
 
107
        switch (prop_id) {
 
108
        case PROP_CPU:
 
109
                selector->priv->cpu = g_value_get_uint (value);
 
110
                break;
 
111
        default:
 
112
                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, spec);
 
113
                break;
 
114
        }
 
115
}
 
116
 
 
117
static void
 
118
cpufreq_selector_get_property (GObject    *object,
 
119
                               guint       prop_id,
 
120
                               GValue     *value,
 
121
                               GParamSpec *spec)
 
122
{
 
123
        CPUFreqSelector *selector = CPUFREQ_SELECTOR (object);
 
124
 
 
125
        switch (prop_id) {
 
126
        case PROP_CPU:
 
127
                g_value_set_uint (value, selector->priv->cpu);
 
128
                break;
 
129
        default:
 
130
                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, spec);
 
131
                break;
 
132
        }
 
133
}
 
134
 
 
135
gboolean
 
136
cpufreq_selector_set_frequency (CPUFreqSelector *selector,
 
137
                                guint            frequency,
 
138
                                GError         **error)
 
139
{
 
140
        CPUFreqSelectorClass *class;
 
141
        
 
142
        g_return_val_if_fail (CPUFREQ_IS_SELECTOR (selector), FALSE);
 
143
        g_return_val_if_fail (frequency > 0, FALSE);
 
144
 
 
145
        class = CPUFREQ_SELECTOR_GET_CLASS (selector);
 
146
        
 
147
        if (class->set_frequency) {
 
148
                return class->set_frequency (selector, frequency, error);
 
149
        }
 
150
 
 
151
        return FALSE;
 
152
}
 
153
 
 
154
gboolean
 
155
cpufreq_selector_set_governor (CPUFreqSelector *selector,
 
156
                               const gchar     *governor,
 
157
                               GError         **error)
 
158
{
 
159
        CPUFreqSelectorClass *class;
 
160
        
 
161
        g_return_val_if_fail (CPUFREQ_IS_SELECTOR (selector), FALSE);
 
162
        g_return_val_if_fail (governor != NULL, FALSE);
 
163
 
 
164
        class = CPUFREQ_SELECTOR_GET_CLASS (selector);
 
165
        
 
166
        if (class->set_governor) {
 
167
                return class->set_governor (selector, governor, error);
 
168
        }
 
169
 
 
170
        return FALSE;
 
171
}
 
172
 
 
173