?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Updated PCI IDs to latest snapshot.
[tangerine.git] / workbench / libs / muimaster / imspec.c
blob6fc392933b6f1cb5b34c72d949a76945daaf3d6f
1 /*
2 Copyright 1999, David Le Corfec.
3 Copyright 2002-2007, The AROS Development Team.
4 All rights reserved.
5
6 $Id$
7 */
8
9 /* This is the implementation of a MUI-like image engine
10 * (see MUIA_Image_Spec for more information about MUI image specs)
11 * Their external form is a string "<type>:<parameters>"
12 * with type being a single char. See zune_image_spec_to_structure().
13 *
14 * Basically an ImageSpec can be anything which can be displayed:
15 * gfx datas, drawing code, ...
16 * See ImageSpecType for the known types.
17 */
18
19 #include <string.h>
20 #include <stdio.h>
21 #include <stdlib.h>
22
23 #include <exec/types.h>
24 #include <exec/memory.h>
25
26 #include <graphics/gfxmacros.h>
27
28 #include <proto/exec.h>
29 #include <proto/graphics.h>
30 #include <proto/intuition.h>
31 #include <proto/dos.h>
32 #include <clib/alib_protos.h>
33
34 //#define MYDEBUG 1
35 #include "debug.h"
36
37 #include "mui.h"
38
39 #include "datatypescache.h"
40 #include "imspec.h"
41 #include "support.h"
42
43 #include "muimaster_intern.h"
44 #include "prefs.h"
45 #include "penspec.h"
46 #include "imspec_intern.h"
47
48 extern struct Library *MUIMasterBase;
49
50 static struct MUI_ImageSpec_intern *get_brush_imspec(CONST_STRPTR filename);
51
52 const static UWORD gridpattern1[] = {
53 0x5555,
54 0xaaaa,
55 };
56
57 const static UWORD gridpattern2[] = {
58 0x4444,
59 0x1111,
60 };
61
62 typedef struct {
63 MPen bg;
64 MPen fg;
65 const UWORD *pattern;
66 } MPattern;
67
68 const static MPattern patternPens[] = {
69 { MPEN_SHADOW, MPEN_BACKGROUND, gridpattern1 }, /* MUII_SHADOWBACK */
70 { MPEN_SHADOW, MPEN_FILL , gridpattern1 }, /* MUII_SHADOWFILL */
71 { MPEN_SHADOW, MPEN_SHINE , gridpattern1 }, /* MUII_SHADOWSHINE */
72 { MPEN_FILL, MPEN_BACKGROUND, gridpattern1 }, /* MUII_FILLBACK */
73 { MPEN_FILL, MPEN_SHINE , gridpattern1 }, /* MUII_FILLSHINE */
74 { MPEN_SHINE, MPEN_BACKGROUND, gridpattern1 }, /* MUII_SHINEBACK */
75 { MPEN_FILL, MPEN_BACKGROUND, gridpattern2 }, /* MUII_FILLBACK2 */
76 { MPEN_HALFSHINE, MPEN_BACKGROUND, gridpattern1 }, /* MUII_HSHINEBACK */
77 { MPEN_HALFSHADOW, MPEN_BACKGROUND, gridpattern1 }, /* MUII_HSHADOWBACK */
78 { MPEN_HALFSHINE, MPEN_SHINE , gridpattern1 }, /* MUII_HSHINESHINE */
79 { MPEN_HALFSHADOW, MPEN_SHADOW , gridpattern1 }, /* MUII_HSHADOWSHADOW */
80 { MPEN_MARK, MPEN_SHINE , gridpattern1 }, /* MUII_MARKSHINE */
81 { MPEN_MARK, MPEN_HALFSHINE , gridpattern1 }, /* MUII_MARKHALFSHINE */
82 { MPEN_MARK, MPEN_BACKGROUND, gridpattern1 }, /* MUII_MARKBACKGROUND */
83 };
84
85 #define PATTERN_COUNT (MUII_LASTPAT - MUII_BACKGROUND + 1)
86
87 static struct MUI_ImageSpec_intern *get_pattern_imspec(LONG in)
88 {
89 struct MUI_ImageSpec_intern *spec = NULL;
90
91 if (in >= MUII_BACKGROUND && in <= MUII_FILL)
92 {
93 if ((spec = mui_alloc_struct(struct MUI_ImageSpec_intern)))
94 {
95 UWORD color;
96 if (in == MUII_BACKGROUND) color = MPEN_BACKGROUND;
97 else if (in == MUII_SHADOW) color = MPEN_SHADOW;
98 else if (in == MUII_SHINE) color = MPEN_SHINE;
99 else color = MPEN_FILL;
100
101 spec->type = IST_COLOR;
102 zune_penspec_fill_muipen(&spec->u.penspec, color);
103 }
104 return spec;
105 }
106 else if (in >= MUII_SHADOWBACK && in <= MUII_MARKBACKGROUND)
107 {
108 if ((spec = mui_alloc_struct(struct MUI_ImageSpec_intern)))
109 {
110 spec->type = IST_PATTERN;
111 spec->u.pattern = in - MUII_SHADOWBACK;
112 }
113 return spec;
114 }
115 return NULL;
116 }
117
118
119 static struct MUI_ImageSpec_intern *get_pen_imspec(CONST_STRPTR str)
120 {
121 struct MUI_ImageSpec_intern *spec;
122
123 if ((spec = mui_alloc_struct(struct MUI_ImageSpec_intern)))
124 {
125 if (!zune_pen_string_to_intern(str, &spec->u.penspec))
126 {
127 D(bug("*** zune_pen_string_to_intern failed\n"));
128 mui_free(spec);
129 return NULL;
130 }
131 spec->type = IST_COLOR;
132 return spec;
133 }
134 return NULL;
135 }
136
137 static struct MUI_ImageSpec_intern *get_scaled_gradient_imspec(CONST_STRPTR str)
138 {
139 struct MUI_ImageSpec_intern *spec;
140
141 if ((spec = mui_alloc_struct(struct MUI_ImageSpec_intern)))
142 {
143 if (!zune_gradient_string_to_intern(str, spec))
144 {
145 D(bug("*** zune_gradient_string_to_intern failed\n"));
146 mui_free(spec);
147 return NULL;
148 }
149 spec->type = IST_SCALED_GRADIENT;
150 return spec;
151 }
152 return NULL;
153 }
154
155 static struct MUI_ImageSpec_intern *get_tiled_gradient_imspec(CONST_STRPTR str)
156 {
157 struct MUI_ImageSpec_intern *spec;
158
159 if ((spec = mui_alloc_struct(struct MUI_ImageSpec_intern)))
160 {
161 if (!zune_gradient_string_to_intern(str, spec))
162 {
163 D(bug("*** zune_gradient_string_to_intern failed\n"));
164 mui_free(spec);
165 return NULL;
166 }
167 spec->type = IST_TILED_GRADIENT;
168 return spec;
169 }
170 return NULL;
171 }
172
173 static struct MUI_ImageSpec_intern *get_boopsi_imspec(CONST_STRPTR filename)
174 {
175 struct MUI_ImageSpec_intern *spec;
176
177 if (!filename)
178 return NULL;
179 if (!strstr(filename, ".image"))
180 return get_brush_imspec(filename);
181
182 if ((spec = mui_alloc_struct(struct MUI_ImageSpec_intern)))
183 {
184 spec->u.boopsi.filename = StrDup(filename);
185 if (!spec->u.boopsi.filename)
186 return NULL;
187 spec->u.boopsi.obj = NULL;
188 spec->type = IST_BOOPSI;
189 return spec;
190 }
191 return NULL;
192 }
193
194
195 static struct MUI_ImageSpec_intern *get_brush_imspec(CONST_STRPTR filename)
196 {
197 struct MUI_ImageSpec_intern *spec;
198 if ((spec = mui_alloc_struct(struct MUI_ImageSpec_intern)))
199 {
200 size_t last_idx;
201 spec->u.brush.filename[0] = StrDup(filename);
202 if (!spec->u.brush.filename[0])
203 return NULL;
204 last_idx = strlen(spec->u.brush.filename[0]) - 1;
205 if (spec->u.brush.filename[0][last_idx] == '0')
206 {
207 char *tmpstr;
208 tmpstr = StrDup(filename);
209 if (!tmpstr)
210 {
211 FreeVec((APTR)spec->u.brush.filename[0]);
212 return NULL;
213 }
214 tmpstr[last_idx] = '1';
215 spec->u.brush.filename[1] = tmpstr;
216 }
217 spec->u.brush.dt[0] = NULL;
218 spec->u.brush.dt[1] = NULL;
219 spec->type = IST_BRUSH;
220 return spec;
221 }
222 return NULL;
223 }
224
225
226 static struct MUI_ImageSpec_intern *get_bitmap_imspec(CONST_STRPTR filename)
227 {
228 struct MUI_ImageSpec_intern *spec;
229 if ((spec = mui_alloc_struct(struct MUI_ImageSpec_intern)))
230 {
231 spec->u.bitmap.filename = StrDup(filename);
232 if (!spec->u.bitmap.filename)
233 return NULL;
234 spec->u.bitmap.dt = NULL;
235 spec->type = IST_BITMAP;
236 return spec;
237 }
238 return NULL;
239 }
240
241
242 static struct MUI_ImageSpec_intern *get_config_imspec(LONG img)
243 {
244 if ((img >= MUII_WindowBack) && (img <= MUII_ReadListBack))
245 {
246 struct MUI_ImageSpec_intern *spec;
247 if ((spec = mui_alloc_struct(struct MUI_ImageSpec_intern)))
248 {
249 spec->u.cfg.muiimg = img;
250 spec->type = IST_CONFIG;
251 return spec;
252 }
253 }
254 return NULL;
255 }
256
257
258 #ifdef MYDEBUG
259 static const char *zune_imspec_to_string(struct MUI_ImageSpec_intern *spec)
260 {
261 static char buf[64];
262
263 if (!spec)
264 {
265 buf[0] = 0;
266 return buf;
267 }
268 switch (spec->type)
269 {
270 case IST_PATTERN:
271 sprintf(buf, "0:%ld", spec->u.pattern);
272 break;
273
274 case IST_VECTOR:
275 sprintf(buf, "1:%ld", spec->u.vect.type);
276 break;
277
278 case IST_COLOR:
279 zune_pen_intern_to_spec(&spec->u.penspec, (struct MUI_PenSpec *)buf);
280 break;
281
282 case IST_BOOPSI:
283 sprintf(buf, "3:%s", spec->u.boopsi.filename);
284 break;
285
286 case IST_BRUSH: /* this is really 3: too */
287 sprintf(buf, "3:%s", spec->u.brush.filename[0]);
288 break;
289
290 case IST_BITMAP:
291 sprintf(buf, "5:%s", spec->u.bitmap.filename);
292 break;
293
294 case IST_CONFIG:
295 sprintf(buf, "6:%ld", spec->u.cfg.muiimg);
296 break;
297
298 case IST_SCALED_GRADIENT:
299 zune_scaled_gradient_intern_to_string(spec, buf);
300 break;
301
302 case IST_TILED_GRADIENT:
303 zune_tiled_gradient_intern_to_string(spec, buf);
304 break;
305 }
306 return buf;
307 }
308 #endif
309
310 /**************************************************************************
311 Create a image spec from a string or a magic value.
312 in : contains magic or string
313 obj: is a AreaObject. It is used to access the config data.
314
315 TODO: merge this with zune_imspec_setup() because this function should
316 be called in MUIM_Setup (configdata)
317 **************************************************************************/
318 static struct MUI_ImageSpec_intern *zune_image_spec_to_structure(IPTR in)
319 {
320 struct MUI_ImageSpec_intern *spec = NULL;
321 CONST_STRPTR s;
322
323 if (in >= MUII_WindowBack && in <= MUII_ReadListBack)
324 {
325 D(bug("zune_image_spec_to_structure [config] : in=%ld\n", in));
326 spec = get_config_imspec(in);
327 }
328 else if (in >= MUII_BACKGROUND && in <= MUII_MARKBACKGROUND)
329 {
330 D(bug("zune_image_spec_to_structure [pattern] : in=%ld\n", in));
331 spec = get_pattern_imspec(in);
332 }
333 else
334 {
335 s = (CONST_STRPTR)in;
336 D(bug("zune_image_spec_to_structure [string] : in=%s\n", s));
337
338 switch (*s)
339 {
340 case '0': /* builtin pattern */
341 {
342 LONG pat;
343 StrToLong(s+2, &pat);
344 spec = get_pattern_imspec(pat);
345 break;
346 }
347
348 case '1': /* builtin standard image, obsoleted by 6: */
349 {
350 LONG vect;
351 StrToLong(s+2, &vect);
352 spec = zune_imspec_create_vector(vect);
353 break;
354 }
355
356 case '2': /* a penspec */
357 spec = get_pen_imspec(s+2);
358 D(bug("zune_image_spec_to_structure : penspec %lx\n", &spec->u.penspec));
359 break;
360
361 case '3': /* BOOPSI image class name */
362 spec = get_boopsi_imspec(s+2);
363 break;
364
365 case '4': /* external MUI brush name */
366 spec = get_brush_imspec(s+2);
367 break;
368
369 case '5': /* external bitmap loaded with datatypes */
370 spec = get_bitmap_imspec(s+2);
371 break;
372
373 case '6': /* preconfigured image or background */
374 {
375 LONG img;
376 StrToLong(s+2, &img);
377
378 if (img >= MUII_WindowBack && img <= MUII_ReadListBack)
379 spec = get_config_imspec(img);
380 break;
381 }
382
383 case '7': /* scaled gradient */
384 spec = get_scaled_gradient_imspec(s+2);
385 break;
386
387 case '8': /* tiled gradient */
388 spec = get_tiled_gradient_imspec(s+2);
389 break;
390
391 } /* switch(*s) */
392 }
393 D(bug("zune_image_spec_to_structure : out=0x%lx [%s]\n",
394 spec, zune_imspec_to_string(spec)));
395 return spec;
396 }
397
398 #if 0
399 static struct MUI_ImageSpec_intern *zune_imspec_copy(struct MUI_ImageSpec_intern *spec)
400 {
401 struct MUI_ImageSpec_intern *nspec;
402
403 if (!spec) return NULL;
404
405 nspec = mui_alloc_struct(struct MUI_ImageSpec_intern);
406 if (nspec) memcpy(nspec,spec,sizeof(struct MUI_ImageSpec_intern));
407 return nspec;
408 }
409 #endif
410
411
412
413 static void zune_imspec_free(struct MUI_ImageSpec_intern *spec)
414 {
415 if (!spec)
416 return;
417 D(bug("zune_imspec_free(0x%lx) [%s]\n",
418 spec, zune_imspec_to_string(spec)));
419
420 switch (spec->type)
421 {
422 case IST_BOOPSI:
423 if (spec->u.boopsi.filename)
424 FreeVec((APTR)spec->u.boopsi.filename);
425 break;
426
427 case IST_BRUSH:
428 if (spec->u.brush.filename[0])
429 FreeVec((APTR)spec->u.brush.filename[0]);
430 if (spec->u.brush.filename[1])
431 FreeVec((APTR)spec->u.brush.filename[1]);
432 break;
433
434 case IST_BITMAP:
435 if (spec->u.bitmap.filename)
436 FreeVec((APTR)spec->u.bitmap.filename);
437 break;
438
439 default:
440 break;
441 }
442
443 mui_free(spec);
444 }
445
446 struct MUI_ImageSpec_intern *zune_imspec_setup(IPTR s, struct MUI_RenderInfo *mri)
447 {
448 struct MUI_ImageSpec_intern *spec;
449
450 if (!mri)
451 {
452 D(bug("zune_imspec_setup: param error: mri=%p\n", mri));
453 return NULL;
454 }
455
456 spec = zune_image_spec_to_structure(s);
457
458 D(bug("zune_imspec_setup(%lx) [%s]\n",
459 spec, zune_imspec_to_string(spec)));
460 if (!spec)
461 return NULL;
462
463 switch (spec->type)
464 {
465 case IST_PATTERN:
466 break;
467
468 case IST_VECTOR:
469 break;
470
471 case IST_COLOR:
472 zune_penspec_setup(&spec->u.penspec, mri);
473 break;
474
475 case IST_BOOPSI:
476 break;
477
478 case IST_BRUSH:
479 {
480 int i;
481
482 for (i = 0; i < 2; i++)
483 {
484 if (spec->u.brush.filename[i])
485 {
486 spec->u.brush.dt[i] = dt_load_picture
487 (
488 spec->u.brush.filename[i], mri->mri_Screen
489 );
490
491 if (!spec->u.brush.dt[i] && !strchr(spec->u.brush.filename[i], ':'))
492 {
493 int size;
494 STRPTR fullpath;
495
496 size = strlen(IMSPEC_EXTERNAL_PREFIX)
497 + strlen(spec->u.brush.filename[i]) + 1;
498 fullpath = (STRPTR)AllocVec(size, MEMF_ANY);
499
500 if (fullpath != NULL)
501 {
502 strcpy(fullpath, IMSPEC_EXTERNAL_PREFIX);
503 strcat(fullpath, spec->u.brush.filename[i]);
504 fullpath[size - 1] = 0;
505 spec->u.brush.dt[i] = dt_load_picture
506 (
507 fullpath, mri->mri_Screen
508 );
509 FreeVec(fullpath);
510 }
511 }
512 }
513 else
514 {
515 spec->u.brush.dt[i] = spec->u.brush.dt[0];
516 }
517 }
518 }
519 break;
520
521 case IST_BITMAP:
522 if (spec->u.bitmap.filename)
523 {
524 spec->u.bitmap.dt = dt_load_picture
525 (
526 spec->u.bitmap.filename, mri->mri_Screen
527 );
528 }
529 break;
530
531 case IST_CONFIG:
532 {
533 Object *win = mri->mri_WindowObject;
534 struct ZunePrefsNew *prefs = muiGlobalInfo(win)->mgi_Prefs;
535 /* potential for deadloop if Zune prefs images contain a 6: */
536 CONST_STRPTR spec_desc = prefs->imagespecs[spec->u.cfg.muiimg];
537 zune_imspec_free(spec);
538 spec = NULL;
539
540 if (spec_desc && (spec_desc[0] == '6'))
541 {
542 D(bug("*** zune_imspec_setup (%s recursive config)\n",
543 zune_imspec_to_string(spec)));
544 }
545 else
546 {
547 spec = zune_imspec_setup((IPTR)spec_desc, mri);
548 }
549 break;
550 }
551
552 case IST_SCALED_GRADIENT:
553 case IST_TILED_GRADIENT:
554 zune_gradientspec_setup(spec, mri);
555 break;
556 }
557 return spec;
558 }
559
560 /* bug : never called in textengine, fix this */
561 void zune_imspec_cleanup(struct MUI_ImageSpec_intern *spec)
562 {
563 if (!spec)
564 return;
565
566 D(bug("zune_imspec_cleanup(0x%lx) [%s]\n",
567 spec, zune_imspec_to_string(spec)));
568
569 switch (spec->type)
570 {
571 case IST_PATTERN:
572 break;
573
574 case IST_VECTOR:
575 break;
576
577 case IST_COLOR:
578 zune_penspec_cleanup(&spec->u.penspec);
579 break;
580
581 case IST_BOOPSI:
582 break;
583
584 case IST_BRUSH:
585 {
586 int i;
587
588 for (i = 0; i < 2; i++)
589 {
590 if (spec->u.brush.filename[i])
591 {
592 dt_dispose_picture(spec->u.brush.dt[i]);
593 }
594 spec->u.brush.dt[i] = NULL;
595 }
596 break;
597 }
598 case IST_BITMAP:
599 if (spec->u.bitmap.dt)
600 {
601 dt_dispose_picture(spec->u.bitmap.dt);
602 spec->u.bitmap.dt = NULL;
603 }
604 break;
605
606 case IST_CONFIG:
607 D(bug("*** zune_imspec_cleanup : IST_CONFIG\n"));
608 break;
609
610 case IST_SCALED_GRADIENT:
611 case IST_TILED_GRADIENT:
612 zune_gradientspec_cleanup(spec);
613 break;
614
615 }
616
617 zune_imspec_free(spec);
618 }
619
620
621 BOOL zune_imspec_askminmax(struct MUI_ImageSpec_intern *spec, struct MUI_MinMax *minmax)
622 {
623 if ((!spec) || (!minmax))
624 return FALSE;
625
626 switch (spec->type)
627 {
628 case IST_PATTERN:
629 case IST_SCALED_GRADIENT:
630 case IST_TILED_GRADIENT:
631 case IST_COLOR:
632 minmax->MinWidth = 3;
633 minmax->MinHeight = 3;
634 minmax->DefWidth = 8;
635 minmax->DefHeight = 8;
636 minmax->MaxWidth = MUI_MAXMAX;
637 minmax->MaxHeight = MUI_MAXMAX;
638 break;
639
640 case IST_VECTOR:
641 return zune_imspec_vector_get_minmax(spec, minmax);
642 break;
643
644 case IST_BOOPSI:
645 /* ??? */
646 break;
647
648 case IST_BRUSH:
649 if (spec->u.brush.dt[0])
650 {
651 char *straddr;
652 long len;
653 straddr = *(spec->u.brush.filename);
654 len = strlen(straddr);
655 if (len > 4)
656 {
657 if (strcmp(&straddr[len-4],".mim")==0)
658 {
659 minmax->MinWidth = dt_width(spec->u.brush.dt[0]) >> 1;
660 minmax->MinHeight = dt_height(spec->u.brush.dt[0]);
661 minmax->DefWidth = minmax->MinWidth;
662 minmax->DefHeight = minmax->MinHeight;
663 minmax->MaxWidth = minmax->MinWidth;
664 minmax->MaxHeight = minmax->MinHeight;
665 break;
666 }
667 }
668 minmax->MinWidth = dt_width(spec->u.brush.dt[0]);
669 minmax->MinHeight = dt_height(spec->u.brush.dt[0]);
670 minmax->DefWidth = minmax->MinWidth;
671 minmax->DefHeight = minmax->MinHeight;
672 minmax->MaxWidth = minmax->MinWidth;
673 minmax->MaxHeight = minmax->MinHeight;
674 }
675 else
676 {
677 minmax->MinWidth = 3;
678 minmax->MinHeight = 3;
679 minmax->DefWidth = 8;
680 minmax->DefHeight = 8;
681 minmax->MaxWidth = MUI_MAXMAX;
682 minmax->MaxHeight = MUI_MAXMAX;
683 return FALSE;
684 }
685 break;
686
687 case IST_BITMAP:
688 minmax->MinWidth = 3;
689 minmax->MinHeight = 3;
690 minmax->DefWidth = dt_width(spec->u.bitmap.dt);
691 minmax->DefHeight = dt_height(spec->u.bitmap.dt);
692 minmax->MaxWidth = MUI_MAXMAX;
693 minmax->MaxHeight = MUI_MAXMAX;
694 if (!spec->u.bitmap.dt)
695 return FALSE;
696 break;
697
698 case IST_CONFIG:
699 D(bug("*** zune_imspec_askminmax : IST_CONFIG\n"));
700 break;
701 }
702 return TRUE;
703 }
704
705
706 void zune_imspec_show(struct MUI_ImageSpec_intern *spec, Object *obj)
707 {
708 if ((!spec) || (!obj))
709 return;
710
711 D(bug("zune_imspec_show(0x%lx) [%s]\n", spec,
712 zune_imspec_to_string(spec)));
713
714 /* scaled gradient generation made here */
715 switch (spec->type)
716 {
717 case IST_CONFIG:
718 D(bug("*** zune_imspec_show : IST_CONFIG\n"));
719 break;
720
721 case IST_SCALED_GRADIENT:
722 case IST_TILED_GRADIENT:
723 spec->u.gradient.obj = obj;
724 break;
725
726 default:
727 break;
728 }
729 }
730
731
732 void zune_imspec_hide(struct MUI_ImageSpec_intern *spec)
733 {
734 if (!spec)
735 return;
736
737 D(bug("zune_imspec_hide(0x%lx) [%s]\n", spec,
738 zune_imspec_to_string(spec)));
739
740 switch (spec->type)
741 {
742 case IST_CONFIG:
743 D(bug("*** zune_imspec_hide : IST_CONFIG\n"));
744 break;
745 default:
746 break;
747 }
748 }
749
750
751 void zune_imspec_drawbuffered (struct MUI_ImageSpec_intern *spec, struct RastPort *rp, struct MUI_RenderInfo *mri,
752 LONG left, LONG top, LONG width, LONG height,
753 LONG xoffset, LONG yoffset, LONG state, LONG dx, LONG dy, WORD mode, LONG abs_l, LONG abs_t, LONG abs_r, LONG abs_b)
754 {
755 LONG right = left + width - 1;
756 LONG bottom = top + height - 1;
757 struct MUI_ImageSpec_intern def;
758
759 if (!spec)
760 {
761 D(bug("*** zune_imspec_draw called on null imspec\n"));
762 return;
763 }
764
765 if ((spec->type == IST_BITMAP && !spec->u.bitmap.dt)
766 || (spec->type == IST_BRUSH && !spec->u.brush.dt[0]))
767 {
768 def.type = IST_COLOR;
769 zune_penspec_fill_muipen(&def.u.penspec, MPEN_BACKGROUND);
770 spec = &def;
771 }
772
773 switch (spec->type)
774 {
775 case IST_PATTERN:
776 {
777 LONG fg = mri->mri_Pens[patternPens[spec->u.pattern].fg];
778 LONG bg = mri->mri_Pens[patternPens[spec->u.pattern].bg];
779 SetDrMd(rp, JAM2);
780 SetAPen(rp, fg);
781 SetBPen(rp, bg);
782 SetAfPt(rp, patternPens[spec->u.pattern].pattern, 1);
783 RectFill(rp, left-dx, top-dy, right-dx, bottom-dy);
784 SetAfPt(rp, NULL, 0);
785 }
786 break;
787
788 case IST_VECTOR:
789 if (spec->u.vect.draw)
790 {
791 spec->u.vect.draw(mri, left-dx, top-dy, width, height, state);
792 }
793 break;
794
795 case IST_COLOR:
796 zune_penspec_drawdirect(&spec->u.penspec, rp, mri, left-dx, top-dy, right-dx, bottom-dy);
797 break;
798
799 case IST_BOOPSI:
800 break;
801
802 case IST_BRUSH:
803 if (state < 0 || state > 1)
804 state = 0;
805 if (spec->u.brush.dt[state])
806 {
807 char *straddr;
808 long len;
809 straddr = *(spec->u.brush.filename);
810 len = strlen(straddr);
811 if (len > 4)
812 {
813 if (strcmp(&straddr[len-4],".mim")==0)
814 {
815 dt_put_mim_on_rastport(spec->u.brush.dt[0], mri->mri_RastPort,
816 left-dx, top-dy, state);
817 break;
818 }
819 }
820 dt_put_on_rastport(spec->u.brush.dt[state], mri->mri_RastPort,
821 left-dx, top-dy);
822 /* dt_put_on_rastport_tiled(spec->u.brush.dt[state], mri->mri_RastPort, */
823 /* left, top, right, bottom, */
824 /* xoffset - left, yoffset - top); */
825 }
826 break;
827
828 case IST_BITMAP:
829 if (spec->u.bitmap.dt)
830 {
831 dt_put_on_rastport_tiled(spec->u.bitmap.dt, rp,
832 left-dx, top-dy, right-dx, bottom-dy,
833 xoffset - left, yoffset - top);
834 }
835 break;
836
837 case IST_CONFIG:
838 D(bug("*** zune_imspec_draw : IST_CONFIG\n"));
839 break;
840
841 case IST_SCALED_GRADIENT:
842 if (mode == 0) zune_gradient_draw(spec, mri, left, top, right, bottom, 0, 0);
843 else zune_gradient_drawfast(spec, rp, mri, 1, abs_l, abs_t, abs_r, abs_b, left, top, right, bottom, xoffset, yoffset);
844 break;
845
846 case IST_TILED_GRADIENT:
847 if (mode == 0) zune_gradient_draw(spec, mri, left, top, right, bottom, xoffset, yoffset);
848 else zune_gradient_drawfast(spec, rp, mri, 1, abs_l, abs_t, abs_r, abs_b, left, top, right, bottom, xoffset, yoffset);
849 break;
850 }
851 }
852
853 void zune_imspec_draw (struct MUI_ImageSpec_intern *spec, struct MUI_RenderInfo *mri,
854 LONG left, LONG top, LONG width, LONG height,
855 LONG xoffset, LONG yoffset, LONG state)
856 {
857 zune_imspec_drawbuffered(spec, mri->mri_RastPort, mri, left, top, width, height, xoffset, yoffset, state, 0, 0, 0, left, top, left+width, top+height);
858 }
859
860 /**************************************************************************
861 Duplicates a image spec. In in may be one of the MUII_#? identifiers
862 (but it will always return a string).
863 The returned string must be freed with zune_image_spec_free() because
864 in the future it might be that the MUII_#? stuff is not converted to
865 a string
866 **************************************************************************/
867 STRPTR zune_image_spec_duplicate(IPTR in)
868 {
869 char *spec;
870 char spec_buf[20];
871
872 if (in >= MUII_WindowBack && in < MUII_BACKGROUND)
873 {
874 sprintf(spec_buf,"6:%ld",in);
875 spec = spec_buf;
876 } else
877 {
878 if (in >= MUII_BACKGROUND && in < MUII_LASTPAT)
879 {
880 sprintf(spec_buf,"0:%ld",in);
881 spec = spec_buf;
882 } else spec = (char*)in;
883 }
884
885 return StrDup(spec);
886 }
887
888 /**************************************************************************
889 Use this function to free the zune_image_spec_duplicate() result
890 **************************************************************************/
891 void zune_image_spec_free(CONST_STRPTR spec)
892 {
893 if (spec) FreeVec((APTR)spec);
894 }
A totally sweet operating system