| | 1 | #define _GNU_SOURCE |
| | 2 | |
| | 3 | #include "../gdk_imlib/gdk_imlib.h" |
| | 4 | #include "../gdk_imlib/gdk_imlib_private.h" |
| | 5 | |
| | 6 | void |
| | 7 | gcalc_map_tables(GdkImlibImage * im) |
| | 8 | { |
| | 9 | int i; |
| | 10 | double g, b, c, ii, v; |
| | 11 | |
| | 12 | if (!im) |
| | 13 | return; |
| | 14 | |
| | 15 | g = ((double)im->mod.gamma) / 256; |
| | 16 | b = ((double)im->mod.brightness) / 256; |
| | 17 | c = ((double)im->mod.contrast) / 256; |
| | 18 | if (g < 0.01) |
| | 19 | g = 0.01; |
| | 20 | |
| | 21 | for (i = 0; i < 256; i++) |
| | 22 | { |
| | 23 | ii = ((double)i) / 256; |
| | 24 | v = ((ii - 0.5) * c) + 0.5 + (b - 1); |
| | 25 | if (v > 0) |
| | 26 | v = pow(((ii - 0.5) * c) + 0.5 + (b - 1), 1 / g) * 256; |
| | 27 | else |
| | 28 | v = 0; |
| | 29 | if (v > 255) |
| | 30 | v = 255; |
| | 31 | else if (v < 0) |
| | 32 | v = 0; |
| | 33 | im->rmap[i] = (unsigned char)v; |
| | 34 | im->gmap[i] = (unsigned char)v; |
| | 35 | im->bmap[i] = (unsigned char)v; |
| | 36 | } |
| | 37 | g = ((double)im->rmod.gamma) / 256; |
| | 38 | b = ((double)im->rmod.brightness) / 256; |
| | 39 | c = ((double)im->rmod.contrast) / 256; |
| | 40 | if (g < 0.01) |
| | 41 | g = 0.01; |
| | 42 | |
| | 43 | for (i = 0; i < 256; i++) |
| | 44 | { |
| | 45 | ii = ((double)im->rmap[i]) / 256; |
| | 46 | v = ((ii - 0.5) * c) + 0.5 + (b - 1); |
| | 47 | if (v > 0) |
| | 48 | v = pow(((ii - 0.5) * c) + 0.5 + (b - 1), 1 / g) * 256; |
| | 49 | else |
| | 50 | v = 0; |
| | 51 | if (v > 255) |
| | 52 | v = 255; |
| | 53 | else if (v < 0) |
| | 54 | v = 0; |
| | 55 | im->rmap[i] = (unsigned char)v; |
| | 56 | } |
| | 57 | g = ((double)im->gmod.gamma) / 256; |
| | 58 | b = ((double)im->gmod.brightness) / 256; |
| | 59 | c = ((double)im->gmod.contrast) / 256; |
| | 60 | if (g < 0.01) |
| | 61 | g = 0.01; |
| | 62 | |
| | 63 | for (i = 0; i < 256; i++) |
| | 64 | { |
| | 65 | ii = ((double)im->gmap[i]) / 256; |
| | 66 | v = ((ii - 0.5) * c) + 0.5 + (b - 1); |
| | 67 | if (v > 0) |
| | 68 | v = pow(((ii - 0.5) * c) + 0.5 + (b - 1), 1 / g) * 256; |
| | 69 | else |
| | 70 | v = 0; |
| | 71 | if (v > 255) |
| | 72 | v = 255; |
| | 73 | else if (v < 0) |
| | 74 | v = 0; |
| | 75 | im->gmap[i] = (unsigned char)v; |
| | 76 | } |
| | 77 | g = ((double)im->bmod.gamma) / 256; |
| | 78 | b = ((double)im->bmod.brightness) / 256; |
| | 79 | c = ((double)im->bmod.contrast) / 256; |
| | 80 | if (g < 0.01) |
| | 81 | g = 0.01; |
| | 82 | for (i = 0; i < 256; i++) |
| | 83 | { |
| | 84 | ii = ((double)im->bmap[i]) / 256; |
| | 85 | v = ((ii - 0.5) * c) + 0.5 + (b - 1); |
| | 86 | if (v > 0) |
| | 87 | v = pow(((ii - 0.5) * c) + 0.5 + (b - 1), 1 / g) * 256; |
| | 88 | else |
| | 89 | v = 0; |
| | 90 | if (v > 255) |
| | 91 | v = 255; |
| | 92 | else if (v < 0) |
| | 93 | v = 0; |
| | 94 | im->bmap[i] = (unsigned char)v; |
| | 95 | } |
| | 96 | gdirty_pixmaps(im); |
| | 97 | } |
| | 98 | |
| | 99 | gint |
| | 100 | gdk_imlib_load_file_to_pixmap(char *filename, GdkPixmap ** pmap, GdkBitmap ** mask) |
| | 101 | { |
| | 102 | GdkImlibImage *im; |
| | 103 | |
| | 104 | im = gdk_imlib_load_image(filename); |
| | 105 | if (!im) |
| | 106 | { |
| | 107 | if (pmap) |
| | 108 | *pmap = NULL; |
| | 109 | if (mask) |
| | 110 | *mask = NULL; |
| | 111 | return 0; |
| | 112 | } |
| | 113 | if (!gdk_imlib_render(im, im->rgb_width, im->rgb_height)) |
| | 114 | { |
| | 115 | gdk_imlib_destroy_image(im); |
| | 116 | if (pmap) |
| | 117 | *pmap = NULL; |
| | 118 | if (mask) |
| | 119 | *mask = NULL; |
| | 120 | return 0; |
| | 121 | } |
| | 122 | if (pmap) |
| | 123 | *pmap = gdk_imlib_move_image(im); |
| | 124 | if (mask) |
| | 125 | *mask = gdk_imlib_move_mask(im); |
| | 126 | gdk_imlib_destroy_image(im); |
| | 127 | return 1; |
| | 128 | } |
| | 129 | |
| | 130 | void |
| | 131 | gdk_imlib_set_image_modifier(GdkImlibImage * im, GdkImlibColorModifier * mod) |
| | 132 | { |
| | 133 | if (!im || !mod) |
| | 134 | return; |
| | 135 | im->mod.gamma = mod->gamma; |
| | 136 | im->mod.brightness = mod->brightness; |
| | 137 | im->mod.contrast = mod->contrast; |
| | 138 | gcalc_map_tables(im); |
| | 139 | } |
| | 140 | |
| | 141 | void |
| | 142 | gdk_imlib_set_image_red_modifier(GdkImlibImage * im, GdkImlibColorModifier * mod) |
| | 143 | { |
| | 144 | if (!im || !mod) |
| | 145 | return; |
| | 146 | im->rmod.gamma = mod->gamma; |
| | 147 | im->rmod.brightness = mod->brightness; |
| | 148 | im->rmod.contrast = mod->contrast; |
| | 149 | gcalc_map_tables(im); |
| | 150 | } |
| | 151 | |
| | 152 | void |
| | 153 | gdk_imlib_set_image_green_modifier(GdkImlibImage * im, GdkImlibColorModifier * mod) |
| | 154 | { |
| | 155 | if (!im || !mod) |
| | 156 | return; |
| | 157 | im->gmod.gamma = mod->gamma; |
| | 158 | im->gmod.brightness = mod->brightness; |
| | 159 | im->gmod.contrast = mod->contrast; |
| | 160 | gcalc_map_tables(im); |
| | 161 | } |
| | 162 | |
| | 163 | void |
| | 164 | gdk_imlib_set_image_blue_modifier(GdkImlibImage * im, GdkImlibColorModifier * mod) |
| | 165 | { |
| | 166 | if (!im | !mod) |
| | 167 | return; |
| | 168 | im->bmod.gamma = mod->gamma; |
| | 169 | im->bmod.brightness = mod->brightness; |
| | 170 | im->bmod.contrast = mod->contrast; |
| | 171 | gcalc_map_tables(im); |
| | 172 | } |
| | 173 | |
| | 174 | void |
| | 175 | gdk_imlib_get_image_modifier(GdkImlibImage * im, GdkImlibColorModifier * mod) |
| | 176 | { |
| | 177 | if (!im || !mod) |
| | 178 | return; |
| | 179 | mod->gamma = im->mod.gamma; |
| | 180 | mod->brightness = im->mod.brightness; |
| | 181 | mod->contrast = im->mod.contrast; |
| | 182 | gcalc_map_tables(im); |
| | 183 | } |
| | 184 | |
| | 185 | void |
| | 186 | gdk_imlib_get_image_red_modifier(GdkImlibImage * im, GdkImlibColorModifier * mod) |
| | 187 | { |
| | 188 | if (!im || !mod) |
| | 189 | return; |
| | 190 | mod->gamma = im->rmod.gamma; |
| | 191 | mod->brightness = im->rmod.brightness; |
| | 192 | mod->contrast = im->rmod.contrast; |
| | 193 | } |
| | 194 | |
| | 195 | void |
| | 196 | gdk_imlib_get_image_green_modifier(GdkImlibImage * im, GdkImlibColorModifier * mod) |
| | 197 | { |
| | 198 | if (!im || !mod) |
| | 199 | return; |
| | 200 | mod->gamma = im->gmod.gamma; |
| | 201 | mod->brightness = im->gmod.brightness; |
| | 202 | mod->contrast = im->gmod.contrast; |
| | 203 | } |
| | 204 | |
| | 205 | void |
| | 206 | gdk_imlib_get_image_blue_modifier(GdkImlibImage * im, GdkImlibColorModifier * mod) |
| | 207 | { |
| | 208 | if (!im || !mod) |
| | 209 | return; |
| | 210 | mod->gamma = im->bmod.gamma; |
| | 211 | mod->brightness = im->bmod.brightness; |
| | 212 | mod->contrast = im->bmod.contrast; |
| | 213 | } |
| | 214 | |
| | 215 | void |
| | 216 | gdk_imlib_set_image_red_curve(GdkImlibImage * im, unsigned char *mod) |
| | 217 | { |
| | 218 | int i; |
| | 219 | |
| | 220 | if (!im || !mod) |
| | 221 | return; |
| | 222 | for (i = 0; i < 256; i++) |
| | 223 | im->rmap[i] = mod[i]; |
| | 224 | gdirty_pixmaps(im); |
| | 225 | im->mod.contrast = 257; |
| | 226 | } |
| | 227 | |
| | 228 | void |
| | 229 | gdk_imlib_set_image_green_curve(GdkImlibImage * im, unsigned char *mod) |
| | 230 | { |
| | 231 | int i; |
| | 232 | |
| | 233 | if (!im || !mod) |
| | 234 | return; |
| | 235 | for (i = 0; i < 256; i++) |
| | 236 | im->gmap[i] = mod[i]; |
| | 237 | gdirty_pixmaps(im); |
| | 238 | im->mod.contrast = 257; |
| | 239 | } |
| | 240 | |
| | 241 | void |
| | 242 | gdk_imlib_set_image_blue_curve(GdkImlibImage * im, unsigned char *mod) |
| | 243 | { |
| | 244 | int i; |
| | 245 | |
| | 246 | if (!im || !mod) |
| | 247 | return; |
| | 248 | for (i = 0; i < 256; i++) |
| | 249 | im->bmap[i] = mod[i]; |
| | 250 | gdirty_pixmaps(im); |
| | 251 | im->mod.contrast = 257; |
| | 252 | } |
| | 253 | |
| | 254 | void |
| | 255 | gdk_imlib_get_image_red_curve(GdkImlibImage * im, unsigned char *mod) |
| | 256 | { |
| | 257 | int i; |
| | 258 | |
| | 259 | if ((!im) || (!mod)) |
| | 260 | return; |
| | 261 | for (i = 0; i < 256; i++) |
| | 262 | mod[i] = im->rmap[i]; |
| | 263 | } |
| | 264 | |
| | 265 | void |
| | 266 | gdk_imlib_get_image_green_curve(GdkImlibImage * im, unsigned char *mod) |
| | 267 | { |
| | 268 | int i; |
| | 269 | |
| | 270 | if (!im || !mod) |
| | 271 | return; |
| | 272 | for (i = 0; i < 256; i++) |
| | 273 | mod[i] = im->gmap[i]; |
| | 274 | } |
| | 275 | |
| | 276 | void |
| | 277 | gdk_imlib_get_image_blue_curve(GdkImlibImage * im, unsigned char *mod) |
| | 278 | { |
| | 279 | int i; |
| | 280 | |
| | 281 | if (!im || !mod) |
| | 282 | return; |
| | 283 | for (i = 0; i < 256; i++) |
| | 284 | mod[i] = im->bmap[i]; |
| | 285 | } |
| | 286 | |
| | 287 | void |
| | 288 | gdk_imlib_apply_modifiers_to_rgb(GdkImlibImage * im) |
| | 289 | { |
| | 290 | int x, y; |
| | 291 | unsigned char *ptr; |
| | 292 | |
| | 293 | if (!im) |
| | 294 | return; |
| | 295 | ptr = im->rgb_data; |
| | 296 | for (y = 0; y < im->rgb_height; y++) |
| | 297 | { |
| | 298 | for (x = 0; x < im->rgb_width; x++) |
| | 299 | { |
| | 300 | *ptr = im->rmap[*ptr]; |
| | 301 | ptr++; |
| | 302 | *ptr = im->gmap[*ptr]; |
| | 303 | ptr++; |
| | 304 | *ptr = im->bmap[*ptr]; |
| | 305 | ptr++; |
| | 306 | } |
| | 307 | } |
| | 308 | im->mod.gamma = 256; |
| | 309 | im->mod.brightness = 256; |
| | 310 | im->mod.contrast = 256; |
| | 311 | im->rmod.gamma = 256; |
| | 312 | im->rmod.brightness = 256; |
| | 313 | im->rmod.contrast = 256; |
| | 314 | im->gmod.gamma = 256; |
| | 315 | im->gmod.brightness = 256; |
| | 316 | im->gmod.contrast = 256; |
| | 317 | im->bmod.gamma = 256; |
| | 318 | im->bmod.brightness = 256; |
| | 319 | im->bmod.contrast = 256; |
| | 320 | gcalc_map_tables(im); |
| | 321 | gdirty_images(im); |
| | 322 | gdirty_pixmaps(im); |
| | 323 | } |
| | 324 | |
| | 325 | void |
| | 326 | gdk_imlib_crop_image(GdkImlibImage * im, gint x, gint y, gint w, gint h) |
| | 327 | { |
| | 328 | unsigned char *data; |
| | 329 | int xx, yy, w3, w4; |
| | 330 | unsigned char *ptr1, *ptr2; |
| | 331 | |
| | 332 | if (!im) |
| | 333 | return; |
| | 334 | if (x < 0) |
| | 335 | { |
| | 336 | w += x; |
| | 337 | x = 0; |
| | 338 | } |
| | 339 | if (y < 0) |
| | 340 | { |
| | 341 | h += y; |
| | 342 | y = 0; |
| | 343 | } |
| | 344 | if (x >= im->rgb_width) |
| | 345 | return; |
| | 346 | if (y >= im->rgb_height) |
| | 347 | return; |
| | 348 | if (w <= 0) |
| | 349 | return; |
| | 350 | if (h <= 0) |
| | 351 | return; |
| | 352 | if (x + w > im->rgb_width) |
| | 353 | w = im->rgb_width - x; |
| | 354 | if (y + h > im->rgb_height) |
| | 355 | h = im->rgb_height - y; |
| | 356 | if (w <= 0) |
| | 357 | return; |
| | 358 | if (h <= 0) |
| | 359 | return; |
| | 360 | |
| | 361 | w3 = im->rgb_width * 3; |
| | 362 | w4 = (im->rgb_width - w) * 3; |
| | 363 | data = malloc(w * h * 3); |
| | 364 | if (data == NULL) |
| | 365 | return; |
| | 366 | ptr1 = im->rgb_data + (y * w3) + (x * 3); |
| | 367 | ptr2 = data; |
| | 368 | for (yy = 0; yy < h; yy++) |
| | 369 | { |
| | 370 | for (xx = 0; xx < w; xx++) |
| | 371 | { |
| | 372 | *ptr2++ = *ptr1++; |
| | 373 | *ptr2++ = *ptr1++; |
| | 374 | *ptr2++ = *ptr1++; |
| | 375 | } |
| | 376 | ptr1 += w4; |
| | 377 | } |
| | 378 | free(im->rgb_data); |
| | 379 | im->rgb_data = data; |
| | 380 | if (im->border.left > x) |
| | 381 | im->border.left = im->border.left - x; |
| | 382 | else |
| | 383 | im->border.left = 0; |
| | 384 | if (im->border.top > y) |
| | 385 | im->border.top = im->border.top - y; |
| | 386 | else |
| | 387 | im->border.top = 0; |
| | 388 | if (im->rgb_width - im->border.right < x + w) |
| | 389 | im->border.right = im->border.right - (im->rgb_width - (x + w)); |
| | 390 | else |
| | 391 | im->border.right = 0; |
| | 392 | if (im->rgb_height - im->border.bottom < y + h) |
| | 393 | im->border.bottom = im->border.bottom - (im->rgb_height - (y + h)); |
| | 394 | else |
| | 395 | im->border.bottom = 0; |
| | 396 | im->rgb_width = w; |
| | 397 | im->rgb_height = h; |
| | 398 | gdirty_images(im); |
| | 399 | gdirty_pixmaps(im); |
| | 400 | } |
| | 401 | |
| | 402 | void |
| | 403 | gdk_imlib_changed_image(GdkImlibImage * im) |
| | 404 | { |
| | 405 | if (!im) |
| | 406 | return; |
| | 407 | gdirty_images(im); |
| | 408 | gdirty_pixmaps(im); |
| | 409 | } |
| | 410 | |
| | 411 | void |
| | 412 | gdk_imlib_apply_image(GdkImlibImage * im, GdkWindow * p) |
| | 413 | { |
| | 414 | GdkPixmap *pp, *mm; |
| | 415 | int w, h; |
| | 416 | |
| | 417 | if (!im || !p) |
| | 418 | return; |
| | 419 | gdk_window_get_size(p, &w, &h); |
| | 420 | if (w <= 0 || h <= 0) |
| | 421 | return; |
| | 422 | gdk_imlib_render(im, w, h); |
| | 423 | pp = gdk_imlib_move_image(im); |
| | 424 | mm = gdk_imlib_move_mask(im); |
| | 425 | gdk_window_set_back_pixmap(p, pp, 0); |
| | 426 | if (mm) |
| | 427 | gdk_window_shape_combine_mask(p, mm, 0, 0); |
| | 428 | gdk_window_clear(p); |
| | 429 | gdk_imlib_free_pixmap(pp); |
| | 430 | } |
| | 431 | |
| | 432 | void |
| | 433 | gdk_imlib_paste_image(GdkImlibImage * im, GdkWindow * p, gint x, gint y, gint w, gint h) |
| | 434 | { |
| | 435 | GdkGC *gc; |
| | 436 | GdkPixmap *pp, *mm; |
| | 437 | |
| | 438 | if (!im || !p) |
| | 439 | return; |
| | 440 | if ((w <= 0) || (h <= 0)) |
| | 441 | return; |
| | 442 | gc = gdk_gc_new(p); |
| | 443 | gdk_imlib_render(im, w, h); |
| | 444 | pp = gdk_imlib_move_image(im); |
| | 445 | mm = gdk_imlib_move_mask(im); |
| | 446 | if (mm) |
| | 447 | { |
| | 448 | gdk_gc_set_clip_mask(gc, mm); |
| | 449 | gdk_gc_set_clip_origin(gc, x, y); |
| | 450 | } |
| | 451 | gdk_draw_pixmap(p, gc, pp, 0, 0, x, y, w, h); |
| | 452 | gdk_imlib_free_pixmap(pp); |
| | 453 | gdk_gc_destroy(gc); |
| | 454 | } |
| | 455 | |
| | 456 | void |
| | 457 | gdk_imlib_paste_image_border(GdkImlibImage * im, GdkWindow * p, gint x, gint y, gint w, gint h) |
| | 458 | { |
| | 459 | GdkGC *gc; |
| | 460 | GdkPixmap *pp, *mm; |
| | 461 | |
| | 462 | if (!im) |
| | 463 | return; |
| | 464 | |
| | 465 | if (w <= 0 || h <= 0) |
| | 466 | return; |
| | 467 | gc = gdk_gc_new(p); |
| | 468 | gdk_imlib_render(im, w, h); |
| | 469 | pp = gdk_imlib_move_image(im); |
| | 470 | mm = gdk_imlib_move_mask(im); |
| | 471 | if (mm) |
| | 472 | { |
| | 473 | gdk_gc_set_clip_mask(gc, mm); |
| | 474 | gdk_gc_set_clip_origin(gc, x, y); |
| | 475 | } |
| | 476 | if ((w <= (im->border.left + im->border.right)) || |
| | 477 | (h <= (im->border.top + im->border.bottom))) |
| | 478 | gdk_draw_pixmap(p, gc, pp, 0, 0, x, y, w, h); |
| | 479 | else |
| | 480 | { |
| | 481 | gdk_draw_pixmap(p, gc, pp, 0, 0, x, y, w, im->border.top); |
| | 482 | gdk_draw_pixmap(p, gc, pp, 0, h - im->border.bottom, |
| | 483 | x, y + (h - im->border.bottom), |
| | 484 | w, im->border.bottom); |
| | 485 | gdk_draw_pixmap(p, gc, pp, 0, im->border.top, |
| | 486 | x, y + im->border.top, |
| | 487 | im->border.left, h - (im->border.top + im->border.bottom)); |
| | 488 | gdk_draw_pixmap(p, gc, pp, w - im->border.right, h - im->border.bottom, |
| | 489 | x + (w - im->border.right), y + (h - im->border.bottom), |
| | 490 | im->border.right, h - (im->border.top + im->border.bottom)); |
| | 491 | } |
| | 492 | gdk_imlib_free_pixmap(pp); |
| | 493 | gdk_gc_destroy(gc); |
| | 494 | } |
| | 495 | |
| | 496 | void |
| | 497 | gdk_imlib_flip_image_horizontal(GdkImlibImage * im) |
| | 498 | { |
| | 499 | unsigned char *ptr1, *ptr2, r, rr; |
| | 500 | int x, y; |
| | 501 | int w3; |
| | 502 | |
| | 503 | if (!im) |
| | 504 | return; |
| | 505 | w3 = im->rgb_width * 3; |
| | 506 | for (y = 0; y < im->rgb_height; y++) |
| | 507 | { |
| | 508 | ptr1 = im->rgb_data + (y * w3); |
| | 509 | ptr2 = im->rgb_data + (y * w3) + w3 - 3; |
| | 510 | for (x = 0; x < im->rgb_width >> 1; x++) |
| | 511 | { |
| | 512 | r = *ptr1; |
| | 513 | rr = *ptr2; |
| | 514 | *ptr2++ = r; |
| | 515 | *ptr1++ = rr; |
| | 516 | |
| | 517 | r = *ptr1; |
| | 518 | rr = *ptr2; |
| | 519 | *ptr2++ = r; |
| | 520 | *ptr1++ = rr; |
| | 521 | |
| | 522 | r = *ptr1; |
| | 523 | rr = *ptr2; |
| | 524 | *ptr2 = r; |
| | 525 | *ptr1++ = rr; |
| | 526 | |
| | 527 | ptr2 -= 5; |
| | 528 | } |
| | 529 | } |
| | 530 | w3 = im->border.left; |
| | 531 | im->border.left = im->border.right; |
| | 532 | im->border.right = w3; |
| | 533 | gdirty_images(im); |
| | 534 | gdirty_pixmaps(im); |
| | 535 | } |
| | 536 | |
| | 537 | void |
| | 538 | gdk_imlib_flip_image_vertical(GdkImlibImage * im) |
| | 539 | { |
| | 540 | unsigned char *ptr1, *ptr2, r, rr; |
| | 541 | int x, y, yy; |
| | 542 | int w3; |
| | 543 | |
| | 544 | if (!im) |
| | 545 | return; |
| | 546 | |
| | 547 | w3 = im->rgb_width * 3; |
| | 548 | for (yy = im->rgb_height - 1, y = 0; y < im->rgb_height >> 1; y++, yy--) |
| | 549 | { |
| | 550 | ptr1 = im->rgb_data + (y * w3); |
| | 551 | ptr2 = im->rgb_data + (yy * w3); |
| | 552 | for (x = 0; x < im->rgb_width; x++) |
| | 553 | { |
| | 554 | r = *ptr1; |
| | 555 | rr = *ptr2; |
| | 556 | *ptr2++ = r; |
| | 557 | *ptr1++ = rr; |
| | 558 | r = *ptr1; |
| | 559 | rr = *ptr2; |
| | 560 | *ptr2++ = r; |
| | 561 | *ptr1++ = rr; |
| | 562 | r = *ptr1; |
| | 563 | rr = *ptr2; |
| | 564 | *ptr2++ = r; |
| | 565 | *ptr1++ = rr; |
| | 566 | } |
| | 567 | } |
| | 568 | w3 = im->border.top; |
| | 569 | im->border.top = im->border.bottom; |
| | 570 | im->border.bottom = w3; |
| | 571 | gdirty_images(im); |
| | 572 | gdirty_pixmaps(im); |
| | 573 | } |
| | 574 | |
| | 575 | void |
| | 576 | gdk_imlib_rotate_image(GdkImlibImage * im, gint d) |
| | 577 | { |
| | 578 | unsigned char *data; |
| | 579 | int x, y, w3, w4; |
| | 580 | unsigned char *ptr1, *ptr2; |
| | 581 | |
| | 582 | if (!im) |
| | 583 | return; |
| | 584 | w3 = im->rgb_width * 3; |
| | 585 | w4 = im->rgb_height * 3; |
| | 586 | |
| | 587 | data = malloc(im->rgb_width * im->rgb_height * 3); |
| | 588 | if (data == NULL) |
| | 589 | return; |
| | 590 | |
| | 591 | for (y = 0; y < im->rgb_height; y++) |
| | 592 | { |
| | 593 | ptr1 = im->rgb_data + (y * w3); |
| | 594 | ptr2 = data + (y * 3); |
| | 595 | for (x = 0; x < im->rgb_width; x++) |
| | 596 | { |
| | 597 | *ptr2++ = *ptr1++; |
| | 598 | *ptr2++ = *ptr1++; |
| | 599 | *ptr2 = *ptr1++; |
| | 600 | ptr2 += w4 - 2; |
| | 601 | } |
| | 602 | } |
| | 603 | free(im->rgb_data); |
| | 604 | im->rgb_data = data; |
| | 605 | w3 = im->rgb_width; |
| | 606 | im->rgb_width = im->rgb_height; |
| | 607 | im->rgb_height = w3; |
| | 608 | w3 = im->border.top; |
| | 609 | im->border.top = im->border.left; |
| | 610 | im->border.left = w3; |
| | 611 | w3 = im->border.bottom; |
| | 612 | im->border.bottom = im->border.right; |
| | 613 | im->border.right = w3; |
| | 614 | gdirty_images(im); |
| | 615 | gdirty_pixmaps(im); |
| | 616 | } |
| | 617 | |
| | 618 | GdkImlibImage * |
| | 619 | gdk_imlib_create_image_from_data(unsigned char *data, unsigned char *alpha, gint w, gint h) |
| | 620 | { |
| | 621 | GdkImlibImage *im; |
| | 622 | char s[128]; |
| | 623 | |
| | 624 | if (!data || w <= 0 || h <= 0) |
| | 625 | return NULL; |
| | 626 | |
| | 627 | im = malloc(sizeof(GdkImlibImage)); |
| | 628 | if (!im) |
| | 629 | return NULL; |
| | 630 | |
| | 631 | im->rgb_width = w; |
| | 632 | im->rgb_height = h; |
| | 633 | im->rgb_data = malloc(im->rgb_width * im->rgb_height * 3); |
| | 634 | if (!im->rgb_data) |
| | 635 | { |
| | 636 | free(im); |
| | 637 | return NULL; |
| | 638 | } |
| | 639 | |
| | 640 | memcpy(im->rgb_data, data, im->rgb_width * im->rgb_height * 3); |
| | 641 | /* im->alpha_data=alpha; */ |
| | 642 | im->alpha_data = NULL; |
| | 643 | g_snprintf(s, sizeof(s), "creat_%x_%x", (int)time(NULL), (int)rand()); |
| | 644 | im->filename = malloc(strlen(s) + 1); |
| | 645 | if (im->filename) |
| | 646 | strcpy(im->filename, s); |
| | 647 | im->width = 0; |
| | 648 | im->height = 0; |
| | 649 | im->shape_color.r = -1; |
| | 650 | im->shape_color.g = -1; |
| | 651 | im->shape_color.b = -1; |
| | 652 | im->border.left = 0; |
| | 653 | im->border.right = 0; |
| | 654 | im->border.top = 0; |
| | 655 | im->border.bottom = 0; |
| | 656 | im->pixmap = NULL; |
| | 657 | im->shape_mask = NULL; |
| | 658 | im->cache = 1; |
| | 659 | im->mod.gamma = id->mod.gamma; |
| | 660 | im->mod.brightness = id->mod.brightness; |
| | 661 | im->mod.contrast = id->mod.contrast; |
| | 662 | im->rmod.gamma = id->rmod.gamma; |
| | 663 | im->rmod.brightness = id->rmod.brightness; |
| | 664 | im->rmod.contrast = id->rmod.contrast; |
| | 665 | im->gmod.gamma = id->gmod.gamma; |
| | 666 | im->gmod.brightness = id->gmod.brightness; |
| | 667 | im->gmod.contrast = id->gmod.contrast; |
| | 668 | im->bmod.gamma = id->bmod.gamma; |
| | 669 | im->bmod.brightness = id->bmod.brightness; |
| | 670 | im->bmod.contrast = id->bmod.contrast; |
| | 671 | if (id->cache.on_image) |
| | 672 | gadd_image(im, im->filename); |
| | 673 | gcalc_map_tables(im); |
| | 674 | return im; |
| | 675 | } |
| | 676 | |
| | 677 | GdkImlibImage * |
| | 678 | gdk_imlib_clone_image(GdkImlibImage * im) |
| | 679 | { |
| | 680 | GdkImlibImage *im2; |
| | 681 | char *s; |
| | 682 | |
| | 683 | if (!im) |
| | 684 | return NULL; |
| | 685 | im2 = malloc(sizeof(GdkImlibImage)); |
| | 686 | if (!im2) |
| | 687 | return NULL; |
| | 688 | im2->rgb_width = im->rgb_width; |
| | 689 | im2->rgb_height = im->rgb_height; |
| | 690 | im2->rgb_data = malloc(im2->rgb_width * im2->rgb_height * 3); |
| | 691 | if (!im2->rgb_data) |
| | 692 | { |
| | 693 | free(im2); |
| | 694 | return NULL; |
| | 695 | } |
| | 696 | |
| | 697 | memcpy(im2->rgb_data, im->rgb_data, im2->rgb_width * im2->rgb_height * 3); |
| | 698 | if (im->alpha_data) |
| | 699 | { |
| | 700 | im2->alpha_data = malloc(im2->rgb_width * im2->rgb_height); |
| | 701 | if (!im2->alpha_data) |
| | 702 | { |
| | 703 | free(im2->rgb_data); |
| | 704 | free(im2); |
| | 705 | return NULL; |
| | 706 | } |
| | 707 | memcpy(im2->alpha_data, im->alpha_data, im2->rgb_width * im2->rgb_height); |
| | 708 | } |
| | 709 | else |
| | 710 | im2->alpha_data = NULL; |
| | 711 | s = malloc(strlen(im->filename) + 320); |
| | 712 | if (s) |
| | 713 | { |
| | 714 | g_snprintf(s, sizeof(s), "%s_%x_%x", im->filename, (int)time(NULL), (int)rand()); |
| | 715 | im2->filename = malloc(strlen(s) + 1); |
| | 716 | if (im2->filename) |
| | 717 | strcpy(im2->filename, s); |
| | 718 | free(s); |
| | 719 | } |
| | 720 | else |
| | 721 | im2->filename = NULL; |
| | 722 | im2->width = 0; |
| | 723 | im2->height = 0; |
| | 724 | im2->shape_color.r = im->shape_color.r; |
| | 725 | im2->shape_color.g = im->shape_color.g; |
| | 726 | im2->shape_color.b = im->shape_color.b; |
| | 727 | im2->border.left = im->border.left; |
| | 728 | im2->border.right = im->border.right; |
| | 729 | im2->border.top = im->border.top; |
| | 730 | im2->border.bottom = im->border.bottom; |
| | 731 | im2->pixmap = NULL; |
| | 732 | im2->shape_mask = NULL; |
| | 733 | im2->cache = 1; |
| | 734 | im2->mod.gamma = im->mod.gamma; |
| | 735 | im2->mod.brightness = im->mod.brightness; |
| | 736 | im2->mod.contrast = im->mod.contrast; |
| | 737 | im2->rmod.gamma = im->rmod.gamma; |
| | 738 | im2->rmod.brightness = im->rmod.brightness; |
| | 739 | im2->rmod.contrast = im->rmod.contrast; |
| | 740 | im2->gmod.gamma = im->gmod.gamma; |
| | 741 | im2->gmod.brightness = im->gmod.brightness; |
| | 742 | im2->gmod.contrast = im->gmod.contrast; |
| | 743 | im2->bmod.gamma = im->bmod.gamma; |
| | 744 | im2->bmod.brightness = im->bmod.brightness; |
| | 745 | im2->bmod.contrast = im->bmod.contrast; |
| | 746 | gcalc_map_tables(im2); |
| | 747 | if (id->cache.on_image) |
| | 748 | gadd_image(im2, im2->filename); |
| | 749 | return im2; |
| | 750 | } |
| | 751 | |
| | 752 | GdkImlibImage * |
| | 753 | gdk_imlib_clone_scaled_image(GdkImlibImage * im, int w, int h) |
| | 754 | { |
| | 755 | GdkImlibImage *im2; |
| | 756 | char *s; |
| | 757 | |
| | 758 | if (!im || w <= 0 || h <= 0) |
| | 759 | return NULL; |
| | 760 | |
| | 761 | im2 = malloc(sizeof(GdkImlibImage)); |
| | 762 | if (!im2) |
| | 763 | return NULL; |
| | 764 | im2->rgb_width = w; |
| | 765 | im2->rgb_height = h; |
| | 766 | im2->rgb_data = malloc(w * h * 3); |
| | 767 | if (!im2->rgb_data) |
| | 768 | { |
| | 769 | free(im2); |
| | 770 | return NULL; |
| | 771 | } |
| | 772 | { |
| | 773 | int x, y, *xarray; |
| | 774 | unsigned char **yarray, *ptr, *ptr2, *ptr22; |
| | 775 | int l, r, m, pos, inc, w3; |
| | 776 | |
| | 777 | xarray = malloc(sizeof(int) * w); |
| | 778 | |
| | 779 | if (!xarray) |
| | 780 | { |
| | 781 | fprintf(stderr, "ERROR: Cannot allocate X co-ord buffer\n"); |
| | 782 | free(im2->rgb_data); |
| | 783 | free(im2); |
| | 784 | return NULL; |
| | 785 | } |
| | 786 | yarray = malloc(sizeof(unsigned char *) * h); |
| | 787 | |
| | 788 | if (!yarray) |
| | 789 | { |
| | 790 | fprintf(stderr, "ERROR: Cannot allocate Y co-ord buffer\n"); |
| | 791 | free(xarray); |
| | 792 | free(im2->rgb_data); |
| | 793 | free(im2); |
| | 794 | return NULL; |
| | 795 | } |
| | 796 | ptr22 = im->rgb_data; |
| | 797 | w3 = im->rgb_width * 3; |
| | 798 | inc = 0; |
| | 799 | if (w < im->border.left + im->border.right) |
| | 800 | { |
| | 801 | l = w >> 1; |
| | 802 | r = w - l; |
| | 803 | m = 0; |
| | 804 | } |
| | 805 | else |
| | 806 | { |
| | 807 | l = im->border.left; |
| | 808 | r = im->border.right; |
| | 809 | m = w - l - r; |
| | 810 | } |
| | 811 | if (m > 0) |
| | 812 | inc = ((im->rgb_width - im->border.left - im->border.right) << 16) / m; |
| | 813 | pos = 0; |
| | 814 | if (l) |
| | 815 | { |
| | 816 | for (x = 0; x < l; x++) |
| | 817 | { |
| | 818 | xarray[x] = (pos >> 16) + (pos >> 16) + (pos >> 16); |
| | 819 | pos += 0x10000; |
| | 820 | } |
| | 821 | } |
| | 822 | if (m) |
| | 823 | { |
| | 824 | for (x = l; x < l + m; x++) |
| | 825 | { |
| | 826 | xarray[x] = (pos >> 16) + (pos >> 16) + (pos >> 16); |
| | 827 | pos += inc; |
| | 828 | } |
| | 829 | } |
| | 830 | pos = (im->rgb_width - r) << 16; |
| | 831 | for (x = w - r; x < w; x++) |
| | 832 | { |
| | 833 | xarray[x] = (pos >> 16) + (pos >> 16) + (pos >> 16); |
| | 834 | pos += 0x10000; |
| | 835 | } |
| | 836 | |
| | 837 | if (h < im->border.top + im->border.bottom) |
| | 838 | { |
| | 839 | l = h >> 1; |
| | 840 | r = h - l; |
| | 841 | m = 0; |
| | 842 | } |
| | 843 | else |
| | 844 | { |
| | 845 | l = im->border.top; |
| | 846 | r = im->border.bottom; |
| | 847 | m = h - l - r; |
| | 848 | } |
| | 849 | if (m > 0) |
| | 850 | inc = ((im->rgb_height - im->border.top - im->border.bottom) << 16) / m; |
| | 851 | pos = 0; |
| | 852 | for (x = 0; x < l; x++) |
| | 853 | { |
| | 854 | yarray[x] = ptr22 + ((pos >> 16) * w3); |
| | 855 | pos += 0x10000; |
| | 856 | } |
| | 857 | if (m) |
| | 858 | { |
| | 859 | for (x = l; x < l + m; x++) |
| | 860 | { |
| | 861 | yarray[x] = ptr22 + ((pos >> 16) * w3); |
| | 862 | pos += inc; |
| | 863 | } |
| | 864 | } |
| | 865 | pos = (im->rgb_height - r) << 16; |
| | 866 | for (x = h - r; x < h; x++) |
| | 867 | { |
| | 868 | yarray[x] = ptr22 + ((pos >> 16) * w3); |
| | 869 | pos += 0x10000; |
| | 870 | } |
| | 871 | |
| | 872 | ptr = im2->rgb_data; |
| | 873 | for (y = 0; y < h; y++) |
| | 874 | { |
| | 875 | for (x = 0; x < w; x++) |
| | 876 | { |
| | 877 | ptr2 = yarray[y] + xarray[x]; |
| | 878 | *ptr++ = (int)*ptr2++; |
| | 879 | *ptr++ = (int)*ptr2++; |
| | 880 | *ptr++ = (int)*ptr2; |
| | 881 | } |
| | 882 | } |
| | 883 | } |
| | 884 | if (im->alpha_data) |
| | 885 | { |
| | 886 | im2->alpha_data = NULL; |
| | 887 | /* yet to be filled in */ |
| | 888 | } |
| | 889 | else |
| | 890 | im2->alpha_data = NULL; |
| | 891 | |
| | 892 | s = malloc(strlen(im->filename) + 320); |
| | 893 | if (s) |
| | 894 | { |
| | 895 | g_snprintf(s, sizeof(s), "%s_%x_%x_%x_%x", im->filename, (int)time(NULL), w, h, (int)rand()); |
| | 896 | im2->filename = malloc(strlen(s) + 1); |
| | 897 | if (im2->filename) |
| | 898 | strcpy(im2->filename, s); |
| | 899 | free(s); |
| | 900 | } |
| | 901 | else |
| | 902 | im2->filename = NULL; |
| | 903 | im2->width = 0; |
| | 904 | im2->height = 0; |
| | 905 | im2->shape_color.r = im->shape_color.r; |
| | 906 | im2->shape_color.g = im->shape_color.g; |
| | 907 | im2->shape_color.b = im->shape_color.b; |
| | 908 | im2->border.left = im->border.left; |
| | 909 | im2->border.right = im->border.right; |
| | 910 | im2->border.top = im->border.top; |
| | 911 | im2->border.bottom = im->border.bottom; |
| | 912 | im2->pixmap = NULL; |
| | 913 | im2->shape_mask = NULL; |
| | 914 | im2->cache = 1; |
| | 915 | im2->mod.gamma = im->mod.gamma; |
| | 916 | im2->mod.brightness = im->mod.brightness; |
| | 917 | im2->mod.contrast = im->mod.contrast; |
| | 918 | im2->rmod.gamma = im->rmod.gamma; |
| | 919 | im2->rmod.brightness = im->rmod.brightness; |
| | 920 | im2->rmod.contrast = im->rmod.contrast; |
| | 921 | im2->gmod.gamma = im->gmod.gamma; |
| | 922 | im2->gmod.brightness = im->gmod.brightness; |
| | 923 | im2->gmod.contrast = im->gmod.contrast; |
| | 924 | im2->bmod.gamma = im->bmod.gamma; |
| | 925 | im2->bmod.brightness = im->bmod.brightness; |
| | 926 | im2->bmod.contrast = im->bmod.contrast; |
| | 927 | gcalc_map_tables(im2); |
| | 928 | if (id->cache.on_image) |
| | 929 | gadd_image(im2, im2->filename); |
| | 930 | return im2; |
| | 931 | } |
| | 932 | |
| | 933 | GdkImlibImage * |
| | 934 | gdk_imlib_create_image_from_xpm_data(char **data) |
| | 935 | { |
| | 936 | GdkImlibImage *im; |
| | 937 | unsigned char *ptr; |
| | 938 | int /* pc, */ c, i, j, k, ncolors, cpp, comment, transp, quote, |
| | 939 | context, len, count, done; |
| | 940 | int w, h; |
| | 941 | char *line, s[65536], tok[65536], col[65536]; |
| | 942 | XColor xcol; |
| | 943 | struct _cmap |
| | 944 | { |
| | 945 | char str[8]; |
| | 946 | char transp; |
| | 947 | int r, g, b; |
| | 948 | } |
| | 949 | *cmap; |
| | 950 | |
| | 951 | int lookup[128][128]; |
| | 952 | |
| | 953 | cmap = NULL; |
| | 954 | j = 0; |
| | 955 | if (!data) |
| | 956 | return NULL; |
| | 957 | im = malloc(sizeof(GdkImlibImage)); |
| | 958 | if (!im) |
| | 959 | return NULL; |
| | 960 | count = 0; |
| | 961 | transp = 0; |
| | 962 | done = 0; |
| | 963 | |
| | 964 | c = ' '; |
| | 965 | comment = 0; |
| | 966 | quote = 0; |
| | 967 | context = 0; |
| | 968 | ptr = NULL; |
| | 969 | |
| | 970 | while (!done) |
| | 971 | { |
| | 972 | line = data[count++]; |
| | 973 | if (context == 0) |
| | 974 | { |
| | 975 | /* Header */ |
| | 976 | sscanf(line, "%i %i %i %i", &w, &h, &ncolors, &cpp); |
| | 977 | if (cpp > 7) |
| | 978 | { |
| | 979 | fprintf(stderr, "gdk_imlib ERROR: XPM data with characters per pixel > 7 not supported\n"); |
| | 980 | free(im); |
| | 981 | return NULL; |
| | 982 | } |
| | 983 | if (w > 32767) |
| | 984 | { |
| | 985 | fprintf(stderr, "gdk_imlib ERROR: Image width > 32767 pixels for data\n"); |
| | 986 | free(im); |
| | 987 | return NULL; |
| | 988 | } |
| | 989 | if (h > 32767) |
| | 990 | { |
| | 991 | fprintf(stderr, "gdk_imlib ERROR: Image height > 32767 pixels for data\n"); |
| | 992 | free(im); |
| | 993 | return NULL; |
| | 994 | } |
| | 995 | cmap = malloc(sizeof(struct _cmap) * ncolors); |
| | 996 | |
| | 997 | if (!cmap) |
| | 998 | { |
| | 999 | free(im); |
| | 1000 | return NULL; |
| | 1001 | } |
| | 1002 | im->rgb_width = w; |
| | 1003 | im->rgb_height = h; |
| | 1004 | im->rgb_data = malloc(im->rgb_width * im->rgb_height * 3); |
| | 1005 | if (!im->rgb_data) |
| | 1006 | { |
| | 1007 | free(cmap); |
| | 1008 | free(im); |
| | 1009 | return NULL; |
| | 1010 | } |
| | 1011 | im->alpha_data = NULL; |
| | 1012 | g_snprintf(s, sizeof(s), "creat_%x_%x", (int)time(NULL), (int)rand()); |
| | 1013 | im->filename = malloc(strlen(s) + 1); |
| | 1014 | if (im->filename) |
| | 1015 | strcpy(im->filename, s); |
| | 1016 | im->width = 0; |
| | 1017 | im->height = 0; |
| | 1018 | im->border.left = 0; |
| | 1019 | im->border.right = 0; |
| | 1020 | im->border.top = 0; |
| | 1021 | im->border.bottom = 0; |
| | 1022 | im->pixmap = NULL; |
| | 1023 | im->shape_mask = NULL; |
| | 1024 | im->cache = 1; |
| | 1025 | im->mod.gamma = id->mod.gamma; |
| | 1026 | im->mod.brightness = id->mod.brightness; |
| | 1027 | im->mod.contrast = id->mod.contrast; |
| | 1028 | im->rmod.gamma = id->rmod.gamma; |
| | 1029 | im->rmod.brightness = id->rmod.brightness; |
| | 1030 | im->rmod.contrast = id->rmod.contrast; |
| | 1031 | im->gmod.gamma = id->gmod.gamma; |
| | 1032 | im->gmod.brightness = id->gmod.brightness; |
| | 1033 | im->gmod.contrast = id->gmod.contrast; |
| | 1034 | im->bmod.gamma = id->bmod.gamma; |
| | 1035 | im->bmod.brightness = id->bmod.brightness; |
| | 1036 | im->bmod.contrast = id->bmod.contrast; |
| | 1037 | ptr = im->rgb_data; |
| | 1038 | j = 0; |
| | 1039 | context++; |
| | 1040 | } |
| | 1041 | else if (context == 1) |
| | 1042 | { |
| | 1043 | int colptr; |
| | 1044 | |
| | 1045 | /* Color Table */ |
| | 1046 | if (j < ncolors) |
| | 1047 | { |
| | 1048 | tok[0] = 0; |
| | 1049 | col[0] = 0; |
| | 1050 | s[0] = 0; |
| | 1051 | colptr = 0; |
| | 1052 | len = strlen(line); |
| | 1053 | strncpy(cmap[j].str, line, cpp); |
| | 1054 | cmap[j].str[cpp] = 0; |
| | 1055 | cmap[j].r = -1; |
| | 1056 | cmap[j].transp = 0; |
| | 1057 | for (k = cpp; k < len; k++) |
| | 1058 | { |
| | 1059 | if (line[k] != ' ') |
| | 1060 | { |
| | 1061 | sscanf(&line[k], "%65536s", s); |
| | 1062 | k += strlen(s); |
| | 1063 | if ((!strcmp(s, "m")) || (!strcmp(s, "s")) || |
| | 1064 | (!strcmp(s, "g4")) || (!strcmp(s, "g")) || |
| | 1065 | (!strcmp(s, "c")) || (k >= len)) |
| | 1066 | { |
| | 1067 | if (k >= len) |
| | 1068 | { |
| | 1069 | int ls; |
| | 1070 | |
| | 1071 | ls = strlen(s); |
| | 1072 | |
| | 1073 | if (col[0] && colptr < sizeof(col)) |
| | 1074 | { |
| | 1075 | strcpy(col + colptr, " "); |
| | 1076 | colptr++; |
| | 1077 | } |
| | 1078 | if (colptr + ls <= sizeof(col)) |
| | 1079 | { |
| | 1080 | strcpy(col + colptr, s); |
| | 1081 | colptr += ls; |
| | 1082 | } |
| | 1083 | |
| | 1084 | } |
| | 1085 | if (col[0]) |
| | 1086 | { |
| | 1087 | if (!strcasecmp(col, "none")) |
| | 1088 | { |
| | 1089 | transp = 1; |
| | 1090 | cmap[j].transp = 1; |
| | 1091 | } |
| | 1092 | else |
| | 1093 | { |
| | 1094 | if ((cmap[j].r < 0) || |
| | 1095 | (!strcmp(tok, "c"))) |
| | 1096 | { |
| | 1097 | XParseColor(id->x.disp, |
| | 1098 | id->x.root_cmap, |
| | 1099 | col, &xcol); |
| | 1100 | cmap[j].r = xcol.red >> 8; |
| | 1101 | cmap[j].g = xcol.green >> 8; |
| | 1102 | cmap[j].b = xcol.blue >> 8; |
| | 1103 | if ((cmap[j].r == 255) && |
| | 1104 | (cmap[j].g == 0) && |
| | 1105 | (cmap[j].b == 255)) |
| | 1106 | cmap[j].r = 254; |
| | 1107 | } |
| | 1108 | } |
| | 1109 | } |
| | 1110 | if (strlen(s) < sizeof(tok)) |
| | 1111 | strcpy(tok, s); |
| | 1112 | col[0] = 0; |
| | 1113 | } |
| | 1114 | else |
| | 1115 | { |
| | 1116 | int ls; |
| | 1117 | |
| | 1118 | ls = strlen(s); |
| | 1119 | |
| | 1120 | if (col[0] && colptr < sizeof(col)) |
| | 1121 | { |
| | 1122 | strcpy(col + colptr, " "); |
| | 1123 | colptr++; |
| | 1124 | } |
| | 1125 | if (ls + colptr < sizeof(col)) |
| | 1126 | { |
| | 1127 | strcpy(col + colptr, s); |
| | 1128 | colptr += ls; |
| | 1129 | } |
| | 1130 | } |
| | 1131 | } |
| | 1132 | } |
| | 1133 | } |
| | 1134 | j++; |
| | 1135 | if (j >= ncolors) |
| | 1136 | { |
| | 1137 | if (cpp == 1) |
| | 1138 | for (i = 0; i < ncolors; i++) |
| | 1139 | lookup[(int)cmap[i].str[0]][(int)cmap[i].str[1]] = i; |
| | 1140 | if (cpp == 2) |
| | 1141 | for (i = 0; i < ncolors; i++) |
| | 1142 | lookup[(int)cmap[i].str[0]][(int)cmap[i].str[1]] = i; |
| | 1143 | context++; |
| | 1144 | } |
| | 1145 | } |
| | 1146 | else |
| | 1147 | { |
| | 1148 | /* Image Data */ |
| | 1149 | i = 0; |
| | 1150 | if (cpp == 0) |
| | 1151 | { |
| | 1152 | } |
| | 1153 | else if (cpp == 1) |
| | 1154 | { |
| | 1155 | if (transp) |
| | 1156 | { |
| | 1157 | for (i = 0; ((i < 65536) && (line[i])); i++) |
| | 1158 | { |
| | 1159 | col[0] = line[i]; |
| | 1160 | if (cmap[lookup[(int)col[0]][0]].transp) |
| | 1161 | { |
| | 1162 | *ptr++ = 255; |
| | 1163 | *ptr++ = 0; |
| | 1164 | *ptr++ = 255; |
| | 1165 | } |
| | 1166 | else |
| | 1167 | { |
| | 1168 | *ptr++ = (unsigned char)cmap[lookup[(int)col[0]][0]].r; |
| | 1169 | *ptr++ = (unsigned char)cmap[lookup[(int)col[0]][0]].g; |
| | 1170 | *ptr++ = (unsigned char)cmap[lookup[(int)col[0]][0]].b; |
| | 1171 | } |
| | 1172 | } |
| | 1173 | } |
| | 1174 | else |
| | 1175 | { |
| | 1176 | for (i = 0; ((i < 65536) && (line[i])); i++) |
| | 1177 | { |
| | 1178 | col[0] = line[i]; |
| | 1179 | *ptr++ = (unsigned char)cmap[lookup[(int)col[0]][0]].r; |
| | 1180 | *ptr++ = (unsigned char)cmap[lookup[(int)col[0]][0]].g; |
| | 1181 | *ptr++ = (unsigned char)cmap[lookup[(int)col[0]][0]].b; |
| | 1182 | } |
| | 1183 | } |
| | 1184 | } |
| | 1185 | else if (cpp == 2) |
| | 1186 | { |
| | 1187 | if (transp) |
| | 1188 | { |
| | 1189 | for (i = 0; ((i < 65536) && (line[i])); i++) |
| | 1190 | { |
| | 1191 | col[0] = line[i++]; |
| | 1192 | col[1] = line[i]; |
| | 1193 | if (cmap[lookup[(int)col[0]][(int)col[1]]].transp) |
| | 1194 | { |
| | 1195 | *ptr++ = 255; |
| | 1196 | *ptr++ = 0; |
| | 1197 | *ptr++ = 255; |
| | 1198 | } |
| | 1199 | else |
| | 1200 | { |
| | 1201 | *ptr++ = (unsigned char)cmap[lookup[(int)col[0]][(int)col[1]]].r; |
| | 1202 | *ptr++ = (unsigned char)cmap[lookup[(int)col[0]][(int)col[1]]].g; |
| | 1203 | *ptr++ = (unsigned char)cmap[lookup[(int)col[0]][(int)col[1]]].b; |
| | 1204 | } |
| | 1205 | } |
| | 1206 | } |
| | 1207 | else |
| | 1208 | { |
| | 1209 | for (i = 0; ((i < 65536) && (line[i])); i++) |
| | 1210 | { |
| | 1211 | col[0] = line[i++]; |
| | 1212 | col[1] = line[i]; |
| | 1213 | *ptr++ = (unsigned char)cmap[lookup[(int)col[0]][(int)col[1]]].r; |
| | 1214 | *ptr++ = (unsigned char)cmap[lookup[(int)col[0]][(int)col[1]]].g; |
| | 1215 | *ptr++ = (unsigned char)cmap[lookup[(int)col[0]][(int)col[1]]].b; |
| | 1216 | } |
| | 1217 | } |
| | 1218 | } |
| | 1219 | else |
| | 1220 | { |
| | 1221 | if (transp) |
| | 1222 | { |
| | 1223 | for (i = 0; ((i < 65536) && (line[i])); i++) |
| | 1224 | { |
| | 1225 | for (j = 0; j < cpp; j++, i++) |
| | 1226 | { |
| | 1227 | col[j] = line[i]; |
| | 1228 | } |
| | 1229 | col[j] = 0; |
| | 1230 | i--; |
| | 1231 | for (j = 0; j < ncolors; j++) |
| | 1232 | { |
| | 1233 | if (!strcmp(col, cmap[j].str)) |
| | 1234 | { |
| | 1235 | if (cmap[j].transp) |
| | 1236 | { |
| | 1237 | *ptr++ = 255; |
| | 1238 | *ptr++ = 0; |
| | 1239 | *ptr++ = 255; |
| | 1240 | } |
| | 1241 | else |
| | 1242 | { |
| | 1243 | *ptr++ = (unsigned char)cmap[j].r; |
| | 1244 | *ptr++ = (unsigned char)cmap[j].g; |
| | 1245 | *ptr++ = (unsigned char)cmap[j].b; |
| | 1246 | } |
| | 1247 | j = ncolors; |
| | 1248 | } |
| | 1249 | } |
| | 1250 | } |
| | 1251 | } |
| | 1252 | else |
| | 1253 | { |
| | 1254 | for (i = 0; ((i < 65536) && (line[i])); i++) |
| | 1255 | { |
| | 1256 | for (j = 0; j < cpp; j++, i++) |
| | 1257 | { |
| | 1258 | col[j] = line[i]; |
| | 1259 | } |
| | 1260 | col[j] = 0; |
| | 1261 | i--; |
| | 1262 | for (j = 0; j < ncolors; j++) |
| | 1263 | { |
| | 1264 | if (!strcmp(col, cmap[j].str)) |
| | 1265 | { |
| | 1266 | *ptr++ = (unsigned char)cmap[j].r; |
| | 1267 | *ptr++ = (unsigned char)cmap[j].g; |
| | 1268 | *ptr++ = (unsigned char)cmap[j].b; |
| | 1269 | j = ncolors; |
| | 1270 | } |
| | 1271 | } |
| | 1272 | } |
| | 1273 | } |
| | 1274 | } |
| | 1275 | } |
| | 1276 | if ((ptr) && ((ptr - im->rgb_data) >= w * h * 3)) |
| | 1277 | done = 1; |
| | 1278 | } |
| | 1279 | if (!transp) |
| | 1280 | { |
| | 1281 | im->shape_color.r = -1; |
| | 1282 | im->shape_color.g = -1; |
| | 1283 | im->shape_color.b = -1; |
| | 1284 | } |
| | 1285 | else |
| | 1286 | { |
| | 1287 | im->shape_color.r = 255; |
| | 1288 | im->shape_color.g = 0; |
| | 1289 | im->shape_color.b = 255; |
| | 1290 | } |
| | 1291 | if (id->cache.on_image) |
| | 1292 | gadd_image(im, im->filename); |
| | 1293 | gcalc_map_tables(im); |
| | 1294 | free(cmap); |
| | 1295 | return im; |
| | 1296 | } |
| | 1297 | |
| | 1298 | gint |
| | 1299 | gdk_imlib_data_to_pixmap(char **data, GdkPixmap ** pmap, GdkBitmap ** mask) |
| | 1300 | { |
| | 1301 | GdkImlibImage *im; |
| | 1302 | |
| | 1303 | im = gdk_imlib_create_image_from_xpm_data(data); |
| | 1304 | if (!im) |
| | 1305 | { |
| | 1306 | if (pmap) |
| | 1307 | *pmap = NULL; |
| | 1308 | if (mask) |
| | 1309 | *mask = NULL; |
| | 1310 | return 0; |
| | 1311 | } |
| | 1312 | if (!gdk_imlib_render(im, im->rgb_width, im->rgb_height)) |
| | 1313 | { |
| | 1314 | gdk_imlib_destroy_image(im); |
| | 1315 | if (pmap) |
| | 1316 | *pmap = NULL; |
| | 1317 | if (mask) |
| | 1318 | *mask = NULL; |
| | 1319 | return 0; |
| | 1320 | } |
| | 1321 | if (pmap) |
| | 1322 | *pmap = gdk_imlib_move_image(im); |
| | 1323 | if (mask) |
| | 1324 | *mask = gdk_imlib_move_mask(im); |
| | 1325 | gdk_imlib_kill_image(im); |
| | 1326 | return 1; |
| | 1327 | } |
| | 1328 | |
| | 1329 | #include <signal.h> |
| | 1330 | #include <sys/wait.h> |
| | 1331 | |
| | 1332 | /* |
| | 1333 | * Helper library |
| | 1334 | */ |
| | 1335 | |
| | 1336 | static int hpid; |
| | 1337 | void *oldpiper; /* actually sighandler_t but BSD uses sig_t. */ |
| | 1338 | |
| | 1339 | FILE * |
| | 1340 | open_helper(const char *instring, const char *fn, const char *mode) |
| | 1341 | { |
| | 1342 | char buf[256]; /* This is safe since our input strings |
| | 1343 | |
| | 1344 | * |
| | 1345 | * * are bounded */ |
| | 1346 | static char *vec[16]; |
| | 1347 | char *p = strdup(instring); |
| | 1348 | char *pp; |
| | 1349 | char *ep; |
| | 1350 | int vn = 0; |
| | 1351 | int pid; |
| | 1352 | FILE *fp = NULL; |
| | 1353 | char *ofil = NULL; |
| | 1354 | int ofd = -1; |
| | 1355 | |
| | 1356 | int pfd[2]; |
| | 1357 | |
| | 1358 | if (p == NULL) |
| | 1359 | return NULL; |
| | 1360 | |
| | 1361 | if (strncmp(instring, "%Q", 2) == 0) |
| | 1362 | { |
| | 1363 | /* |
| | 1364 | * Generate a quanting pipeline |
| | 1365 | */ |
| | 1366 | fprintf(stderr, "Not currently supported: install ImageMagic.\n"); |
| | 1367 | return NULL; |
| | 1368 | } |
| | 1369 | /* |
| | 1370 | * Ok split the instring on spaces and translate |
| | 1371 | * %C %P %F and %s |
| | 1372 | * |
| | 1373 | * FIXME: We need to handle a format string that begins |
| | 1374 | * %Q to indicate an 8bit quant in the pipeline first. |
| | 1375 | */ |
| | 1376 | |
| | 1377 | pp = p; |
| | 1378 | |
| | 1379 | while (vn < 15) |
| | 1380 | { |
| | 1381 | while (*pp && isspace(*pp)) |
| | 1382 | pp++; |
| | 1383 | ep = pp; |
| | 1384 | while (*ep && !isspace(*ep)) |
| | 1385 | ep++; |
| | 1386 | if (*pp == 0) |
| | 1387 | break; |
| | 1388 | /* pp->ep is now the input string block */ |
| | 1389 | if (*ep) |
| | 1390 | *ep++ = 0; |
| | 1391 | |
| | 1392 | if (strcmp(pp, "%s") == 0) |
| | 1393 | vec[vn] = strdup(fn); |
| | 1394 | else if (strncmp(pp, "%P/", 3) == 0) |
| | 1395 | { |
| | 1396 | strcpy(buf, NETPBM_PATH); |
| | 1397 | strcat(buf, pp + 2); |
| | 1398 | if ((vec[vn] = strdup(buf)) == NULL) |
| | 1399 | break; |
| | 1400 | } |
| | 1401 | else if (strncmp(pp, "%J", 3) == 0) |
| | 1402 | { |
| | 1403 | if ((vec[vn] = strdup(DJPEG_PROG)) == NULL) |
| | 1404 | break; |
| | 1405 | } |
| | 1406 | else if (strncmp(pp, "%H", 3) == 0) |
| | 1407 | { |
| | 1408 | if ((vec[vn] = strdup(CJPEG_PROG)) == NULL) |
| | 1409 | break; |
| | 1410 | } |
| | 1411 | else if (strncmp(pp, "%C/", 3) == 0) |
| | 1412 | { |
| | 1413 | strcpy(buf, CONVERT_PATH); |
| | 1414 | strcat(buf, pp + 2); |
| | 1415 | if ((vec[vn] = strdup(buf)) == NULL) |
| | 1416 | break; |
| | 1417 | } |
| | 1418 | else if (strncmp(pp, ">%s", 3) == 0) |
| | 1419 | { |
| | 1420 | ofil = pp; |
| | 1421 | vn++; |
| | 1422 | pp = ep; |
| | 1423 | continue; |
| | 1424 | } |
| | 1425 | else |
| | 1426 | { |
| | 1427 | if ((vec[vn] = strdup(pp)) == NULL) |
| | 1428 | break; |
| | 1429 | } |
| | 1430 | vn++; |
| | 1431 | pp = ep; |
| | 1432 | } |
| | 1433 | |
| | 1434 | vec[vn] = NULL; |
| | 1435 | |
| | 1436 | if (pipe(pfd) == -1) |
| | 1437 | goto oops; |
| | 1438 | |
| | 1439 | if (*mode == 'r') |
| | 1440 | { |
| | 1441 | fp = fdopen(pfd[0], "r"); |
| | 1442 | if (fp == NULL) |
| | 1443 | goto oops; |
| | 1444 | } |
| | 1445 | else if (*mode == 'w') |
| | 1446 | { |
| | 1447 | fp = fdopen(pfd[1], "w"); |
| | 1448 | if (fp == NULL) |
| | 1449 | goto oops; |
| | 1450 | } |
| | 1451 | else |
| | 1452 | goto oops; |
| | 1453 | |
| | 1454 | if (ofil != NULL) |
| | 1455 | if ((ofd = open(ofil, O_WRONLY | O_TRUNC | O_CREAT)) == -1) |
| | 1456 | goto oops; |
| | 1457 | |
| | 1458 | switch (pid = fork()) |
| | 1459 | { |
| | 1460 | case -1: |
| | 1461 | break; |
| | 1462 | case 0: |
| | 1463 | signal(SIGPIPE, SIG_DFL); |
| | 1464 | if (*mode == 'r') |
| | 1465 | dup2(pfd[1], 1); |
| | 1466 | if (*mode == 'w') |
| | 1467 | { |
| | 1468 | dup2(pfd[0], 0); |
| | 1469 | if (ofd != -1) |
| | 1470 | { |
| | 1471 | dup2(ofd, 1); |
| | 1472 | close(1); |
| | 1473 | } |
| | 1474 | } |
| | 1475 | close(pfd[0]); |
| | 1476 | close(pfd[1]); |
| | 1477 | execv(vec[0], vec); |
| | 1478 | perror(vec[0]); |
| | 1479 | /* |
| | 1480 | * This MUST be _exit or we will hit the SIGPIPE |
| | 1481 | * handler in ways we dont want. We want our parent |
| | 1482 | * to flush the inherited file buffers not us. |
| | 1483 | */ |
| | 1484 | _exit(1); |
| | 1485 | default: |
| | 1486 | hpid = pid; |
| | 1487 | |
| | 1488 | if (ofd != -1) |
| | 1489 | close(ofd); |
| | 1490 | if (*mode == 'r') |
| | 1491 | close(pfd[1]); |
| | 1492 | else |
| | 1493 | close(pfd[0]); |
| | 1494 | } |
| | 1495 | for (vn = 0; vn < 16; vn++) |
| | 1496 | if (vec[vn]) |
| | 1497 | free(vec[vn]); |
| | 1498 | oldpiper = signal(SIGPIPE, SIG_IGN); |
| | 1499 | return fp; |
| | 1500 | |
| | 1501 | oops: |
| | 1502 | if (ofd != -1) |
| | 1503 | close(ofd); |
| | 1504 | if (fp) |
| | 1505 | fclose(fp); |
| | 1506 | for (vn = 0; vn < 16; vn++) |
| | 1507 | if (vec[vn]) |
| | 1508 | free(vec[vn]); |
| | 1509 | return NULL; |
| | 1510 | } |
| | 1511 | |
| | 1512 | int |
| | 1513 | close_helper(FILE * fp) |
| | 1514 | { |
| | 1515 | int info; |
| | 1516 | |
| | 1517 | fclose(fp); |
| | 1518 | signal(SIGPIPE, oldpiper); |
| | 1519 | waitpid(hpid, &info, 0); |
| | 1520 | return WEXITSTATUS(info); |
| | 1521 | } |
projects / wxWidgets.git / blame_incremental