?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Some fix for scrolling with lasso.
[tangerine.git] / workbench / libs / muimaster / classes / bitmap.c
blob67b4406cc35106e27599728ff3ef33d2bc9078f4
1 /*
2 Copyright © 2002-2006, The AROS Development Team. All rights reserved.
3 $Id$
4 */
5
6 #include <graphics/gfx.h>
7 #include <graphics/view.h>
8 #include <clib/alib_protos.h>
9 #include <cybergraphx/cybergraphics.h>
10 #include <proto/exec.h>
11 #include <proto/graphics.h>
12 #include <proto/utility.h>
13 #include <proto/cybergraphics.h>
14 #include <proto/intuition.h>
15 #include <proto/muimaster.h>
16
17 #include "mui.h"
18 #include "muimaster_intern.h"
19 #include "support.h"
20
21 #include <string.h>
22
23 extern struct Library *MUIMasterBase;
24
25 struct MUI_BitmapData
26 {
27 struct BitMap *bm, *remapped_bm;
28 ULONG *sourcecolors;
29 LONG width, height, precision, transparent;
30 UBYTE *mappingtable;
31 PLANEPTR mask;
32 WORD *remaptable;
33 BYTE usefriend;
34 };
35
36 static void remap_bitmap(struct IClass *cl, Object *obj)
37 {
38 struct MUI_BitmapData *data = INST_DATA(cl, obj);
39 struct BitMap *friendbm = NULL;
40 struct RastPort temprp, bmrp, *scrrp;
41 UBYTE *linebuffer;
42 ULONG *cgfxcoltab = NULL;
43 LONG bmflags = 0;
44 WORD bmdepth, bmwidth, bmheight, bmcols, x, y;
45
46 if (!data->mappingtable && !data->sourcecolors) return;
47 if (!data->bm || (data->width < 1) || (data->height < 1)) return;
48
49 /* Don't remap if bitmap is hicolor/truecolor */
50 if (GetBitMapAttr(data->bm, BMA_DEPTH) > 8) return;
51
52 if (!data->mappingtable && !data->remaptable)
53 {
54 data->remaptable = AllocVec(256 * sizeof(WORD), MEMF_PUBLIC | MEMF_CLEAR);
55 if (!data->remaptable) return;
56 }
57
58 scrrp = &_screen(obj)->RastPort;
59
60 if (data->usefriend)
61 {
62 friendbm = scrrp->BitMap;
63 bmflags |= BMF_MINPLANES;
64 }
65
66 linebuffer = AllocVec(data->width + 16, MEMF_PUBLIC);
67 if (!linebuffer) return;
68
69 bmdepth = GetBitMapAttr(scrrp->BitMap, BMA_DEPTH);
70 if (bmdepth > 8) bmdepth = 8;
71
72 bmcols = 1L << bmdepth;
73
74 data->remapped_bm = AllocBitMap(data->width, data->height, bmdepth, bmflags, friendbm);
75
76 if (!data->remapped_bm)
77 {
78 FreeVec(linebuffer);
79 return;
80 }
81
82 bmwidth = GetBitMapAttr(data->remapped_bm, BMA_WIDTH);
83 bmheight = GetBitMapAttr(data->remapped_bm, BMA_HEIGHT);
84
85 if (data->transparent != -1)
86 {
87 data->mask = AllocRaster(bmwidth,bmheight);
88 memset(data->mask, 0xff, RASSIZE(bmwidth, bmheight));
89 }
90
91 if (CyberGfxBase &&
92 !data->mappingtable &&
93 (GetBitMapAttr(data->remapped_bm, BMA_DEPTH) >= 15))
94 {
95 cgfxcoltab = AllocVec(bmcols * sizeof(ULONG), MEMF_ANY);
96
97 if (cgfxcoltab)
98 {
99 for(y = 0; y < bmcols; y++)
100 {
101 ULONG red = data->sourcecolors[y * 3] & 0xFF000000;
102 ULONG green = data->sourcecolors[y * 3 + 1] & 0xFF000000;
103 ULONG blue = data->sourcecolors[y * 3 + 2] & 0xFF000000;
104
105 cgfxcoltab[y] = (red >> 8) | (green >> 16) | (blue >> 24);
106 }
107 }
108
109 }
110
111 InitRastPort(&temprp);
112 temprp.BitMap = AllocBitMap(data->width, 1, 1, 0, NULL);
113
114 InitRastPort(&bmrp);
115
116 for(y = 0; y < data->height; y++)
117 {
118 /* Read a line from source bitmap */
119
120 bmrp.BitMap = data->bm;
121 if (temprp.BitMap)
122 {
123 ReadPixelLine8(&bmrp, 0, y, data->width, linebuffer, &temprp);
124 }
125 else
126 {
127 for(x = 0; x < data->width; x++)
128 {
129 linebuffer[x] = ReadPixel(&bmrp, x, y);
130 }
131 }
132
133 /* Build the mask, totaly slow but works */
134 if (data->mask)
135 {
136 UBYTE *mask = data->mask + y * bmwidth / 8;
137 UBYTE xmask = 0x80;
138
139 for(x = 0; x < data->width; x++)
140 {
141 if (linebuffer[x] == data->transparent)
142 {
143 *mask &= ~xmask;
144 }
145
146 xmask >>= 1;
147 if (!xmask)
148 {
149 xmask = 0x80;
150 mask++;
151 }
152 }
153 }
154
155 /* Remap the line */
156 if (data->mappingtable)
157 {
158 for(x = 0; x < data->width; x++)
159 {
160 linebuffer[x] = data->mappingtable[linebuffer[x]];
161 }
162 }
163 else if (!cgfxcoltab)
164 {
165 for(x = 0; x < data->width; x++)
166 {
167 UBYTE pixel = linebuffer[x];
168 UBYTE remappixel = data->remaptable[pixel];
169
170 if (!remappixel)
171 {
172 struct TagItem tags[3];
173 tags[0].ti_Tag = OBP_Precision;
174 tags[0].ti_Data = data->precision;
175 tags[1].ti_Tag = OBP_FailIfBad;
176 tags[1].ti_Data = FALSE;
177 tags[2].ti_Tag = 0;
178
179 data->remaptable[pixel] = remappixel = ObtainBestPenA(_screen(obj)->ViewPort.ColorMap,
180 data->sourcecolors[pixel * 3],
181 data->sourcecolors[pixel * 3 + 1],
182 data->sourcecolors[pixel * 3 + 2],
183 tags) | 0x100;
184 }
185
186 linebuffer[x] = (remappixel & 0xFF);
187 }
188
189 } /* else if (!cgfxcoltab) */
190
191 /* Write line into destination bitmap */
192
193 bmrp.BitMap = data->remapped_bm;
194
195 if (cgfxcoltab)
196 {
197 WriteLUTPixelArray(linebuffer,
198 0,
199 0,
200 data->width,
201 &bmrp,
202 cgfxcoltab,
203 0,
204 y,
205 data->width,
206 1,
207 CTABFMT_XRGB8);
208 }
209 else
210 {
211 bmrp.BitMap = data->remapped_bm;
212 if (temprp.BitMap)
213 {
214 WritePixelLine8(&bmrp, 0, y, data->width, linebuffer, &temprp);
215 }
216 else
217 {
218 for(x = 0; x < data->width; x++)
219 {
220 SetAPen(&bmrp, linebuffer[x]);
221 WritePixel(&bmrp, x, y);
222 }
223 }
224
225 }
226
227 } /* for(y = 0; y < data->height; y++) */
228
229 DeinitRastPort(&temprp);
230 DeinitRastPort(&bmrp);
231
232 if (temprp.BitMap)
233 {
234 WaitBlit();
235 FreeBitMap(temprp.BitMap);
236 }
237
238 FreeVec(cgfxcoltab);
239 FreeVec(linebuffer);
240 }
241
242 /**************************************************************************
243 OM_NEW
244 **************************************************************************/
245 IPTR Bitmap__OM_NEW(struct IClass *cl, Object *obj, struct opSet *msg)
246 {
247 struct MUI_BitmapData *data;
248 struct TagItem *tag, *tags;
249
250 obj = (Object *)DoSuperMethodA(cl, obj, (Msg)msg);
251 if (!obj) return FALSE;
252
253 data = INST_DATA(cl, obj);
254
255 data->precision = PRECISION_GUI;
256 data->transparent = -1;
257
258 /* parse initial taglist */
259
260 for (tags = msg->ops_AttrList; (tag = NextTagItem((const struct TagItem**)&tags)); )
261 {
262 switch (tag->ti_Tag)
263 {
264 case MUIA_Bitmap_Bitmap:
265 data->bm = (struct BitMap *)tag->ti_Data;
266 break;
267
268 case MUIA_Bitmap_Height:
269 data->height = (LONG)tag->ti_Data;
270 break;
271
272 case MUIA_Bitmap_MappingTable:
273 data->mappingtable = (UBYTE *)tag->ti_Data;
274 break;
275
276 case MUIA_Bitmap_Precision:
277 data->precision = (LONG)tag->ti_Data;
278 break;
279
280 case MUIA_Bitmap_SourceColors:
281 data->sourcecolors = (ULONG *)tag->ti_Data;
282 break;
283
284 case MUIA_Bitmap_Transparent:
285 data->transparent = (LONG)tag->ti_Data;
286 break;
287
288 case MUIA_Bitmap_UseFriend:
289 data->usefriend = (tag->ti_Data != 0);
290 break;
291
292 case MUIA_Bitmap_Width:
293 data->width = (LONG)tag->ti_Data;
294 break;
295
296 }
297 }
298
299 return (IPTR)obj;
300 }
301
302 /**************************************************************************
303 OM_DISPOSE
304 **************************************************************************/
305 IPTR Bitmap__OM_DISPOSE(struct IClass *cl, Object *obj, Msg msg)
306 {
307 struct MUI_BitmapData *data = INST_DATA(cl, obj);
308
309 if (data->remapped_bm)
310 {
311 WaitBlit();
312 FreeBitMap(data->remapped_bm);
313 }
314 if (data->remaptable) FreeVec(data->remaptable);
315
316 return DoSuperMethodA(cl, obj, msg);
317 }
318
319 /**************************************************************************
320 OM_SET
321 **************************************************************************/
322 IPTR Bitmap__OM_SET(struct IClass *cl, Object *obj, struct opSet *msg)
323 {
324 struct MUI_BitmapData *data = INST_DATA(cl, obj);
325 struct TagItem *tags = msg->ops_AttrList;
326 struct TagItem *tag;
327
328 while ((tag = NextTagItem((const struct TagItem**)&tags)) != NULL)
329 {
330 switch (tag->ti_Tag)
331 {
332 case MUIA_Bitmap_Bitmap:
333 if (!data->remapped_bm)
334 {
335 data->bm = (struct BitMap *)tag->ti_Data;
336 }
337 break;
338
339 case MUIA_Bitmap_Height:
340 data->height = (LONG)tag->ti_Data;
341 break;
342
343 case MUIA_Bitmap_MappingTable:
344 data->mappingtable = (UBYTE *)tag->ti_Data;
345 break;
346
347 case MUIA_Bitmap_Precision:
348 data->precision = (LONG)tag->ti_Data;
349 break;
350
351 case MUIA_Bitmap_SourceColors:
352 data->sourcecolors = (ULONG *)tag->ti_Data;
353 break;
354
355 case MUIA_Bitmap_Transparent:
356 data->transparent = (LONG)tag->ti_Data;
357 break;
358
359 case MUIA_Bitmap_Width:
360 data->width = (LONG)tag->ti_Data;
361 break;
362
363 }
364 }
365
366 return DoSuperMethodA(cl, obj, (Msg)msg);
367 }
368
369 /**************************************************************************
370 OM_GET
371 **************************************************************************/
372 IPTR Bitmap__OM_GET(struct IClass *cl, Object *obj, struct opGet *msg)
373 {
374 #define STORE *(msg->opg_Storage)
375
376 struct MUI_BitmapData *data = INST_DATA(cl, obj);
377
378 switch(msg->opg_AttrID)
379 {
380 case MUIA_Bitmap_Bitmap:
381 STORE = (IPTR)data->bm;
382 return TRUE;
383
384 case MUIA_Bitmap_Height:
385 STORE = (IPTR)data->height;
386 return TRUE;
387
388 case MUIA_Bitmap_MappingTable:
389 STORE = (IPTR)data->mappingtable;
390 return TRUE;
391
392 case MUIA_Bitmap_Precision:
393 STORE = (IPTR)data->precision;
394 return TRUE;
395
396 case MUIA_Bitmap_RemappedBitmap:
397 STORE = (IPTR)data->remapped_bm;
398 return TRUE;
399
400 case MUIA_Bitmap_SourceColors:
401 STORE = (IPTR)data->sourcecolors;
402 return TRUE;
403
404 case MUIA_Bitmap_Transparent:
405 STORE = (IPTR)data->transparent;
406 return TRUE;
407
408 case MUIA_Bitmap_Width:
409 STORE = (IPTR)data->width;
410 return TRUE;
411 }
412
413 return DoSuperMethodA(cl, obj, (Msg)msg);
414 #undef STORE
415 }
416
417 /**************************************************************************
418 MUIM_Setup
419 **************************************************************************/
420 IPTR Bitmap__MUIM_Setup(struct IClass *cl, Object *obj, Msg msg)
421 {
422 //struct MUI_BitmapData *data = INST_DATA(cl, obj);
423
424 if (!DoSuperMethodA(cl, obj, (Msg)msg))
425 return FALSE;
426
427 remap_bitmap(cl, obj);
428
429 return TRUE;
430 }
431
432 /**************************************************************************
433 MUIM_Cleanup
434 **************************************************************************/
435 IPTR Bitmap__MUIM_Cleanup(struct IClass *cl, Object *obj, Msg msg)
436 {
437 struct MUI_BitmapData *data = INST_DATA(cl, obj);
438
439 if (data->mask)
440 {
441 LONG bmwidth = GetBitMapAttr(data->remapped_bm, BMA_WIDTH);
442 LONG bmheight = GetBitMapAttr(data->remapped_bm, BMA_HEIGHT);
443 FreeRaster(data->mask,bmwidth,bmheight);
444
445 data->mask = NULL;
446 }
447
448 if (data->remapped_bm)
449 {
450 WaitBlit();
451 FreeBitMap(data->remapped_bm);
452 data->remapped_bm = NULL;
453
454 if (data->remaptable)
455 {
456 WORD i;
457
458 for(i = 0; i < 256; i++)
459 {
460 if (data->remaptable[i])
461 {
462 ReleasePen(_screen(obj)->ViewPort.ColorMap, data->remaptable[i] & 0xFF);
463 data->remaptable[i] = 0;
464 }
465 }
466 }
467 }
468
469 return DoSuperMethodA(cl, obj, (Msg)msg);
470 }
471
472 /**************************************************************************
473 MUIM_AskMinMax
474 **************************************************************************/
475 IPTR Bitmap__MUIM_AskMinMax(struct IClass *cl, Object *obj, struct MUIP_AskMinMax *msg)
476 {
477 DoSuperMethodA(cl, obj, (Msg)msg);
478
479 msg->MinMaxInfo->MinWidth += 1;
480 msg->MinMaxInfo->MinHeight += 1;
481
482 msg->MinMaxInfo->DefWidth += 1;
483 msg->MinMaxInfo->DefHeight += 1;
484
485 msg->MinMaxInfo->MaxWidth = MUI_MAXMAX;
486 msg->MinMaxInfo->MaxHeight = MUI_MAXMAX;
487
488 return TRUE;
489 }
490
491 /**************************************************************************
492 MUIM_Draw
493 **************************************************************************/
494 IPTR Bitmap__MUIM_Draw(struct IClass *cl, Object *obj, struct MUIP_Draw *msg)
495 {
496 struct MUI_BitmapData *data = INST_DATA(cl, obj);
497 struct BitMap *bm;
498
499 DoSuperMethodA(cl,obj,(Msg)msg);
500
501 bm = data->remapped_bm ? data->remapped_bm : data->bm;
502 if (bm)
503 {
504 LONG width, height;
505
506 width = data->width;
507 height = data->height;
508
509 if (width > _mwidth(obj)) width = _mwidth(obj);
510 if (height > _mheight(obj)) height = _mheight(obj);
511
512 if ((width > 0) && (height > 0))
513 {
514 if (data->mask)
515 {
516 BltMaskBitMapRastPort(bm, 0, 0, _rp(obj), _mleft(obj), _mtop(obj), width, height, 0xE0, data->mask);
517 }
518 else
519 {
520 BltBitMapRastPort(bm, 0, 0, _rp(obj), _mleft(obj), _mtop(obj), width, height, 0xC0);
521 }
522 }
523 }
524
525 return TRUE;
526 }
527
528
529 BOOPSI_DISPATCHER(IPTR, Bitmap_Dispatcher, cl, obj, msg)
530 {
531 switch (msg->MethodID)
532 {
533 case OM_NEW: return Bitmap__OM_NEW(cl, obj, (struct opSet *)msg);
534 case OM_DISPOSE: return Bitmap__OM_DISPOSE(cl, obj, msg);
535 case OM_SET: return Bitmap__OM_SET(cl, obj, (struct opSet *)msg);
536 case OM_GET: return Bitmap__OM_GET(cl, obj, (struct opGet *)msg);
537 case MUIM_Setup: return Bitmap__MUIM_Setup(cl, obj, msg);
538 case MUIM_Cleanup: return Bitmap__MUIM_Cleanup(cl, obj, msg);
539 case MUIM_AskMinMax: return Bitmap__MUIM_AskMinMax(cl, obj, (struct MUIP_AskMinMax *)msg);
540 case MUIM_Draw: return Bitmap__MUIM_Draw(cl, obj, (struct MUIP_Draw *)msg);
541 }
542
543 return DoSuperMethodA(cl, obj, msg);
544 }
545 BOOPSI_DISPATCHER_END
546
547 /*
548 * Class descriptor.
549 */
550 const struct __MUIBuiltinClass _MUI_Bitmap_desc = {
551 MUIC_Bitmap,
552 MUIC_Area,
553 sizeof(struct MUI_BitmapData),
554 (void*)Bitmap_Dispatcher
555 };
A totally sweet operating system