vcs.maemo.org Git - monky/blob - src/specials.c

   1 /* Conky, a system monitor, based on torsmo
   2  *
   3  * Any original torsmo code is licensed under the BSD license
   4  *
   5  * All code written since the fork of torsmo is licensed under the GPL
   6  *
   7  * Please see COPYING for details
   8  *
   9  * Copyright (c) 2004, Hannu Saransaari and Lauri Hakkarainen
  10  * Copyright (c) 2005-2009 Brenden Matthews, Philip Kovacs, et. al.
  11  *      (see AUTHORS)
  12  * All rights reserved.
  13  *
  14  * This program is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU General Public License as published by
  16  * the Free Software Foundation, either version 3 of the License, or
  17  * (at your option) any later version.
  18  *
  19  * This program is distributed in the hope that it will be useful,
  20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22  * GNU General Public License for more details.
  23  * You should have received a copy of the GNU General Public License
  24  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  25  *
  26  */
  27 #include "conky.h"
  28 #include "colours.h"
  29 #ifdef X11
  30 #include "fonts.h"
  31 #endif
  32 #include "logging.h"
  33 #include "specials.h"
  34 #include <math.h>
  35
  36 /* maximum number of special things, e.g. fonts, offsets, aligns, etc. */
  37 unsigned int max_specials = MAX_SPECIALS_DEFAULT;
  38
  39 /* create specials array on heap instead of stack with introduction of
  40  * max_specials */
  41 struct special_t *specials = NULL;
  42
  43 unsigned int special_count;
  44
  45 #ifdef X11
  46 int default_bar_width = 0, default_bar_height = 6;
  47 int default_graph_width = 0, default_graph_height = 25;
  48 int default_gauge_width = 40, default_gauge_height = 25;
  49 #endif
  50
  51 /*
  52  * Scanning arguments to various special text objects
  53  */
  54
  55 #ifdef X11
  56 const char *scan_gauge(const char *args, int *w, int *h)
  57 {
  58         /*width and height*/
  59         *w = default_gauge_width;
  60         *h = default_gauge_height;
  61
  62         /* gauge's argument is either height or height,width */
  63         if (args) {
  64                 int n = 0;
  65
  66                 if (sscanf(args, "%d,%d %n", h, w, &n) <= 1) {
  67                         if (sscanf(args, "%d %n", h, &n) == 2) {
  68                                 *w = *h; /*square gauge*/
  69                         }
  70                 }
  71                 args += n;
  72         }
  73
  74         return args;
  75 }
  76
  77 const char *scan_bar(const char *args, int *w, int *h)
  78 {
  79         /* zero width means all space that is available */
  80         *w = default_bar_width;
  81         *h = default_bar_height;
  82         /* bar's argument is either height or height,width */
  83         if (args) {
  84                 int n = 0;
  85
  86                 if (sscanf(args, "%d,%d %n", h, w, &n) <= 1) {
  87                         sscanf(args, "%d %n", h, &n);
  88                 }
  89                 args += n;
  90         }
  91
  92         return args;
  93 }
  94
  95 char *scan_font(const char *args)
  96 {
  97         if (args && *args) {
  98                 return strndup(args, DEFAULT_TEXT_BUFFER_SIZE);
  99         }
 100
 101         return NULL;
 102 }
 103
 104 char *scan_graph(const char *args, int *w, int *h,
 105                  unsigned int *first_colour, unsigned int *last_colour,
 106                  unsigned int *scale, char *showaslog)
 107 {
 108         const char *nographtype;
 109         char buf[64];
 110         buf[0] = 0;
 111
 112         /* zero width means all space that is available */
 113         *w = default_graph_width;
 114         *h = default_graph_height;
 115         *first_colour = 0;
 116         *last_colour = 0;
 117         *scale = 0;
 118         if (args) {
 119                 //set showaslog and place the rest of the args in nographtype
 120                 if(strcasecmp(args, LOGGRAPH) == EQUAL) {
 121                         *showaslog = TRUE;
 122                         return NULL;
 123                 }else if(strcasecmp(args, NORMGRAPH) == EQUAL) {
 124                         *showaslog = FALSE;
 125                         return NULL;
 126                 }else if(strncasecmp(args, LOGGRAPH" ", strlen(LOGGRAPH) + 1 ) == EQUAL) {
 127                         *showaslog = TRUE;
 128                         nographtype = &args[strlen(LOGGRAPH) + 1];
 129                 }else if(strncasecmp(args, NORMGRAPH" ", strlen(NORMGRAPH) + 1 ) == EQUAL) {
 130                         *showaslog = FALSE;
 131                         nographtype = &args[strlen(NORMGRAPH) + 1];
 132                 }else{
 133                         *showaslog = FALSE;
 134                         nographtype = args;
 135                 }
 136                 DBGP("printing graph as %s, other args are: %s", (*showaslog ? "log" : "normal"), nographtype);
 137                 //check the rest of the args
 138                 if (sscanf(nographtype, "%d,%d %x %x %u", h, w, first_colour, last_colour, scale) == 5) {
 139                         return NULL;
 140                 }
 141                 *scale = 0;
 142                 if (sscanf(nographtype, "%d,%d %x %x", h, w, first_colour, last_colour) == 4) {
 143                         return NULL;
 144                 }
 145                 if (sscanf(nographtype, "%63s %d,%d %x %x %u", buf, h, w, first_colour, last_colour, scale) == 6) {
 146                         return strndup(buf, text_buffer_size);
 147                 }
 148                 *scale = 0;
 149                 if (sscanf(nographtype, "%63s %d,%d %x %x", buf, h, w, first_colour, last_colour) == 5) {
 150                         return strndup(buf, text_buffer_size);
 151                 }
 152                 buf[0] = '\0';
 153                 *h = 25;
 154                 *w = 0;
 155                 if (sscanf(nographtype, "%x %x %u", first_colour, last_colour, scale) == 3) {
 156                         return NULL;
 157                 }
 158                 *scale = 0;
 159                 if (sscanf(nographtype, "%x %x", first_colour, last_colour) == 2) {
 160                         return NULL;
 161                 }
 162                 if (sscanf(nographtype, "%63s %x %x %u", buf, first_colour, last_colour, scale) == 4) {
 163                         return strndup(buf, text_buffer_size);
 164                 }
 165                 *scale = 0;
 166                 if (sscanf(nographtype, "%63s %x %x", buf, first_colour, last_colour) == 3) {
 167                         return strndup(buf, text_buffer_size);
 168                 }
 169                 buf[0] = '\0';
 170                 *first_colour = 0;
 171                 *last_colour = 0;
 172                 if (sscanf(nographtype, "%d,%d %u", h, w, scale) == 3) {
 173                         return NULL;
 174                 }
 175                 *scale = 0;
 176                 if (sscanf(nographtype, "%d,%d", h, w) == 2) {
 177                         return NULL;
 178                 }
 179                 if (sscanf(nographtype, "%63s %d,%d %u", buf, h, w, scale) < 4) {
 180                         *scale = 0;
 181                         //TODO: check the return value and throw an error?
 182                         sscanf(nographtype, "%63s %d,%d", buf, h, w);
 183                 }
 184
 185                 return strndup(buf, text_buffer_size);
 186         }
 187
 188         if (buf[0] == '\0') {
 189                 return NULL;
 190         } else {
 191                 return strndup(buf, text_buffer_size);
 192         }
 193 }
 194 #endif
 195
 196 /*
 197  * Printing various special text objects
 198  */
 199
 200 static struct special_t *new_special(char *buf, enum special_types t)
 201 {
 202         if (special_count >= max_specials) {
 203                 CRIT_ERR("too many special things in text");
 204         }
 205
 206         buf[0] = SPECIAL_CHAR;
 207         buf[1] = '\0';
 208         specials[special_count].type = t;
 209         return &specials[special_count++];
 210 }
 211
 212 #ifdef X11
 213 void new_gauge(char *buf, int w, int h, int usage)
 214 {
 215         struct special_t *s = 0;
 216         if ((output_methods & TO_X) == 0)
 217                 return;
 218
 219         s = new_special(buf, GAUGE);
 220
 221         s->arg = (usage > 255) ? 255 : ((usage < 0) ? 0 : usage);
 222         s->width = w;
 223         s->height = h;
 224 }
 225
 226 void new_bar(char *buf, int w, int h, int usage)
 227 {
 228         struct special_t *s = 0;
 229
 230         if ((output_methods & TO_X) == 0)
 231                 return;
 232
 233         s = new_special(buf, BAR);
 234
 235         s->arg = (usage > 255) ? 255 : ((usage < 0) ? 0 : usage);
 236         s->width = w;
 237         s->height = h;
 238 }
 239
 240 void new_font(char *buf, char *args)
 241 {
 242         if ((output_methods & TO_X) == 0)
 243                 return;
 244
 245         if (args) {
 246                 struct special_t *s = new_special(buf, FONT);
 247
 248                 if (s->font_added > font_count || !s->font_added || (strncmp(args, fonts[s->font_added].name, DEFAULT_TEXT_BUFFER_SIZE) != EQUAL) ) {
 249                         int tmp = selected_font;
 250
 251                         selected_font = s->font_added = addfont(args);
 252                         load_fonts();
 253                         selected_font = tmp;
 254                 }
 255         } else {
 256                 struct special_t *s = new_special(buf, FONT);
 257                 int tmp = selected_font;
 258
 259                 selected_font = s->font_added = 0;
 260                 selected_font = tmp;
 261         }
 262 }
 263
 264 static void graph_append(struct special_t *graph, double f, char showaslog)
 265 {
 266         int i;
 267
 268         if (showaslog) {
 269 #ifdef MATH
 270                 f = log10(f + 1);
 271 #endif
 272         }
 273
 274         if (!graph->scaled && f > graph->graph_scale) {
 275                 f = graph->graph_scale;
 276         }
 277
 278 /* Already happens in new_graph
 279         if (graph->scaled) {
 280                 graph->graph_scale = 1;
 281         }
 282 */
 283         graph->graph[0] = f;    /* add new data */
 284         /* shift all the data by 1 */
 285         for (i = graph->graph_width - 1; i > 0; i--) {
 286                 graph->graph[i] = graph->graph[i - 1];
 287                 if (graph->scaled && graph->graph[i] > graph->graph_scale) {
 288                         /* check if we need to update the scale */
 289                         graph->graph_scale = graph->graph[i];
 290                 }
 291         }
 292 }
 293
 294 void new_graph(char *buf, int w, int h, unsigned int first_colour,
 295                 unsigned int second_colour, double i, int scale, int append, char showaslog)
 296 {
 297         struct special_t *s = 0;
 298
 299         if ((output_methods & TO_X) == 0)
 300                 return;
 301
 302         s = new_special(buf, GRAPH);
 303
 304         s->width = w;
 305         if (s->graph == NULL) {
 306                 if (s->width > 0 && s->width < MAX_GRAPH_DEPTH) {
 307                         // subtract 2 for the box
 308                         s->graph_width = s->width /* - 2 */;
 309                 } else {
 310                         s->graph_width = MAX_GRAPH_DEPTH - 2;
 311                 }
 312                 s->graph = malloc(s->graph_width * sizeof(double));
 313                 memset(s->graph, 0, s->graph_width * sizeof(double));
 314                 s->graph_scale = 100;
 315         }
 316         s->height = h;
 317         s->first_colour = adjust_colors(first_colour);
 318         s->last_colour = adjust_colors(second_colour);
 319         if (scale != 0) {
 320                 s->scaled = 0;
 321                 s->graph_scale = scale;
 322                 s->show_scale = 0;
 323         } else {
 324                 s->scaled = 1;
 325                 s->graph_scale = 1;
 326                 s->show_scale = 1;
 327         }
 328         /* if (s->width) {
 329                 s->graph_width = s->width - 2;  // subtract 2 for rectangle around
 330         } */
 331         if (showaslog) {
 332 #ifdef MATH
 333                 s->graph_scale = log10(s->graph_scale + 1);
 334 #endif
 335         }
 336         if (append) {
 337                 graph_append(s, i, showaslog);
 338         }
 339 }
 340
 341 void new_hr(char *buf, int a)
 342 {
 343         if ((output_methods & TO_X) == 0)
 344                 return;
 345
 346         new_special(buf, HORIZONTAL_LINE)->height = a;
 347 }
 348
 349 void new_stippled_hr(char *buf, int a, int b)
 350 {
 351         struct special_t *s = 0;
 352
 353         if ((output_methods & TO_X) == 0)
 354                 return;
 355
 356         s = new_special(buf, STIPPLED_HR);
 357
 358         s->height = b;
 359         s->arg = a;
 360 }
 361
 362 void new_fg(char *buf, long c)
 363 {
 364         if ((output_methods & TO_X) == 0)
 365                 return;
 366
 367         new_special(buf, FG)->arg = c;
 368 }
 369
 370 void new_bg(char *buf, long c)
 371 {
 372         if ((output_methods & TO_X) == 0)
 373                 return;
 374
 375         new_special(buf, BG)->arg = c;
 376 }
 377 #endif
 378
 379 void new_outline(char *buf, long c)
 380 {
 381         new_special(buf, OUTLINE)->arg = c;
 382 }
 383
 384 void new_offset(char *buf, long c)
 385 {
 386         new_special(buf, OFFSET)->arg = c;
 387 }
 388
 389 void new_voffset(char *buf, long c)
 390 {
 391         new_special(buf, VOFFSET)->arg = c;
 392 }
 393
 394 void new_alignr(char *buf, long c)
 395 {
 396         new_special(buf, ALIGNR)->arg = c;
 397 }
 398
 399 // A postive offset pushes the text further left
 400 void new_alignc(char *buf, long c)
 401 {
 402         new_special(buf, ALIGNC)->arg = c;
 403 }
 404
 405 void new_goto(char *buf, long c)
 406 {
 407         new_special(buf, GOTO)->arg = c;
 408 }
 409
 410 void new_tab(char *buf, int a, int b)
 411 {
 412         struct special_t *s = new_special(buf, TAB);
 413
 414         s->width = a;
 415         s->arg = b;
 416 }
 417