Mercurial > geeqie.yaz
annotate src/pan-item.c @ 1196:4fe35e07308d
handle the case when io.open() fails
author | nadvornik |
---|---|
date | Sun, 07 Dec 2008 13:28:04 +0000 |
parents | 1646720364cf |
children | 8b89e3ff286b |
rev | line source |
---|---|
105 | 1 /* |
196 | 2 * Geeqie |
105 | 3 * (C) 2006 John Ellis |
475 | 4 * Copyright (C) 2008 The Geeqie Team |
105 | 5 * |
6 * Author: John Ellis | |
7 * | |
8 * This software is released under the GNU General Public License (GNU GPL). | |
9 * Please read the included file COPYING for more information. | |
10 * This software comes with no warranty of any kind, use at your own risk! | |
11 */ | |
12 | |
13 | |
281 | 14 #include "main.h" |
105 | 15 #include "pan-types.h" |
16 | |
17 | |
18 /* | |
19 *----------------------------------------------------------------------------- | |
20 * item base functions | |
21 *----------------------------------------------------------------------------- | |
22 */ | |
23 | |
24 void pan_item_free(PanItem *pi) | |
25 { | |
26 if (!pi) return; | |
27 | |
28 if (pi->pixbuf) g_object_unref(pi->pixbuf); | |
138 | 29 if (pi->fd) file_data_unref(pi->fd); |
105 | 30 g_free(pi->text); |
31 g_free(pi->key); | |
32 g_free(pi->data); | |
33 | |
34 g_free(pi); | |
35 } | |
36 | |
37 void pan_item_set_key(PanItem *pi, const gchar *key) | |
38 { | |
39 gchar *tmp; | |
40 | |
41 if (!pi) return; | |
42 | |
43 tmp = pi->key; | |
44 pi->key = g_strdup(key); | |
45 g_free(tmp); | |
46 } | |
47 | |
48 void pan_item_added(PanWindow *pw, PanItem *pi) | |
49 { | |
50 if (!pi) return; | |
51 image_area_changed(pw->imd, pi->x, pi->y, pi->width, pi->height); | |
52 } | |
53 | |
54 void pan_item_remove(PanWindow *pw, PanItem *pi) | |
55 { | |
56 if (!pi) return; | |
57 | |
58 if (pw->click_pi == pi) pw->click_pi = NULL; | |
59 if (pw->queue_pi == pi) pw->queue_pi = NULL; | |
60 if (pw->search_pi == pi) pw->search_pi = NULL; | |
61 pw->queue = g_list_remove(pw->queue, pi); | |
62 | |
63 pw->list = g_list_remove(pw->list, pi); | |
64 image_area_changed(pw->imd, pi->x, pi->y, pi->width, pi->height); | |
65 pan_item_free(pi); | |
66 } | |
67 | |
68 void pan_item_size_by_item(PanItem *pi, PanItem *child, gint border) | |
69 { | |
70 if (!pi || !child) return; | |
71 | |
72 if (pi->x + pi->width < child->x + child->width + border) | |
73 pi->width = child->x + child->width + border - pi->x; | |
74 | |
75 if (pi->y + pi->height < child->y + child->height + border) | |
76 pi->height = child->y + child->height + border - pi->y; | |
77 } | |
78 | |
79 void pan_item_size_coordinates(PanItem *pi, gint border, gint *w, gint *h) | |
80 { | |
81 if (!pi) return; | |
82 | |
83 if (*w < pi->x + pi->width + border) *w = pi->x + pi->width + border; | |
84 if (*h < pi->y + pi->height + border) *h = pi->y + pi->height + border; | |
85 } | |
86 | |
87 | |
88 /* | |
89 *----------------------------------------------------------------------------- | |
90 * item box type | |
91 *----------------------------------------------------------------------------- | |
92 */ | |
93 | |
94 PanItem *pan_item_box_new(PanWindow *pw, FileData *fd, gint x, gint y, gint width, gint height, | |
95 gint border_size, | |
96 guint8 base_r, guint8 base_g, guint8 base_b, guint8 base_a, | |
97 guint8 bord_r, guint8 bord_g, guint8 bord_b, guint8 bord_a) | |
98 { | |
99 PanItem *pi; | |
100 | |
101 pi = g_new0(PanItem, 1); | |
102 pi->type = PAN_ITEM_BOX; | |
103 pi->fd = fd; | |
104 pi->x = x; | |
105 pi->y = y; | |
106 pi->width = width; | |
107 pi->height = height; | |
108 | |
109 pi->color_r = base_r; | |
110 pi->color_g = base_g; | |
111 pi->color_b = base_b; | |
112 pi->color_a = base_a; | |
113 | |
114 pi->color2_r = bord_r; | |
115 pi->color2_g = bord_g; | |
116 pi->color2_b = bord_b; | |
117 pi->color2_a = bord_a; | |
118 pi->border = border_size; | |
119 | |
120 pw->list = g_list_prepend(pw->list, pi); | |
121 | |
122 return pi; | |
123 } | |
124 | |
125 void pan_item_box_shadow(PanItem *pi, gint offset, gint fade) | |
126 { | |
127 gint *shadow; | |
128 | |
129 if (!pi || pi->type != PAN_ITEM_BOX) return; | |
130 | |
131 shadow = pi->data; | |
132 if (shadow) | |
133 { | |
134 pi->width -= shadow[0]; | |
135 pi->height -= shadow[0]; | |
136 } | |
137 | |
138 shadow = g_new0(gint, 2); | |
139 shadow[0] = offset; | |
140 shadow[1] = fade; | |
141 | |
142 pi->width += offset; | |
143 pi->height += offset; | |
144 | |
145 g_free(pi->data); | |
146 pi->data = shadow; | |
147 } | |
148 | |
149 gint pan_item_box_draw(PanWindow *pw, PanItem *pi, GdkPixbuf *pixbuf, PixbufRenderer *pr, | |
150 gint x, gint y, gint width, gint height) | |
151 { | |
152 gint bw, bh; | |
153 gint *shadow; | |
154 gint rx, ry, rw, rh; | |
155 | |
156 bw = pi->width; | |
157 bh = pi->height; | |
158 | |
159 shadow = pi->data; | |
160 if (shadow) | |
161 { | |
162 bw -= shadow[0]; | |
163 bh -= shadow[0]; | |
164 | |
165 if (pi->color_a > 254) | |
166 { | |
167 pixbuf_draw_shadow(pixbuf, pi->x - x + bw, pi->y - y + shadow[0], | |
168 shadow[0], bh - shadow[0], | |
169 pi->x - x + shadow[0], pi->y - y + shadow[0], bw, bh, | |
170 shadow[1], | |
171 PAN_SHADOW_COLOR, PAN_SHADOW_ALPHA); | |
172 pixbuf_draw_shadow(pixbuf, pi->x - x + shadow[0], pi->y - y + bh, | |
173 bw, shadow[0], | |
174 pi->x - x + shadow[0], pi->y - y + shadow[0], bw, bh, | |
175 shadow[1], | |
176 PAN_SHADOW_COLOR, PAN_SHADOW_ALPHA); | |
177 } | |
178 else | |
179 { | |
180 gint a; | |
181 a = pi->color_a * PAN_SHADOW_ALPHA >> 8; | |
182 pixbuf_draw_shadow(pixbuf, pi->x - x + shadow[0], pi->y - y + shadow[0], | |
183 bw, bh, | |
184 pi->x - x + shadow[0], pi->y - y + shadow[0], bw, bh, | |
185 shadow[1], | |
186 PAN_SHADOW_COLOR, a); | |
187 } | |
188 } | |
189 | |
190 if (util_clip_region(x, y, width, height, | |
191 pi->x, pi->y, bw, bh, | |
192 &rx, &ry, &rw, &rh)) | |
193 { | |
194 pixbuf_draw_rect_fill(pixbuf, | |
195 rx - x, ry - y, rw, rh, | |
196 pi->color_r, pi->color_g, pi->color_b, pi->color_a); | |
197 } | |
198 if (util_clip_region(x, y, width, height, | |
199 pi->x, pi->y, bw, pi->border, | |
200 &rx, &ry, &rw, &rh)) | |
201 { | |
202 pixbuf_draw_rect_fill(pixbuf, | |
203 rx - x, ry - y, rw, rh, | |
204 pi->color2_r, pi->color2_g, pi->color2_b, pi->color2_a); | |
205 } | |
206 if (util_clip_region(x, y, width, height, | |
207 pi->x, pi->y + pi->border, pi->border, bh - pi->border * 2, | |
208 &rx, &ry, &rw, &rh)) | |
209 { | |
210 pixbuf_draw_rect_fill(pixbuf, | |
211 rx - x, ry - y, rw, rh, | |
212 pi->color2_r, pi->color2_g, pi->color2_b, pi->color2_a); | |
213 } | |
214 if (util_clip_region(x, y, width, height, | |
215 pi->x + bw - pi->border, pi->y + pi->border, | |
216 pi->border, bh - pi->border * 2, | |
217 &rx, &ry, &rw, &rh)) | |
218 { | |
219 pixbuf_draw_rect_fill(pixbuf, | |
220 rx - x, ry - y, rw, rh, | |
221 pi->color2_r, pi->color2_g, pi->color2_b, pi->color2_a); | |
222 } | |
223 if (util_clip_region(x, y, width, height, | |
224 pi->x, pi->y + bh - pi->border, | |
225 bw, pi->border, | |
226 &rx, &ry, &rw, &rh)) | |
227 { | |
228 pixbuf_draw_rect_fill(pixbuf, | |
229 rx - x, ry - y, rw, rh, | |
230 pi->color2_r, pi->color2_g, pi->color2_b, pi->color2_a); | |
231 } | |
232 | |
233 return FALSE; | |
234 } | |
235 | |
236 | |
237 /* | |
238 *----------------------------------------------------------------------------- | |
239 * item triangle type | |
240 *----------------------------------------------------------------------------- | |
241 */ | |
242 | |
243 PanItem *pan_item_tri_new(PanWindow *pw, FileData *fd, gint x, gint y, gint width, gint height, | |
244 gint x1, gint y1, gint x2, gint y2, gint x3, gint y3, | |
245 guint8 r, guint8 g, guint8 b, guint8 a) | |
246 { | |
247 PanItem *pi; | |
248 gint *coord; | |
249 | |
250 pi = g_new0(PanItem, 1); | |
251 pi->type = PAN_ITEM_TRIANGLE; | |
252 pi->x = x; | |
253 pi->y = y; | |
254 pi->width = width; | |
255 pi->height = height; | |
256 | |
257 pi->color_r = r; | |
258 pi->color_g = g; | |
259 pi->color_b = b; | |
260 pi->color_a = a; | |
261 | |
262 coord = g_new0(gint, 6); | |
263 coord[0] = x1; | |
264 coord[1] = y1; | |
265 coord[2] = x2; | |
266 coord[3] = y2; | |
267 coord[4] = x3; | |
268 coord[5] = y3; | |
269 | |
270 pi->data = coord; | |
271 | |
272 pi->border = PAN_BORDER_NONE; | |
273 | |
274 pw->list = g_list_prepend(pw->list, pi); | |
275 | |
276 return pi; | |
277 } | |
278 | |
279 void pan_item_tri_border(PanItem *pi, gint borders, | |
280 guint8 r, guint8 g, guint8 b, guint8 a) | |
281 { | |
282 if (!pi || pi->type != PAN_ITEM_TRIANGLE) return; | |
283 | |
284 pi->border = borders; | |
285 | |
286 pi->color2_r = r; | |
287 pi->color2_g = g; | |
288 pi->color2_b = b; | |
289 pi->color2_a = a; | |
290 } | |
291 | |
292 gint pan_item_tri_draw(PanWindow *pw, PanItem *pi, GdkPixbuf *pixbuf, PixbufRenderer *pr, | |
293 gint x, gint y, gint width, gint height) | |
294 { | |
295 gint rx, ry, rw, rh; | |
296 | |
297 if (util_clip_region(x, y, width, height, | |
298 pi->x, pi->y, pi->width, pi->height, | |
299 &rx, &ry, &rw, &rh) && pi->data) | |
300 { | |
301 gint *coord = pi->data; | |
302 pixbuf_draw_triangle(pixbuf, | |
303 rx - x, ry - y, rw, rh, | |
304 coord[0] - x, coord[1] - y, | |
305 coord[2] - x, coord[3] - y, | |
306 coord[4] - x, coord[5] - y, | |
307 pi->color_r, pi->color_g, pi->color_b, pi->color_a); | |
308 | |
309 if (pi->border & PAN_BORDER_1) | |
310 { | |
311 pixbuf_draw_line(pixbuf, | |
312 rx - x, ry - y, rw, rh, | |
313 coord[0] - x, coord[1] - y, | |
314 coord[2] - x, coord[3] - y, | |
315 pi->color2_r, pi->color2_g, pi->color2_b, pi->color2_a); | |
316 } | |
317 if (pi->border & PAN_BORDER_2) | |
318 { | |
319 pixbuf_draw_line(pixbuf, | |
320 rx - x, ry - y, rw, rh, | |
321 coord[2] - x, coord[3] - y, | |
322 coord[4] - x, coord[5] - y, | |
323 pi->color2_r, pi->color2_g, pi->color2_b, pi->color2_a); | |
324 } | |
325 if (pi->border & PAN_BORDER_3) | |
326 { | |
327 pixbuf_draw_line(pixbuf, | |
328 rx - x, ry - y, rw, rh, | |
329 coord[4] - x, coord[5] - y, | |
330 coord[0] - x, coord[1] - y, | |
331 pi->color2_r, pi->color2_g, pi->color2_b, pi->color2_a); | |
332 } | |
333 } | |
334 | |
335 return FALSE; | |
336 } | |
337 | |
338 | |
339 /* | |
340 *----------------------------------------------------------------------------- | |
341 * item text type | |
342 *----------------------------------------------------------------------------- | |
343 */ | |
344 | |
345 static PangoLayout *pan_item_text_layout(PanItem *pi, GtkWidget *widget) | |
346 { | |
347 PangoLayout *layout; | |
348 | |
349 layout = gtk_widget_create_pango_layout(widget, NULL); | |
350 | |
351 if (pi->text_attr & PAN_TEXT_ATTR_MARKUP) | |
352 { | |
353 pango_layout_set_markup(layout, pi->text, -1); | |
354 return layout; | |
355 } | |
356 | |
357 if (pi->text_attr & PAN_TEXT_ATTR_BOLD || | |
358 pi->text_attr & PAN_TEXT_ATTR_HEADING) | |
359 { | |
360 PangoAttrList *pal; | |
361 PangoAttribute *pa; | |
442 | 362 |
105 | 363 pal = pango_attr_list_new(); |
364 if (pi->text_attr & PAN_TEXT_ATTR_BOLD) | |
365 { | |
366 pa = pango_attr_weight_new(PANGO_WEIGHT_BOLD); | |
367 pa->start_index = 0; | |
368 pa->end_index = G_MAXINT; | |
369 pango_attr_list_insert(pal, pa); | |
370 } | |
371 if (pi->text_attr & PAN_TEXT_ATTR_HEADING) | |
372 { | |
373 pa = pango_attr_scale_new(PANGO_SCALE_LARGE); | |
374 pa->start_index = 0; | |
375 pa->end_index = G_MAXINT; | |
376 pango_attr_list_insert(pal, pa); | |
377 } | |
378 pango_layout_set_attributes(layout, pal); | |
379 pango_attr_list_unref(pal); | |
380 } | |
381 | |
382 pango_layout_set_text(layout, pi->text, -1); | |
383 return layout; | |
384 } | |
385 | |
386 static void pan_item_text_compute_size(PanItem *pi, GtkWidget *widget) | |
387 { | |
388 PangoLayout *layout; | |
389 | |
390 if (!pi || !pi->text || !widget) return; | |
391 | |
392 layout = pan_item_text_layout(pi, widget); | |
393 pango_layout_get_pixel_size(layout, &pi->width, &pi->height); | |
394 g_object_unref(G_OBJECT(layout)); | |
395 | |
396 pi->width += pi->border * 2; | |
397 pi->height += pi->border * 2; | |
398 } | |
399 | |
400 PanItem *pan_item_text_new(PanWindow *pw, gint x, gint y, const gchar *text, | |
401 PanTextAttrType attr, PanBorderType border, | |
402 guint8 r, guint8 g, guint8 b, guint8 a) | |
403 { | |
404 PanItem *pi; | |
405 | |
406 pi = g_new0(PanItem, 1); | |
407 pi->type = PAN_ITEM_TEXT; | |
408 pi->x = x; | |
409 pi->y = y; | |
410 pi->text = g_strdup(text); | |
411 pi->text_attr = attr; | |
412 | |
413 pi->color_r = r; | |
414 pi->color_g = g; | |
415 pi->color_b = b; | |
416 pi->color_a = a; | |
417 | |
418 pi->border = border; | |
419 | |
420 pan_item_text_compute_size(pi, pw->imd->pr); | |
421 | |
422 pw->list = g_list_prepend(pw->list, pi); | |
423 | |
424 return pi; | |
425 } | |
426 | |
427 gint pan_item_text_draw(PanWindow *pw, PanItem *pi, GdkPixbuf *pixbuf, PixbufRenderer *pr, | |
428 gint x, gint y, gint width, gint height) | |
429 { | |
430 PangoLayout *layout; | |
431 | |
432 layout = pan_item_text_layout(pi, (GtkWidget *)pr); | |
433 pixbuf_draw_layout(pixbuf, layout, (GtkWidget *)pr, | |
434 pi->x - x + pi->border, pi->y - y + pi->border, | |
435 pi->color_r, pi->color_g, pi->color_b, pi->color_a); | |
436 g_object_unref(G_OBJECT(layout)); | |
437 | |
438 return FALSE; | |
439 } | |
440 | |
441 | |
442 /* | |
443 *----------------------------------------------------------------------------- | |
444 * item thumbnail type | |
445 *----------------------------------------------------------------------------- | |
446 */ | |
447 | |
448 PanItem *pan_item_thumb_new(PanWindow *pw, FileData *fd, gint x, gint y) | |
449 { | |
450 PanItem *pi; | |
451 | |
452 pi = g_new0(PanItem, 1); | |
453 pi->type = PAN_ITEM_THUMB; | |
454 pi->fd = fd; | |
455 pi->x = x; | |
456 pi->y = y; | |
457 pi->width = PAN_THUMB_SIZE + PAN_SHADOW_OFFSET * 2; | |
458 pi->height = PAN_THUMB_SIZE + PAN_SHADOW_OFFSET * 2; | |
459 | |
460 pi->pixbuf = NULL; | |
461 | |
462 pi->queued = FALSE; | |
463 | |
464 pw->list = g_list_prepend(pw->list, pi); | |
465 | |
466 return pi; | |
467 } | |
468 | |
469 gint pan_item_thumb_draw(PanWindow *pw, PanItem *pi, GdkPixbuf *pixbuf, PixbufRenderer *pr, | |
470 gint x, gint y, gint width, gint height) | |
471 { | |
472 gint tx, ty, tw, th; | |
473 gint rx, ry, rw, rh; | |
474 | |
475 if (pi->pixbuf) | |
476 { | |
477 tw = gdk_pixbuf_get_width(pi->pixbuf); | |
478 th = gdk_pixbuf_get_height(pi->pixbuf); | |
479 | |
480 tx = pi->x + (pi->width - tw) / 2; | |
481 ty = pi->y + (pi->height - th) / 2; | |
482 | |
483 if (gdk_pixbuf_get_has_alpha(pi->pixbuf)) | |
484 { | |
485 if (util_clip_region(x, y, width, height, | |
486 tx + PAN_SHADOW_OFFSET, ty + PAN_SHADOW_OFFSET, tw, th, | |
487 &rx, &ry, &rw, &rh)) | |
488 { | |
489 pixbuf_draw_shadow(pixbuf, | |
490 rx - x, ry - y, rw, rh, | |
491 tx + PAN_SHADOW_OFFSET - x, ty + PAN_SHADOW_OFFSET - y, tw, th, | |
492 PAN_SHADOW_FADE, | |
493 PAN_SHADOW_COLOR, PAN_SHADOW_ALPHA); | |
494 } | |
495 } | |
496 else | |
497 { | |
498 if (util_clip_region(x, y, width, height, | |
499 tx + tw, ty + PAN_SHADOW_OFFSET, | |
500 PAN_SHADOW_OFFSET, th - PAN_SHADOW_OFFSET, | |
501 &rx, &ry, &rw, &rh)) | |
502 { | |
503 pixbuf_draw_shadow(pixbuf, | |
504 rx - x, ry - y, rw, rh, | |
505 tx + PAN_SHADOW_OFFSET - x, ty + PAN_SHADOW_OFFSET - y, tw, th, | |
506 PAN_SHADOW_FADE, | |
507 PAN_SHADOW_COLOR, PAN_SHADOW_ALPHA); | |
508 } | |
509 if (util_clip_region(x, y, width, height, | |
510 tx + PAN_SHADOW_OFFSET, ty + th, tw, PAN_SHADOW_OFFSET, | |
511 &rx, &ry, &rw, &rh)) | |
512 { | |
513 pixbuf_draw_shadow(pixbuf, | |
514 rx - x, ry - y, rw, rh, | |
515 tx + PAN_SHADOW_OFFSET - x, ty + PAN_SHADOW_OFFSET - y, tw, th, | |
516 PAN_SHADOW_FADE, | |
517 PAN_SHADOW_COLOR, PAN_SHADOW_ALPHA); | |
518 } | |
519 } | |
520 | |
521 if (util_clip_region(x, y, width, height, | |
522 tx, ty, tw, th, | |
523 &rx, &ry, &rw, &rh)) | |
524 { | |
525 gdk_pixbuf_composite(pi->pixbuf, pixbuf, rx - x, ry - y, rw, rh, | |
1000
4fe8f9656107
For the sake of consistency, use glib basic types everywhere.
zas_
parents:
995
diff
changeset
|
526 (gdouble) tx - x, |
4fe8f9656107
For the sake of consistency, use glib basic types everywhere.
zas_
parents:
995
diff
changeset
|
527 (gdouble) ty - y, |
105 | 528 1.0, 1.0, GDK_INTERP_NEAREST, |
529 255); | |
530 } | |
531 | |
532 if (util_clip_region(x, y, width, height, | |
533 tx, ty, tw, PAN_OUTLINE_THICKNESS, | |
534 &rx, &ry, &rw, &rh)) | |
535 { | |
536 pixbuf_draw_rect_fill(pixbuf, | |
537 rx - x, ry - y, rw, rh, | |
538 PAN_OUTLINE_COLOR_1, PAN_OUTLINE_ALPHA); | |
539 } | |
540 if (util_clip_region(x, y, width, height, | |
541 tx, ty, PAN_OUTLINE_THICKNESS, th, | |
542 &rx, &ry, &rw, &rh)) | |
543 { | |
544 pixbuf_draw_rect_fill(pixbuf, | |
545 rx - x, ry - y, rw, rh, | |
546 PAN_OUTLINE_COLOR_1, PAN_OUTLINE_ALPHA); | |
547 } | |
548 if (util_clip_region(x, y, width, height, | |
549 tx + tw - PAN_OUTLINE_THICKNESS, ty + PAN_OUTLINE_THICKNESS, | |
550 PAN_OUTLINE_THICKNESS, th - PAN_OUTLINE_THICKNESS, | |
551 &rx, &ry, &rw, &rh)) | |
552 { | |
553 pixbuf_draw_rect_fill(pixbuf, | |
554 rx - x, ry - y, rw, rh, | |
555 PAN_OUTLINE_COLOR_2, PAN_OUTLINE_ALPHA); | |
556 } | |
557 if (util_clip_region(x, y, width, height, | |
558 tx + PAN_OUTLINE_THICKNESS, ty + th - PAN_OUTLINE_THICKNESS, | |
559 tw - PAN_OUTLINE_THICKNESS * 2, PAN_OUTLINE_THICKNESS, | |
560 &rx, &ry, &rw, &rh)) | |
561 { | |
562 pixbuf_draw_rect_fill(pixbuf, | |
563 rx - x, ry - y, rw, rh, | |
564 PAN_OUTLINE_COLOR_2, PAN_OUTLINE_ALPHA); | |
565 } | |
566 } | |
567 else | |
568 { | |
569 tw = pi->width - PAN_SHADOW_OFFSET * 2; | |
570 th = pi->height - PAN_SHADOW_OFFSET * 2; | |
571 tx = pi->x + PAN_SHADOW_OFFSET; | |
572 ty = pi->y + PAN_SHADOW_OFFSET; | |
573 | |
574 if (util_clip_region(x, y, width, height, | |
575 tx, ty, tw, th, | |
576 &rx, &ry, &rw, &rh)) | |
577 { | |
578 gint d; | |
579 | |
580 d = (pw->size <= PAN_IMAGE_SIZE_THUMB_NONE) ? 2 : 8; | |
581 pixbuf_draw_rect_fill(pixbuf, | |
582 rx - x, ry - y, rw, rh, | |
583 PAN_SHADOW_COLOR, | |
584 PAN_SHADOW_ALPHA / d); | |
585 } | |
586 } | |
587 | |
588 return (pi->pixbuf == NULL); | |
589 } | |
590 | |
591 | |
592 /* | |
593 *----------------------------------------------------------------------------- | |
594 * item image type | |
595 *----------------------------------------------------------------------------- | |
596 */ | |
597 | |
598 static void pan_item_image_find_size(PanWindow *pw, PanItem *pi, gint w, gint h) | |
599 { | |
600 GList *work; | |
601 | |
602 pi->width = w; | |
603 pi->height = h; | |
604 | |
605 if (!pi->fd) return; | |
606 | |
607 work = pw->cache_list; | |
608 while (work) | |
609 { | |
610 PanCacheData *pc; | |
611 | |
612 pc = work->data; | |
613 work = work->next; | |
614 | |
615 if (pc->cd && pc->cd->dimensions && | |
138 | 616 pc->fd && pc->fd == pi->fd) |
105 | 617 { |
618 pi->width = MAX(1, pc->cd->width * pw->image_size / 100); | |
619 pi->height = MAX(1, pc->cd->height * pw->image_size / 100); | |
620 | |
621 pw->cache_list = g_list_remove(pw->cache_list, pc); | |
622 cache_sim_data_free(pc->cd); | |
138 | 623 file_data_unref(pc->fd); |
624 g_free(pc); | |
105 | 625 return; |
626 } | |
627 } | |
628 } | |
629 | |
630 PanItem *pan_item_image_new(PanWindow *pw, FileData *fd, gint x, gint y, gint w, gint h) | |
631 { | |
632 PanItem *pi; | |
633 | |
634 pi = g_new0(PanItem, 1); | |
635 pi->type = PAN_ITEM_IMAGE; | |
636 pi->fd = fd; | |
637 pi->x = x; | |
638 pi->y = y; | |
639 | |
640 pi->color_a = 255; | |
641 | |
642 pi->color2_r = 0; | |
643 pi->color2_g = 0; | |
644 pi->color2_b = 0; | |
645 pi->color2_a = PAN_SHADOW_ALPHA / 2; | |
646 | |
647 pan_item_image_find_size(pw, pi, w, h); | |
648 | |
649 pw->list = g_list_prepend(pw->list, pi); | |
650 | |
651 return pi; | |
652 } | |
653 | |
654 gint pan_item_image_draw(PanWindow *pw, PanItem *pi, GdkPixbuf *pixbuf, PixbufRenderer *pr, | |
655 gint x, gint y, gint width, gint height) | |
656 { | |
657 gint rx, ry, rw, rh; | |
658 | |
659 if (util_clip_region(x, y, width, height, | |
660 pi->x, pi->y, pi->width, pi->height, | |
661 &rx, &ry, &rw, &rh)) | |
662 { | |
663 if (pi->pixbuf) | |
664 { | |
665 gdk_pixbuf_composite(pi->pixbuf, pixbuf, rx - x, ry - y, rw, rh, | |
1000
4fe8f9656107
For the sake of consistency, use glib basic types everywhere.
zas_
parents:
995
diff
changeset
|
666 (gdouble) pi->x - x, |
4fe8f9656107
For the sake of consistency, use glib basic types everywhere.
zas_
parents:
995
diff
changeset
|
667 (gdouble) pi->y - y, |
105 | 668 1.0, 1.0, GDK_INTERP_NEAREST, |
669 pi->color_a); | |
670 } | |
671 else | |
672 { | |
673 pixbuf_draw_rect_fill(pixbuf, | |
674 rx - x, ry - y, rw, rh, | |
675 pi->color2_r, pi->color2_g, pi->color2_b, pi->color2_a); | |
676 } | |
677 } | |
678 | |
679 return (pi->pixbuf == NULL); | |
680 } | |
681 | |
682 | |
683 /* | |
684 *----------------------------------------------------------------------------- | |
685 * item lookup/search | |
686 *----------------------------------------------------------------------------- | |
687 */ | |
688 | |
689 PanItem *pan_item_find_by_key(PanWindow *pw, PanItemType type, const gchar *key) | |
690 { | |
691 GList *work; | |
692 | |
693 if (!key) return NULL; | |
694 | |
695 work = g_list_last(pw->list); | |
696 while (work) | |
697 { | |
698 PanItem *pi; | |
699 | |
700 pi = work->data; | |
701 if ((pi->type == type || type == PAN_ITEM_NONE) && | |
702 pi->key && strcmp(pi->key, key) == 0) | |
703 { | |
704 return pi; | |
705 } | |
706 work = work->prev; | |
707 } | |
708 work = g_list_last(pw->list_static); | |
709 while (work) | |
710 { | |
711 PanItem *pi; | |
712 | |
713 pi = work->data; | |
714 if ((pi->type == type || type == PAN_ITEM_NONE) && | |
715 pi->key && strcmp(pi->key, key) == 0) | |
716 { | |
717 return pi; | |
718 } | |
719 work = work->prev; | |
720 } | |
721 | |
722 return NULL; | |
723 } | |
724 | |
725 /* when ignore_case and partial are TRUE, path should be converted to lower case */ | |
726 static GList *pan_item_find_by_path_l(GList *list, GList *search_list, | |
727 PanItemType type, const gchar *path, | |
728 gint ignore_case, gint partial) | |
729 { | |
730 GList *work; | |
731 | |
732 work = g_list_last(search_list); | |
733 while (work) | |
734 { | |
735 PanItem *pi; | |
736 | |
737 pi = work->data; | |
738 if ((pi->type == type || type == PAN_ITEM_NONE) && pi->fd) | |
739 { | |
740 gint match = FALSE; | |
741 | |
726 | 742 if (path[0] == G_DIR_SEPARATOR) |
105 | 743 { |
744 if (pi->fd->path && strcmp(path, pi->fd->path) == 0) match = TRUE; | |
745 } | |
746 else if (pi->fd->name) | |
747 { | |
748 if (partial) | |
749 { | |
750 if (ignore_case) | |
751 { | |
752 gchar *haystack; | |
753 | |
754 haystack = g_utf8_strdown(pi->fd->name, -1); | |
755 match = (strstr(haystack, path) != NULL); | |
756 g_free(haystack); | |
757 } | |
758 else | |
759 { | |
760 if (strstr(pi->fd->name, path)) match = TRUE; | |
761 } | |
762 } | |
763 else if (ignore_case) | |
764 { | |
765 if (strcasecmp(path, pi->fd->name) == 0) match = TRUE; | |
766 } | |
767 else | |
768 { | |
769 if (strcmp(path, pi->fd->name) == 0) match = TRUE; | |
770 } | |
771 } | |
772 | |
773 if (match) list = g_list_prepend(list, pi); | |
774 } | |
775 work = work->prev; | |
776 } | |
777 | |
778 return list; | |
779 } | |
780 | |
781 /* when ignore_case and partial are TRUE, path should be converted to lower case */ | |
782 GList *pan_item_find_by_path(PanWindow *pw, PanItemType type, const gchar *path, | |
783 gint ignore_case, gint partial) | |
784 { | |
785 GList *list = NULL; | |
786 | |
787 if (!path) return NULL; | |
726 | 788 if (partial && path[0] == G_DIR_SEPARATOR) return NULL; |
105 | 789 |
790 list = pan_item_find_by_path_l(list, pw->list_static, type, path, ignore_case, partial); | |
791 list = pan_item_find_by_path_l(list, pw->list, type, path, ignore_case, partial); | |
792 | |
793 return g_list_reverse(list); | |
794 } | |
795 | |
783 | 796 GList *pan_item_find_by_fd(PanWindow *pw, PanItemType type, FileData *fd, |
797 gint ignore_case, gint partial) | |
798 { | |
799 if (!fd) return NULL; | |
995 | 800 return pan_item_find_by_path(pw, type, fd->path, ignore_case, partial); |
783 | 801 } |
802 | |
803 | |
105 | 804 static PanItem *pan_item_find_by_coord_l(GList *list, PanItemType type, gint x, gint y, const gchar *key) |
805 { | |
806 GList *work; | |
807 | |
808 work = list; | |
809 while (work) | |
810 { | |
811 PanItem *pi; | |
812 | |
813 pi = work->data; | |
814 if ((pi->type == type || type == PAN_ITEM_NONE) && | |
815 x >= pi->x && x < pi->x + pi->width && | |
816 y >= pi->y && y < pi->y + pi->height && | |
817 (!key || (pi->key && strcmp(pi->key, key) == 0))) | |
818 { | |
819 return pi; | |
820 } | |
821 work = work->next; | |
822 } | |
823 | |
824 return NULL; | |
825 } | |
826 | |
827 PanItem *pan_item_find_by_coord(PanWindow *pw, PanItemType type, | |
828 gint x, gint y, const gchar *key) | |
829 { | |
830 PanItem *pi; | |
831 | |
832 pi = pan_item_find_by_coord_l(pw->list, type, x, y, key); | |
833 if (pi) return pi; | |
834 | |
835 return pan_item_find_by_coord_l(pw->list_static, type, x, y, key); | |
836 } | |
837 | |
838 | |
839 /* | |
840 *----------------------------------------------------------------------------- | |
841 * text alignments | |
842 *----------------------------------------------------------------------------- | |
843 */ | |
844 | |
845 PanTextAlignment *pan_text_alignment_new(PanWindow *pw, gint x, gint y, const gchar *key) | |
846 { | |
847 PanTextAlignment *ta; | |
848 | |
849 ta = g_new0(PanTextAlignment, 1); | |
850 | |
851 ta->pw = pw; | |
852 ta->column1 = NULL; | |
853 ta->column2 = NULL; | |
854 ta->x = x; | |
855 ta->y = y; | |
856 ta->key = g_strdup(key); | |
857 | |
858 return ta; | |
859 } | |
860 | |
861 void pan_text_alignment_free(PanTextAlignment *ta) | |
862 { | |
863 if (!ta) return; | |
864 | |
865 g_list_free(ta->column1); | |
866 g_list_free(ta->column2); | |
867 g_free(ta->key); | |
868 g_free(ta); | |
869 } | |
870 | |
871 PanItem *pan_text_alignment_add(PanTextAlignment *ta, const gchar *label, const gchar *text) | |
872 { | |
873 PanItem *item; | |
874 | |
875 if (label) | |
876 { | |
877 item = pan_item_text_new(ta->pw, ta->x, ta->y, label, | |
878 PAN_TEXT_ATTR_BOLD, 0, | |
879 PAN_POPUP_TEXT_COLOR, 255); | |
880 pan_item_set_key(item, ta->key); | |
881 } | |
882 else | |
883 { | |
884 item = NULL; | |
885 } | |
886 ta->column1 = g_list_append(ta->column1, item); | |
887 | |
888 if (text) | |
889 { | |
890 item = pan_item_text_new(ta->pw, ta->x, ta->y, text, | |
891 PAN_TEXT_ATTR_NONE, 0, | |
892 PAN_POPUP_TEXT_COLOR, 255); | |
893 pan_item_set_key(item, ta->key); | |
894 } | |
895 else | |
896 { | |
897 item = NULL; | |
898 } | |
899 ta->column2 = g_list_append(ta->column2, item); | |
900 | |
901 return item; | |
902 } | |
903 | |
904 void pan_text_alignment_calc(PanTextAlignment *ta, PanItem *box) | |
905 { | |
906 gint cw1, cw2; | |
907 gint x, y; | |
908 GList *work1; | |
909 GList *work2; | |
910 | |
911 cw1 = 0; | |
912 cw2 = 0; | |
913 | |
914 work1 = ta->column1; | |
915 while (work1) | |
916 { | |
917 PanItem *p; | |
918 | |
919 p = work1->data; | |
920 work1 = work1->next; | |
921 | |
922 if (p && p->width > cw1) cw1 = p->width; | |
923 } | |
924 | |
925 work2 = ta->column2; | |
926 while (work2) | |
927 { | |
928 PanItem *p; | |
929 | |
930 p = work2->data; | |
931 work2 = work2->next; | |
932 | |
933 if (p && p->width > cw2) cw2 = p->width; | |
934 } | |
935 | |
936 x = ta->x; | |
937 y = ta->y; | |
938 work1 = ta->column1; | |
939 work2 = ta->column2; | |
940 while (work1 && work2) | |
941 { | |
942 PanItem *p1; | |
943 PanItem *p2; | |
944 gint height = 0; | |
945 | |
946 p1 = work1->data; | |
947 p2 = work2->data; | |
948 work1 = work1->next; | |
949 work2 = work2->next; | |
950 | |
951 if (p1) | |
952 { | |
953 p1->x = x; | |
954 p1->y = y; | |
955 pan_item_size_by_item(box, p1, PREF_PAD_BORDER); | |
956 height = p1->height; | |
957 } | |
958 if (p2) | |
959 { | |
960 p2->x = x + cw1 + PREF_PAD_SPACE; | |
961 p2->y = y; | |
962 pan_item_size_by_item(box, p2, PREF_PAD_BORDER); | |
963 if (height < p2->height) height = p2->height; | |
964 } | |
965 | |
966 if (!p1 && !p2) height = PREF_PAD_GROUP; | |
967 | |
968 y += height; | |
969 } | |
970 } | |
1055
1646720364cf
Adding a vim modeline to all files - patch by Klaus Ethgen
nadvornik
parents:
1000
diff
changeset
|
971 /* vim: set shiftwidth=8 softtabstop=0 cindent cinoptions={1s: */ |