← Back to branch summary

~ubuntu-branches/ubuntu/utopic/awn-extras-applets/utopic

« back to all changes in this revision

Viewing changes to applets/unmaintained/awnsystemmonitor/cpu_component.c

  • Committer: Bazaar Package Importer
  • Author(s): Julien Lavergne
  • Date: 2010-01-13 21:50:33 UTC
  • mfrom: (1.1.4 upstream)
  • Revision ID: james.westby@ubuntu.com-20100113215033-kd9otcdjrajmiag0
Tags: 0.3.9~bzr1944-0ubuntu1
https://launchpad.net/bugs/359668
* New upstream snapshot.
 - Catch error in weather applet (LP: #359668)
* debian/patches: Refresh.
* debian/*.install: 
 - Update to new location and new applets.
 - Disable dialect applet until python-xklavier is in the archive.
 - Disable MiMenu and Pandora applets, there are unmaintained and not stable.
* debian/awn-applets-c-core: Dropped, not needed.
* debian/control:
 - Update description with new applets.
 - Remove libawn-extras and python-awnlib, all merged in python-awn-extras.
 - Replace awn-manager by awn-settings.
 - Drop build-depends on libgnome-desktop-dev, python*-dev, python2.5,
   awn-manager, libglade2-dev and libgnomeui-dev.
 - Add build-depends on libdesktop-agnostic-bin and vala-awn.
 - Bump build-depends of libawn-dev (>= 0.3.9~bzr1890), valac (>= 0.7.7) and
   debhelper (>= 7.0.50~).
 - Bump Standards-Version to 3.8.3 (no change needed).
 - Demote gconf-editor to Suggest, it's only needed for very advanced
   settings.
 - Update Recommends for python applets with new applets.
 - Suggest python-gconf for notification-area and alacarte for YAMA.
 - Add a debug package for C applets.
* debian/libawn-extras*: Removed, libawn-extras was removed upstream.
* debian/python-awnlib*: Merged with python-awn-extras.
* debian/rules:
 - Rewrite to use overrides.
* debian/copyright:
 - Update copyright and licenses.
* debian/README.source: Added.

Show diffs side-by-side

added added

removed removed

Lines of Context:
applets/unmaintained/awnsystemmonitor/cpu_component.c
 
1
/*
 
2
 * Copyright (c) 2007 Rodney Cryderman <rcryderman@gmail.com>
 
3
 *
 
4
 * This library is free software; you can redistribute it and/or
 
5
 * modify it under the terms of the GNU Lesser General Public
 
6
 * License as published by the Free Software Foundation; either
 
7
 * version 2 of the License, or (at your option) any later version.
 
8
 *
 
9
 * This library is distributed in the hope that it will be useful,
 
10
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
11
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
12
 * Lesser General Public License for more details.
 
13
 *
 
14
 * You should have received a copy of the GNU Lesser General Public
 
15
 * License along with this library; if not, write to the
 
16
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 
17
 * Boston, MA 02111-1307, USA.
 
18
 */
 
19
 
 
20
#include <libawn/awn-applet.h>
 
21
#include <glib/gmacros.h>
 
22
#include <glib/gerror.h>
 
23
#include <gconf/gconf-value.h>
 
24
 
 
25
#include <libawn/awn-dialog.h>
 
26
#include <libawn/awn-applet-simple.h>
 
27
#include <glib.h>
 
28
#include <gtk/gtk.h>
 
29
#include <gdk/gdk.h>
 
30
#include <string.h>
 
31
 
 
32
 
 
33
#include <glibtop/mem.h>
 
34
#include <glibtop/cpu.h>
 
35
 
 
36
 
 
37
#include "cairo-utils.h"
 
38
//#include <libawn/awn-title.h>
 
39
#include <libawn/awn-tooltip.h>
 
40
 
 
41
 
 
42
 
 
43
#include "cpu_component.h"
 
44
#include "dashboard_util.h"
 
45
#include "dashboard.h"
 
46
#include "config.h"
 
47
#include "gconf-config.h"
 
48
#define GCONF_CPU_REFRESH GCONF_PATH  "/component_cpu_refresh_rate"
 
49
#define GCONF_CPU_METER GCONF_PATH  "/component_cpu_shiny_meter"
 
50
#define GCONF_CPU_SIZE_MULT GCONF_PATH  "/component_cpu_scale"
 
51
#define GCONF_CPU_METER_START_COLOUR GCONF_PATH  "/component_cpu_meter_start_c"
 
52
#define GCONF_CPU_METER_STOP_COLOUR GCONF_PATH  "/component_cpu_meter_end_c"
 
53
#define GCONF_CPU_METER_MIDDLE_COLOUR GCONF_PATH  "/component_cpu_meter_middle_c"
 
54
#define GCONF_CPU_METER_USE_2_COLOUR_GRADIENT GCONF_PATH "/component_cpu_use_2_colour_gradient"
 
55
 
 
56
#define GCONF_CPU_METER_NO_GTK_FG  GCONF_PATH "/component_cpu_fg"
 
57
#define GCONF_CPU_METER_NO_GTK_BG  GCONF_PATH "/component_cpu_bg"
 
58
 
 
59
//#undef NDEBUG
 
60
#include <assert.h>
 
61
 
 
62
typedef struct
 
63
{
 
64
  double max_width_left;
 
65
  double max_width_right;
 
66
  double width;
 
67
  double height;
 
68
  double move_down;
 
69
  int timer;
 
70
  int refresh;
 
71
  long     accum_user, accum_sys, accum_idle, accum_iowait ;
 
72
  float user;
 
73
  float  sys;
 
74
  float idle;
 
75
  float iowait;
 
76
  float size_mult;
 
77
  cairo_pattern_t *pats[4];
 
78
  gboolean shiny_graphs;
 
79
  AwnColor colour_meter_start;
 
80
  AwnColor colour_meter_end;
 
81
  AwnColor colour_meter_middle;
 
82
  gboolean two_colour_gradient;
 
83
  AwnColor    bg;             /*colours if gtk colours are overridden */
 
84
  AwnColor    fg;
 
85
  gboolean    emotive_text;
 
86
}CPU_plug_data;
 
87
 
 
88
static gboolean render(GtkWidget ** pwidget, gint interval, CPU_plug_data **p);
 
89
static gboolean query_support_multiple(void);
 
90
static void destruct(CPU_plug_data **p);
 
91
static void construct(CPU_plug_data **p);
 
92
static gboolean decrease_step(CPU_plug_data **p);
 
93
static gboolean increase_step(CPU_plug_data **p);
 
94
static GtkWidget* attach_right_click_menu(CPU_plug_data **p);
 
95
static const char* get_component_name(void *);
 
96
static const char* get_component_friendly_name(void *);
 
97
 
 
98
static gboolean _toggle_2_gradient(GtkWidget *widget, GdkEventButton *event, CPU_plug_data *p);
 
99
static gboolean _toggle_shiny(GtkWidget *widget, GdkEventButton *event, CPU_plug_data *p);
 
100
 
 
101
static gboolean _set_100(GtkWidget *widget, GdkEventButton *event, CPU_plug_data *p);
 
102
static gboolean _set_200(GtkWidget *widget, GdkEventButton *event, CPU_plug_data *p);
 
103
static gboolean _set_500(GtkWidget *widget, GdkEventButton *event, CPU_plug_data *p);
 
104
static gboolean _set_1000(GtkWidget *widget, GdkEventButton *event, CPU_plug_data *p);
 
105
static gboolean _set_5000(GtkWidget *widget, GdkEventButton *event, CPU_plug_data *p);
 
106
 
 
107
static gboolean _set_good(GtkWidget *widget, GdkEventButton *event, CPU_plug_data *p);
 
108
static gboolean _set_bad(GtkWidget *widget, GdkEventButton *event, CPU_plug_data *p);
 
109
static gboolean _set_middling(GtkWidget *widget, GdkEventButton *event, CPU_plug_data *p);
 
110
static gboolean _set_fg(GtkWidget *widget, GdkEventButton *event, CPU_plug_data *p);
 
111
static gboolean _set_bg(GtkWidget *widget, GdkEventButton *event, CPU_plug_data *p);
 
112
 
 
113
static void set_colour_gradient(CPU_plug_data *p, AwnColor* colour, const char * mess, const char * gconf_key);
 
114
 
 
115
static void _notify_color_change(void *);
 
116
 
 
117
static void _fn_set_bg(AwnColor * new_bg, CPU_plug_data **p);
 
118
static void _fn_set_fg(AwnColor * new_fg, CPU_plug_data **p);
 
119
 
 
120
 
 
121
static void * plug_fns[MAX_CALLBACK_FN] =
 
122
{
 
123
  construct,
 
124
  destruct,
 
125
  render,
 
126
  query_support_multiple,
 
127
  NULL,
 
128
  increase_step,
 
129
  decrease_step,
 
130
  attach_right_click_menu,
 
131
  get_component_name,
 
132
  get_component_friendly_name,
 
133
  _fn_set_bg,
 
134
  _fn_set_fg,
 
135
  NULL
 
136
};
 
137
 
 
138
 
 
139
void * cpu_plug_lookup(int fn_id)
 
140
{
 
141
  assert(fn_id < MAX_CALLBACK_FN);
 
142
  return plug_fns[fn_id];
 
143
}
 
144
 
 
145
static void _fn_set_bg(AwnColor * new_bg, CPU_plug_data **p)
 
146
{
 
147
  char *svalue;
 
148
  CPU_plug_data  * plug_data = *p;
 
149
  plug_data->bg = *new_bg;
 
150
  svalue = dashboard_cairo_colour_to_string(new_bg);
 
151
  gconf_client_set_string(get_dashboard_gconf(), GCONF_CPU_METER_NO_GTK_BG, svalue , NULL);
 
152
  free(svalue);
 
153
}
 
154
 
 
155
 
 
156
static void _fn_set_fg(AwnColor * new_fg, CPU_plug_data **p)
 
157
{
 
158
  char *svalue;
 
159
  CPU_plug_data  * plug_data = *p;
 
160
  plug_data->fg = *new_fg;
 
161
  svalue = dashboard_cairo_colour_to_string(new_fg);
 
162
  gconf_client_set_string(get_dashboard_gconf(), GCONF_CPU_METER_NO_GTK_FG, svalue , NULL);
 
163
  free(svalue);
 
164
}
 
165
 
 
166
 
 
167
static const char* get_component_name(void *d)
 
168
{
 
169
  const char * name = "component_cpu";
 
170
  return name;
 
171
}
 
172
 
 
173
static const char* get_component_friendly_name(void *d)
 
174
{
 
175
  const char * name = "CPU Stats";
 
176
  return name;
 
177
}
 
178
 
 
179
 
 
180
 
 
181
static GtkWidget* attach_right_click_menu(CPU_plug_data **p)
 
182
{
 
183
  CPU_plug_data * plug_data = *p;
 
184
  GtkWidget * menu_items;
 
185
  GtkWidget *menu = gtk_menu_new();
 
186
//    GtkWidget *graphs_sub_menu = gtk_menu_new ();
 
187
  GtkWidget *graphs_refresh_menu = gtk_menu_new();
 
188
  GtkWidget *graphs_colour_menu = gtk_menu_new();
 
189
 
 
190
  dashboard_build_clickable_menu_item(menu, G_CALLBACK(_toggle_shiny), "Shiny On/Off", plug_data);
 
191
  dashboard_build_clickable_menu_item(menu, G_CALLBACK(_set_fg), "Foreground", plug_data);
 
192
  dashboard_build_clickable_menu_item(menu, G_CALLBACK(_set_bg), "Background", plug_data);
 
193
  dashboard_build_clickable_menu_item(menu, G_CALLBACK(_toggle_2_gradient), "2 Colour Gradient", plug_data);
 
194
  dashboard_build_clickable_menu_item(graphs_refresh_menu, G_CALLBACK(_set_100), "100ms", plug_data);
 
195
  dashboard_build_clickable_menu_item(graphs_refresh_menu, G_CALLBACK(_set_200), "200ms", plug_data);
 
196
  dashboard_build_clickable_menu_item(graphs_refresh_menu, G_CALLBACK(_set_500), "500ms", plug_data);
 
197
  dashboard_build_clickable_menu_item(graphs_refresh_menu, G_CALLBACK(_set_1000), "1000ms", plug_data);
 
198
  dashboard_build_clickable_menu_item(graphs_refresh_menu, G_CALLBACK(_set_5000), "5000ms", plug_data);
 
199
  menu_items = gtk_menu_item_new_with_label("Refresh");
 
200
  gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_items);
 
201
  gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu_items), graphs_refresh_menu);
 
202
  gtk_widget_show(menu_items);
 
203
  dashboard_build_clickable_menu_item(graphs_colour_menu, G_CALLBACK(_set_good), "Good", plug_data);
 
204
  dashboard_build_clickable_menu_item(graphs_colour_menu, G_CALLBACK(_set_middling), "Middling", plug_data);
 
205
  dashboard_build_clickable_menu_item(graphs_colour_menu, G_CALLBACK(_set_bad), "Bad", plug_data);
 
206
  gtk_widget_show(menu_items);
 
207
  menu_items = gtk_menu_item_new_with_label("Meter Colours");
 
208
  gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_items);
 
209
  gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu_items), graphs_colour_menu);
 
210
  gtk_widget_show(menu_items);
 
211
  return menu;
 
212
 
 
213
}
 
214
 
 
215
static gboolean _toggle_shiny(GtkWidget *widget, GdkEventButton *event, CPU_plug_data *p)
 
216
{
 
217
  p->shiny_graphs = !p->shiny_graphs;
 
218
  gconf_client_set_bool(get_dashboard_gconf(), GCONF_CPU_METER, p->shiny_graphs, NULL);
 
219
  return TRUE;
 
220
}
 
221
 
 
222
static gboolean _toggle_2_gradient(GtkWidget *widget, GdkEventButton *event, CPU_plug_data *p)
 
223
{
 
224
  p->two_colour_gradient = !p->two_colour_gradient;
 
225
  gconf_client_set_bool(get_dashboard_gconf(), GCONF_CPU_METER_USE_2_COLOUR_GRADIENT, p->two_colour_gradient, NULL);
 
226
  _notify_color_change(p);
 
227
  return TRUE;
 
228
}
 
229
 
 
230
static gboolean set_refresh(CPU_plug_data *p, int val)
 
231
{
 
232
  p->refresh = val;
 
233
  gconf_client_set_int(get_dashboard_gconf(), GCONF_CPU_REFRESH, p->refresh, NULL);
 
234
  return TRUE;
 
235
}
 
236
 
 
237
static gboolean _set_100(GtkWidget *widget, GdkEventButton *event, CPU_plug_data *p)
 
238
{
 
239
  return set_refresh(p, 100);
 
240
}
 
241
 
 
242
static gboolean _set_200(GtkWidget *widget, GdkEventButton *event, CPU_plug_data *p)
 
243
{
 
244
  return set_refresh(p, 200);
 
245
}
 
246
 
 
247
static gboolean _set_500(GtkWidget *widget, GdkEventButton *event, CPU_plug_data *p)
 
248
{
 
249
  return set_refresh(p, 500);
 
250
}
 
251
 
 
252
static gboolean _set_1000(GtkWidget *widget, GdkEventButton *event, CPU_plug_data *p)
 
253
{
 
254
  return set_refresh(p, 1000);
 
255
}
 
256
 
 
257
static gboolean _set_5000(GtkWidget *widget, GdkEventButton *event, CPU_plug_data *p)
 
258
{
 
259
  return set_refresh(p, 5000);
 
260
}
 
261
 
 
262
 
 
263
static void _notify_color_change(void *p)
 
264
{
 
265
  CPU_plug_data *data = p;
 
266
  assert(p);
 
267
  data->max_width_left = -1;
 
268
}
 
269
 
 
270
 
 
271
static void set_colour_gradient(CPU_plug_data *p, AwnColor* colour, const char * mess, const char * gconf_key)
 
272
{
 
273
  char *svalue;
 
274
  enable_suppress_hide_main();
 
275
  pick_awn_color(colour, mess, p, _notify_color_change);
 
276
  svalue = dashboard_cairo_colour_to_string(colour);
 
277
  gconf_client_set_string(get_dashboard_gconf(), gconf_key, svalue , NULL);
 
278
  free(svalue);
 
279
 
 
280
}
 
281
 
 
282
 
 
283
static gboolean _set_fg(GtkWidget *widget, GdkEventButton *event, CPU_plug_data *p)
 
284
{
 
285
  set_colour_gradient(p, &p->fg, "Foreground Colour if Ignore gtk", GCONF_CPU_METER_NO_GTK_FG);
 
286
  return TRUE;
 
287
}
 
288
 
 
289
static gboolean _set_bg(GtkWidget *widget, GdkEventButton *event, CPU_plug_data *p)
 
290
{
 
291
  set_colour_gradient(p, &p->bg, "Foreground Colour if Ignore gtk", GCONF_CPU_METER_NO_GTK_BG);
 
292
  return TRUE;
 
293
}
 
294
 
 
295
 
 
296
static gboolean _set_good(GtkWidget *widget, GdkEventButton *event, CPU_plug_data *p)
 
297
{
 
298
  set_colour_gradient(p, &p->colour_meter_start, "Changing Good Colour", GCONF_CPU_METER_START_COLOUR);
 
299
  return TRUE;
 
300
}
 
301
 
 
302
 
 
303
static gboolean _set_bad(GtkWidget *widget, GdkEventButton *event, CPU_plug_data *p)
 
304
{
 
305
  set_colour_gradient(p, &p->colour_meter_end, "Changing Bad Colour", GCONF_CPU_METER_STOP_COLOUR);
 
306
  return TRUE;
 
307
}
 
308
 
 
309
static gboolean _set_middling(GtkWidget *widget, GdkEventButton *event, CPU_plug_data *p)
 
310
{
 
311
  set_colour_gradient(p, &p->colour_meter_middle, "Changing Middle Colour", GCONF_CPU_METER_MIDDLE_COLOUR);
 
312
  return TRUE;
 
313
}
 
314
 
 
315
static gboolean decrease_step(CPU_plug_data **p)
 
316
{
 
317
  CPU_plug_data *data = *p;
 
318
  data->size_mult = data->size_mult * 5.0 / 6.0;
 
319
  data->max_width_left = -1;
 
320
  gconf_client_set_float(get_dashboard_gconf(), GCONF_CPU_SIZE_MULT, data->size_mult, NULL);
 
321
  return TRUE;
 
322
}
 
323
 
 
324
static gboolean increase_step(CPU_plug_data **p)
 
325
{
 
326
  CPU_plug_data *data = *p;
 
327
  data->size_mult = data->size_mult  * 1.2;
 
328
  data->max_width_left = -1;
 
329
  gconf_client_set_float(get_dashboard_gconf(), GCONF_CPU_SIZE_MULT, data->size_mult, NULL);
 
330
  return TRUE;
 
331
}
 
332
 
 
333
 
 
334
 
 
335
static gboolean query_support_multiple(void)
 
336
{
 
337
  return FALSE;
 
338
}
 
339
 
 
340
static void construct(CPU_plug_data **p)
 
341
{
 
342
  GConfValue *value;
 
343
  *p = g_malloc(sizeof(CPU_plug_data));
 
344
  CPU_plug_data * data = *p;
 
345
  gchar * svalue;
 
346
  data->max_width_left = -1;
 
347
  data->max_width_right = -1;
 
348
  data->timer = 100;
 
349
  data->user = 0;
 
350
  data->sys = 0;
 
351
  data->idle = 100;
 
352
  data->iowait = 0;
 
353
 
 
354
  data->emotive_text = FALSE;
 
355
 
 
356
  svalue = gconf_client_get_string(get_dashboard_gconf(), GCONF_CPU_METER_NO_GTK_BG, NULL);
 
357
 
 
358
  if (!svalue)
 
359
  {
 
360
    gconf_client_set_string(get_dashboard_gconf(), GCONF_CPU_METER_NO_GTK_BG, svalue = g_strdup("999999ee"), NULL);
 
361
  }
 
362
 
 
363
  awn_cairo_string_to_color(svalue, &data->bg);
 
364
 
 
365
  g_free(svalue);
 
366
 
 
367
  svalue = gconf_client_get_string(get_dashboard_gconf(), GCONF_CPU_METER_NO_GTK_FG, NULL);
 
368
 
 
369
  if (!svalue)
 
370
  {
 
371
    gconf_client_set_string(get_dashboard_gconf(), GCONF_CPU_METER_NO_GTK_FG, svalue = g_strdup("000000ff"), NULL);
 
372
  }
 
373
 
 
374
  awn_cairo_string_to_color(svalue, &data->fg);
 
375
 
 
376
  g_free(svalue);
 
377
 
 
378
  value = gconf_client_get(get_dashboard_gconf(), GCONF_CPU_SIZE_MULT, NULL);
 
379
 
 
380
  if (value)
 
381
  {
 
382
    data->size_mult = gconf_client_get_float(get_dashboard_gconf(), GCONF_CPU_SIZE_MULT, NULL);
 
383
  }
 
384
  else
 
385
  {
 
386
    data->size_mult = 1.72;
 
387
    gconf_client_set_float(get_dashboard_gconf(), GCONF_CPU_SIZE_MULT, data->size_mult, NULL);
 
388
  }
 
389
 
 
390
  value = gconf_client_get(get_dashboard_gconf(), GCONF_CPU_REFRESH, NULL);
 
391
 
 
392
  if (value)
 
393
  {
 
394
    data->refresh = gconf_client_get_int(get_dashboard_gconf(), GCONF_CPU_REFRESH, NULL);
 
395
  }
 
396
  else
 
397
  {
 
398
    data->refresh = 500;
 
399
    set_refresh(*p, data->refresh);
 
400
  }
 
401
 
 
402
  value = gconf_client_get(get_dashboard_gconf(), GCONF_CPU_METER, NULL);
 
403
 
 
404
  if (value)
 
405
  {
 
406
    data->shiny_graphs = gconf_client_get_bool(get_dashboard_gconf(), GCONF_CPU_METER, NULL);
 
407
  }
 
408
  else
 
409
  {
 
410
    data->shiny_graphs = TRUE;
 
411
    gconf_client_set_bool(get_dashboard_gconf(), GCONF_CPU_METER,
 
412
                          data->shiny_graphs, NULL);
 
413
  }
 
414
 
 
415
  value = gconf_client_get(get_dashboard_gconf(), GCONF_CPU_METER_USE_2_COLOUR_GRADIENT    , NULL);
 
416
 
 
417
  if (value)
 
418
  {
 
419
    data->two_colour_gradient = gconf_client_get_bool(get_dashboard_gconf(), GCONF_CPU_METER_USE_2_COLOUR_GRADIENT    , NULL);
 
420
  }
 
421
  else
 
422
  {
 
423
    data->two_colour_gradient = FALSE;
 
424
    gconf_client_set_bool(get_dashboard_gconf(), GCONF_CPU_METER_USE_2_COLOUR_GRADIENT, data->two_colour_gradient, NULL);
 
425
  }
 
426
 
 
427
  svalue = gconf_client_get_string(get_dashboard_gconf(), GCONF_CPU_METER_START_COLOUR, NULL);
 
428
 
 
429
  if (!svalue)
 
430
  {
 
431
    gconf_client_set_string(get_dashboard_gconf(), GCONF_CPU_METER_START_COLOUR, svalue = g_strdup("00FF10bb"), NULL);
 
432
  }
 
433
 
 
434
  awn_cairo_string_to_color(svalue, &data->colour_meter_start);
 
435
 
 
436
  g_free(svalue);
 
437
  svalue = gconf_client_get_string(get_dashboard_gconf(), GCONF_CPU_METER_MIDDLE_COLOUR, NULL);
 
438
 
 
439
  if (!svalue)
 
440
  {
 
441
    gconf_client_set_string(get_dashboard_gconf(), GCONF_CPU_METER_MIDDLE_COLOUR, svalue = g_strdup("EEC83177"), NULL);
 
442
  }
 
443
 
 
444
  awn_cairo_string_to_color(svalue, &data->colour_meter_middle);
 
445
 
 
446
  g_free(svalue);
 
447
  svalue = gconf_client_get_string(get_dashboard_gconf(), GCONF_CPU_METER_STOP_COLOUR, NULL);
 
448
 
 
449
  if (!svalue)
 
450
  {
 
451
    gconf_client_set_string(get_dashboard_gconf(), GCONF_CPU_METER_STOP_COLOUR, svalue = g_strdup("FF0010ee"), NULL);
 
452
  }
 
453
 
 
454
  awn_cairo_string_to_color(svalue, &data->colour_meter_end);
 
455
 
 
456
  g_free(svalue);
 
457
  //data->pats[] is initialized once i render.. then needs to be free'd in constructor
 
458
 
 
459
}
 
460
 
 
461
static void destruct(CPU_plug_data **p)
 
462
{
 
463
  CPU_plug_data *data = *p;
 
464
  int i;
 
465
 
 
466
  for (i = 0;i < 4;i++)
 
467
  {
 
468
    cairo_pattern_destroy(data->pats[i]);
 
469
  }
 
470
 
 
471
  g_free(*p);
 
472
}
 
473
 
 
474
static gboolean render(GtkWidget ** pwidget, gint interval, CPU_plug_data **p)
 
475
{
 
476
  CPU_plug_data * data = *p;
 
477
  char buf[256];
 
478
  glibtop_cpu         cpu;
 
479
  static gdouble old_time = -1;
 
480
  float old_user, old_sys, old_idle, old_iowait;
 
481
  dashboard_cairo_widget c_widge;
 
482
  char * content[2][4];
 
483
  int i;
 
484
  cairo_text_extents_t    extents;
 
485
  double x, y;
 
486
  float cpu_mult;
 
487
  float tot = 0;
 
488
  GTimeVal  timeval;
 
489
 
 
490
  if (old_time < 0)
 
491
  {
 
492
    old_time = time(NULL);
 
493
    return FALSE;
 
494
  }
 
495
    
 
496
  data->timer = data->timer - interval;
 
497
  if (data->timer <= 0)
 
498
  {
 
499
    gdouble newtime;
 
500
    g_get_current_time (&timeval);
 
501
    newtime = timeval.tv_sec + timeval.tv_usec / 1000000.0;
 
502
    cpu_mult = (1.0 / (newtime - old_time) );
 
503
    old_time = newtime;
 
504
    glibtop_get_cpu(&cpu);      //could as easily do this in render icon.  seems more appropriate here.     FIXME
 
505
 
 
506
    old_user = data->user;
 
507
    data->user = (cpu.user - data->accum_user) * cpu_mult;
 
508
    data->accum_user = cpu.user;
 
509
 
 
510
    old_sys = data->sys;
 
511
    data->sys = (cpu.sys - data->accum_sys) * cpu_mult;
 
512
    data->accum_sys = cpu.sys;
 
513
 
 
514
    old_idle = data->idle;
 
515
    data->idle = (cpu.idle - data->accum_idle) * cpu_mult;
 
516
    data->accum_idle = cpu.idle;
 
517
 
 
518
    old_iowait = data->iowait;
 
519
    data->iowait = (cpu.iowait - data->accum_iowait) * cpu_mult ;
 
520
    data->accum_iowait = cpu.iowait;
 
521
 
 
522
    data->user = (data->user > 100) ? (100 + old_user) / 2 : (data->user + old_user) / 2;
 
523
    data->sys = (data->sys > 100) ? (100 + old_sys) / 2 : (data->sys + old_sys) / 2;
 
524
    data->idle = (data->idle > 100) ? (100 + old_idle) / 2 : (data->idle + old_idle) / 2;
 
525
    data->iowait = (data->iowait > 100) ? (100 + old_iowait) / 2 : (data->iowait + old_iowait) / 2;
 
526
 
 
527
    tot = data->user + data->sys + data->idle + data->iowait;
 
528
    if (data->user + data->sys + data->idle + data->iowait > 100)
 
529
    {
 
530
      data->idle = data->idle * 100.0 / tot;
 
531
      data->sys = data->sys  * 100.0 / tot;
 
532
      data->user = data->user* 100.0 / tot;
 
533
      data->iowait = data->iowait * 100.0 / tot;
 
534
    }
 
535
 
 
536
    content[0][0] = strdup("User");
 
537
 
 
538
    content[0][1] = strdup("Sys");
 
539
    content[0][2] = strdup("Wait");
 
540
    content[0][3] = strdup("Idle");
 
541
 
 
542
    snprintf(buf, sizeof(buf), "%3.1f%%", data->user);
 
543
    content[1][0] = strdup(buf);
 
544
 
 
545
    snprintf(buf, sizeof(buf), "%3.1f%%", data->sys);
 
546
    content[1][1] = strdup(buf);
 
547
 
 
548
    snprintf(buf, sizeof(buf), "%3.1f%%", data->iowait);
 
549
    content[1][2] = strdup(buf);
 
550
 
 
551
    snprintf(buf, sizeof(buf), "%3.1f%%", data->idle);
 
552
    content[1][3] = strdup(buf);
 
553
 
 
554
goto_bad_heheh:
 
555
 
 
556
    if (data->max_width_left < 0)
 
557
    {
 
558
      *pwidget = get_cairo_widget(&c_widge, dashboard_get_font_size(DASHBOARD_FONT_SMALL) * 9 * data->size_mult, dashboard_get_font_size(DASHBOARD_FONT_SMALL) * 4 * data->size_mult);
 
559
      use_bg_rgba_colour(c_widge.cr);
 
560
      cairo_set_operator(c_widge.cr, CAIRO_OPERATOR_SOURCE);
 
561
      cairo_paint(c_widge.cr);
 
562
    }
 
563
    else
 
564
    {
 
565
      *pwidget = get_cairo_widget(&c_widge, data->width, data->height);
 
566
      cairo_rectangle(c_widge.cr, 0, 0, data->width, data->height);
 
567
 
 
568
      cairo_set_source_rgba(c_widge.cr, data->bg.red, data->bg.green, data->bg.blue, data->bg.alpha);
 
569
 
 
570
      cairo_fill(c_widge.cr);
 
571
    }
 
572
 
 
573
    cairo_select_font_face(c_widge.cr, "Sans", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL);
 
574
 
 
575
    cairo_set_font_size(c_widge.cr, dashboard_get_font_size(DASHBOARD_FONT_SMALL)*data->size_mult);
 
576
 
 
577
 
 
578
    cairo_set_source_rgba(c_widge.cr, data->fg.red, data->fg.green, data->fg.blue, data->fg.alpha);
 
579
 
 
580
    cairo_move_to(c_widge.cr, 10.0*data->size_mult, 15.0*data->size_mult);
 
581
 
 
582
    if (data->max_width_left < 0)
 
583
    {
 
584
      for (i = 0;i < 4;i++)
 
585
      {
 
586
        cairo_text_extents(c_widge.cr, content[0][i], &extents);
 
587
 
 
588
        if (extents.width > data->max_width_left)
 
589
        {
 
590
          data->max_width_left = extents.width;
 
591
        }
 
592
 
 
593
      }
 
594
 
 
595
      data->move_down = extents.height * 1.4;
 
596
 
 
597
      for (i = 0;i < 4;i++)
 
598
      {
 
599
        cairo_text_extents(c_widge.cr, content[1][i], &extents);
 
600
 
 
601
        if (extents.width > data->max_width_right)
 
602
        {
 
603
          data->max_width_right = extents.width;
 
604
        }
 
605
      }
 
606
 
 
607
      data->width = (data->max_width_right + data->max_width_left) * 1.25 + 100 * data->size_mult;
 
608
 
 
609
      data->height = extents.height * 6.8;
 
610
      del_cairo_widget(&c_widge);
 
611
      y = dashboard_get_font_size(DASHBOARD_FONT_SMALL) * data->size_mult ;
 
612
      data->pats[0] = cairo_pattern_create_linear(data->width - 100 * data->size_mult, y - data->move_down * 0.8, data->width, data->move_down * 0.6);
 
613
      cairo_pattern_add_color_stop_rgba(data->pats[0], 0, data->colour_meter_start.red ,
 
614
                                        data->colour_meter_start.green,
 
615
                                        data->colour_meter_start.blue,
 
616
                                        data->colour_meter_start.alpha);
 
617
 
 
618
      if (!data->two_colour_gradient)
 
619
        cairo_pattern_add_color_stop_rgba(data->pats[0], 0.5, data->colour_meter_middle.red ,
 
620
                                          data->colour_meter_middle.green,
 
621
                                          data->colour_meter_middle.blue,
 
622
                                          data->colour_meter_middle.alpha);
 
623
 
 
624
      cairo_pattern_add_color_stop_rgba(data->pats[0], 1, data->colour_meter_end.red ,
 
625
                                        data->colour_meter_end.green,
 
626
                                        data->colour_meter_end.blue,
 
627
                                        data->colour_meter_end.alpha);
 
628
 
 
629
      data->pats[1] = cairo_pattern_create_linear(data->width - 100 * data->size_mult, y - data->move_down * 0.8, data->width, data->move_down * 0.6);
 
630
 
 
631
      cairo_pattern_add_color_stop_rgba(data->pats[1], 0, data->colour_meter_start.red ,
 
632
                                        data->colour_meter_start.green,
 
633
                                        data->colour_meter_start.blue,
 
634
                                        data->colour_meter_start.alpha);
 
635
 
 
636
      if (!data->two_colour_gradient)
 
637
        cairo_pattern_add_color_stop_rgba(data->pats[1], 0.5, data->colour_meter_middle.red ,
 
638
                                          data->colour_meter_middle.green,
 
639
                                          data->colour_meter_middle.blue,
 
640
                                          data->colour_meter_middle.alpha);
 
641
 
 
642
      cairo_pattern_add_color_stop_rgba(data->pats[1], 1, data->colour_meter_end.red ,
 
643
                                        data->colour_meter_end.green,
 
644
                                        data->colour_meter_end.blue,
 
645
                                        data->colour_meter_end.alpha);
 
646
 
 
647
      data->pats[2] = cairo_pattern_create_linear(data->width - 100 * data->size_mult, y - data->move_down * 0.8, data->width, data->move_down * 0.6);
 
648
 
 
649
      cairo_pattern_add_color_stop_rgba(data->pats[2], 0, data->colour_meter_start.red ,
 
650
                                        data->colour_meter_start.green,
 
651
                                        data->colour_meter_start.blue,
 
652
                                        data->colour_meter_start.alpha);
 
653
 
 
654
      if (!data->two_colour_gradient)
 
655
        cairo_pattern_add_color_stop_rgba(data->pats[2], 0.5, data->colour_meter_middle.red ,
 
656
                                          data->colour_meter_middle.green,
 
657
                                          data->colour_meter_middle.blue,
 
658
                                          data->colour_meter_middle.alpha);
 
659
 
 
660
      cairo_pattern_add_color_stop_rgba(data->pats[2], 1, data->colour_meter_end.red ,
 
661
                                        data->colour_meter_end.green,
 
662
                                        data->colour_meter_end.blue,
 
663
                                        data->colour_meter_end.alpha);
 
664
 
 
665
      data->pats[3] = cairo_pattern_create_linear(data->width - 100 * data->size_mult, y - data->move_down * 0.8 , data->width, data->move_down * 0.6);
 
666
 
 
667
      cairo_pattern_add_color_stop_rgba(data->pats[3], 0, data->colour_meter_end.red ,
 
668
                                        data->colour_meter_end.green,
 
669
                                        data->colour_meter_end.blue,
 
670
                                        data->colour_meter_end.alpha);
 
671
 
 
672
      if (!data->two_colour_gradient)
 
673
        cairo_pattern_add_color_stop_rgba(data->pats[3], 0.5, data->colour_meter_middle.red ,
 
674
                                          data->colour_meter_middle.green,
 
675
                                          data->colour_meter_middle.blue,
 
676
                                          data->colour_meter_middle.alpha);
 
677
 
 
678
      cairo_pattern_add_color_stop_rgba(data->pats[3], 1, data->colour_meter_start.red ,
 
679
                                        data->colour_meter_start.green,
 
680
                                        data->colour_meter_start.blue,
 
681
                                        data->colour_meter_start.alpha);
 
682
 
 
683
      goto goto_bad_heheh;
 
684
    }
 
685
 
 
686
    cairo_move_to(c_widge.cr, x = dashboard_get_font_size(DASHBOARD_FONT_SMALL) * data->size_mult, y = dashboard_get_font_size(DASHBOARD_FONT_SMALL) * data->size_mult);
 
687
 
 
688
    for (i = 0;i < 4;i++)
 
689
    {
 
690
      cairo_show_text(c_widge.cr, content[0][i]);
 
691
      x = x + data->max_width_left * 1.1;
 
692
      cairo_text_extents(c_widge.cr, content[1][i], &extents);
 
693
 
 
694
      if (data->emotive_text)
 
695
      {
 
696
        switch (i)
 
697
        {
 
698
 
 
699
          case 0:
 
700
            cairo_set_source_rgb(c_widge.cr, data->user / 100.0, 1.0 - data->user / 100.0, 0.4);
 
701
 
 
702
            break;
 
703
 
 
704
          case 1:
 
705
            cairo_set_source_rgb(c_widge.cr, (data->sys) / 100.0, 1.0 - (data->sys) / 100.0, 0.4);
 
706
            break;
 
707
 
 
708
          case 2:
 
709
            cairo_set_source_rgb(c_widge.cr, (data->iowait) / 100.0, 1.0 - (data->iowait) / 100.0, 0.4);
 
710
            break;
 
711
 
 
712
          case 3:
 
713
            cairo_set_source_rgb(c_widge.cr, 1.0 - data->idle / 100.0, data->idle / 100.0, 0.4);
 
714
            break;
 
715
        }
 
716
      }
 
717
      else
 
718
      {
 
719
        cairo_set_source_rgba(c_widge.cr, data->fg.red, data->fg.green, data->fg.blue, data->fg.alpha);
 
720
      }
 
721
 
 
722
      cairo_move_to(c_widge.cr,
 
723
 
 
724
                    x + (data->max_width_right - extents.width)
 
725
                    , y);
 
726
      cairo_show_text(c_widge.cr, content[1][i]);
 
727
//            cairo_pattern_t *pat;
 
728
 
 
729
//            pat = cairo_pattern_create_linear (0.0, 0.0,  0.0, 256.0);
 
730
 
 
731
      switch (i)
 
732
      {
 
733
 
 
734
        case 0:
 
735
 
 
736
          if (data->user)
 
737
          {
 
738
            cairo_rectangle(c_widge.cr, data->width - 100*data->size_mult, y - data->move_down*0.6, data->user*data->size_mult, data->move_down*0.6);
 
739
 
 
740
            if (data->shiny_graphs)
 
741
              cairo_set_source(c_widge.cr, data->pats[i]);
 
742
 
 
743
            cairo_fill(c_widge.cr);
 
744
          }
 
745
 
 
746
          break;
 
747
 
 
748
        case 1:
 
749
 
 
750
          if (data->sys)
 
751
          {
 
752
 
 
753
            cairo_rectangle(c_widge.cr, data->width - 100*data->size_mult, y - data->move_down*0.6, data->sys*data->size_mult, data->move_down*0.6);
 
754
 
 
755
            if (data->shiny_graphs)
 
756
              cairo_set_source(c_widge.cr, data->pats[i]);
 
757
 
 
758
            cairo_fill(c_widge.cr);
 
759
          }
 
760
 
 
761
          break;
 
762
 
 
763
        case 2:
 
764
 
 
765
          if (data->iowait)
 
766
          {
 
767
 
 
768
            cairo_rectangle(c_widge.cr, data->width - 100*data->size_mult, y - data->move_down*0.6, data->iowait*data->size_mult, data->move_down*0.6);
 
769
 
 
770
            if (data->shiny_graphs)
 
771
              cairo_set_source(c_widge.cr, data->pats[i]);
 
772
 
 
773
            cairo_fill(c_widge.cr);
 
774
          }
 
775
 
 
776
          break;
 
777
 
 
778
        case 3:
 
779
 
 
780
          if (data->user)
 
781
          {
 
782
 
 
783
            cairo_rectangle(c_widge.cr, data->width - 100*data->size_mult, y - data->move_down*0.6, data->idle*data->size_mult, data->move_down*0.6);
 
784
 
 
785
            if (data->shiny_graphs)
 
786
              cairo_set_source(c_widge.cr, data->pats[i]);
 
787
 
 
788
            cairo_fill(c_widge.cr);
 
789
          }
 
790
 
 
791
          break;
 
792
      }
 
793
 
 
794
      cairo_set_source_rgba(c_widge.cr, data->fg.red, data->fg.green, data->fg.blue, data->fg.alpha);
 
795
 
 
796
      x = dashboard_get_font_size(DASHBOARD_FONT_SMALL) * data->size_mult;
 
797
      y = y + data->move_down;
 
798
      cairo_move_to(c_widge.cr, x, y);
 
799
    }
 
800
 
 
801
    del_cairo_widget(&c_widge);
 
802
 
 
803
    data->timer = data->refresh;
 
804
 
 
805
    for (i = 0;i < 4;i++)
 
806
    {
 
807
      free(content[0][i]);
 
808
      free(content[1][i]);
 
809
    }
 
810
 
 
811
    return TRUE;
 
812
  }
 
813
  else
 
814
  {
 
815
    return FALSE;
 
816
  }
 
817
}
 
818