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

   1 /* -*- mode: c; c-basic-offset: 4; tab-width: 4; indent-tabs-mode: t -*-
   2  *
   3  * Conky, a system monitor, based on torsmo
   4  *
   5  * Please see COPYING for details
   6  *
   7  * Copyright (c) 2005-2009 Brenden Matthews, et. al.
   8  * All rights reserved.
   9  *
  10  * This program is free software: you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation, either version 3 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  21  *
  22  * vim: ts=4 sw=4 noet ai cindent syntax=c
  23  *
  24  */
  25
  26 #include "config.h"
  27 #include "imlib2.h"
  28 #include "conky.h"
  29 #include "logging.h"
  30
  31 #include <Imlib2.h>
  32 #include <stdio.h>
  33 #include <stdlib.h>
  34 #include <limits.h>
  35 #include <string.h>
  36 #include <time.h>
  37
  38 struct image_list_s {
  39         char name[1024];
  40         Imlib_Image image;
  41         int x, y, w, h;
  42         int wh_set;
  43         char no_cache;
  44         int flush_interval;
  45         struct image_list_s *next;
  46 };
  47
  48 struct image_list_s *image_list_start, *image_list_end;
  49
  50 /* areas to update */
  51 Imlib_Updates updates, current_update;
  52 /* our virtual framebuffer image we draw into */
  53 Imlib_Image buffer, image;
  54
  55 static int cache_size_set = 0;
  56
  57 /* flush the image cache ever X seconds */
  58 static int cimlib_cache_flush_interval = 0;
  59 static int cimlib_cache_flush_last = 0;
  60
  61 #define DEFAULT_IMLIB2_CACHE_SIZE 4096 * 1024 /* default cache size for loaded images */
  62
  63 void cimlib_set_cache_size(long size)
  64 {
  65         imlib_set_cache_size(size);
  66         cache_size_set = 1;
  67 }
  68
  69 void cimlib_set_cache_flush_interval(long interval)
  70 {
  71         if (interval >= 0) {
  72                 cimlib_cache_flush_interval = interval;
  73         } else {
  74                 NORM_ERR("Imlib2: flush interval should be >= 0");
  75         }
  76 }
  77
  78 void cimlib_cleanup(void)
  79 {
  80         struct image_list_s *cur = image_list_start, *last = NULL;
  81         while (cur) {
  82                 last = cur;
  83                 cur = last->next;
  84                 free(last);
  85         }
  86         image_list_start = image_list_end = NULL;
  87 }
  88
  89 Imlib_Context context;
  90
  91 void cimlib_init(Display *disp, Window drawable, Visual *visual, Colormap
  92                 colourmap)
  93 {
  94         image_list_start = image_list_end = NULL;
  95         context = imlib_context_new();
  96         imlib_context_push(context);
  97         if (!cache_size_set) cimlib_set_cache_size(DEFAULT_IMLIB2_CACHE_SIZE);
  98         /* set the maximum number of colors to allocate for 8bpp and less to 256 */
  99         imlib_set_color_usage(256);
 100         /* dither for depths < 24bpp */
 101         imlib_context_set_dither(1);
 102         /* set the display , visual, colormap and drawable we are using */
 103         imlib_context_set_display(disp);
 104         imlib_context_set_visual(visual);
 105         imlib_context_set_colormap(colourmap);
 106         imlib_context_set_drawable(drawable);
 107 }
 108
 109 void cimlib_deinit(void)
 110 {
 111         cimlib_cleanup();
 112         cache_size_set = 0;
 113         imlib_context_disconnect_display();
 114         imlib_context_pop();
 115         imlib_context_free(context);
 116 }
 117
 118 void cimlib_add_image(const char *args)
 119 {
 120         struct image_list_s *cur = NULL;
 121         char *tmp;
 122
 123         cur = malloc(sizeof(struct image_list_s));
 124         memset(cur, 0, sizeof(struct image_list_s));
 125
 126         if (!sscanf(args, "%1023s", cur->name)) {
 127                 NORM_ERR("Invalid args for $image.  Format is: '<path to image> (-p"
 128                                 "x,y) (-s WxH) (-n) (-f interval)' (got '%s')", args);
 129                 free(cur);
 130                 return;
 131         }
 132         to_real_path(cur->name, cur->name);
 133         // now we check for optional args
 134         tmp = strstr(args, "-p ");
 135         if (tmp) {
 136                 tmp += 3;
 137                 sscanf(tmp, "%i,%i", &cur->x, &cur->y);
 138         }
 139         tmp = strstr(args, "-s ");
 140         if (tmp) {
 141                 tmp += 3;
 142                 if (sscanf(tmp, "%ix%i", &cur->w, &cur->h)) {
 143                         cur->wh_set = 1;
 144                 }
 145         }
 146
 147         tmp = strstr(args, "-n");
 148         if (tmp) {
 149                 cur->no_cache = 1;
 150         }
 151
 152         tmp = strstr(args, "-f ");
 153         if (tmp) {
 154                 tmp += 3;
 155                 if (sscanf(tmp, "%d", &cur->flush_interval)) {
 156                         cur->no_cache = 0;
 157                 }
 158         }
 159         if (cur->flush_interval < 0) {
 160                 NORM_ERR("Imlib2: flush interval should be >= 0");
 161                 cur->flush_interval = 0;
 162         }
 163
 164         if (image_list_end) {
 165                 image_list_end->next = cur;
 166                 image_list_end = cur;
 167         } else {
 168                 image_list_start = image_list_end = cur;
 169         }
 170 }
 171
 172 static void cimlib_draw_image(struct image_list_s *cur, int *clip_x, int
 173                 *clip_y, int *clip_x2, int *clip_y2)
 174 {
 175         int w, h;
 176         time_t now = time(NULL);
 177
 178         image = imlib_load_image(cur->name);
 179         if (!image) {
 180                 NORM_ERR("Unable to load image '%s'", cur->name);
 181                 return;
 182         }
 183
 184         DBGP("Drawing image '%s' at (%i,%i) scaled to %ix%i, "
 185              "caching interval set to %i (with -n opt %i)",
 186              cur->name, cur->x, cur->y, cur->w, cur->h,
 187              cur->flush_interval, cur->no_cache);
 188
 189         imlib_context_set_image(image);
 190         /* turn alpha channel on */
 191         imlib_image_set_has_alpha(1);
 192         w = imlib_image_get_width();
 193         h = imlib_image_get_height();
 194         if (!cur->wh_set) {
 195                 cur->w = w;
 196                 cur->h = h;
 197         }
 198         imlib_context_set_image(buffer);
 199         imlib_blend_image_onto_image(image, 1, 0, 0, w, h,
 200                         cur->x, cur->y, cur->w, cur->h);
 201         imlib_context_set_image(image);
 202         if (cur->no_cache || (cur->flush_interval &&
 203                               now % cur->flush_interval == 0)) {
 204                 imlib_free_image_and_decache();
 205         } else {
 206                 imlib_free_image();
 207         }
 208         if (cur->x < *clip_x) *clip_x = cur->x;
 209         if (cur->y < *clip_y) *clip_y = cur->y;
 210         if (cur->x + cur->w > *clip_x2) *clip_x2 = cur->x + cur->w;
 211         if (cur->y + cur->h > *clip_y2) *clip_y2 = cur->y + cur->h;
 212 }
 213
 214 static void cimlib_draw_all(int *clip_x, int *clip_y, int *clip_x2, int *clip_y2)
 215 {
 216         struct image_list_s *cur = image_list_start;
 217         while (cur) {
 218                 cimlib_draw_image(cur, clip_x, clip_y, clip_x2, clip_y2);
 219                 cur = cur->next;
 220         }
 221 }
 222
 223 void cimlib_render(int x, int y, int width, int height)
 224 {
 225         int clip_x = INT_MAX, clip_y = INT_MAX;
 226         int clip_x2 = 0, clip_y2 = 0;
 227         time_t now;
 228
 229         if (!image_list_start) return; /* are we actually drawing anything? */
 230
 231         /* cheque if it's time to flush our cache */
 232         now = time(NULL);
 233         if (cimlib_cache_flush_interval && now - cimlib_cache_flush_interval > cimlib_cache_flush_last) {
 234                 int size = imlib_get_cache_size();
 235                 imlib_set_cache_size(0);
 236                 imlib_set_cache_size(size);
 237                 cimlib_cache_flush_last = now;
 238                 DBGP("Flushing Imlib2 cache (%li)\n", now);
 239         }
 240
 241         /* take all the little rectangles to redraw and merge them into
 242          * something sane for rendering */
 243         buffer = imlib_create_image(width, height);
 244         /* clear our buffer */
 245         imlib_context_set_image(buffer);
 246         imlib_image_clear();
 247         /* we can blend stuff now */
 248         imlib_context_set_blend(1);
 249         /* turn alpha channel on */
 250         imlib_image_set_has_alpha(1);
 251
 252         cimlib_draw_all(&clip_x, &clip_y, &clip_x2, &clip_y2);
 253
 254         /* set the buffer image as our current image */
 255         imlib_context_set_image(buffer);
 256
 257         /* setup our clip rect */
 258         if (clip_x == INT_MAX) clip_x = 0;
 259         if (clip_y == INT_MAX) clip_y = 0;
 260
 261         /* render the image at 0, 0 */
 262         imlib_render_image_part_on_drawable_at_size(clip_x, clip_y, clip_x2 - clip_x,
 263                         clip_y2 - clip_y, x + clip_x, y + clip_y, clip_x2 - clip_x,
 264                         clip_y2 - clip_y);
 265         /* don't need that temporary buffer image anymore */
 266         imlib_free_image();
 267 }
 268