?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
grub2: bring back build of aros-side grub2 tools
[AROS.git] / workbench / libs / gadtools / paletteclass.c
blob65a7b59ad15c1d327ec734c7989da1d8f8f9d7f8
1 /*
2 Copyright © 1995-2005, The AROS Development Team. All rights reserved.
3 $Id$
4
5 Desc: Internal GadTools palette class.
6 Lang: English
7 */
8
9
10 #include <proto/exec.h>
11 #include <exec/libraries.h>
12 #include <exec/memory.h>
13 #include <proto/dos.h>
14 #include <intuition/classes.h>
15 #include <intuition/classusr.h>
16 #include <intuition/gadgetclass.h>
17 #include <intuition/imageclass.h>
18 #include <intuition/intuition.h>
19 #include <intuition/cghooks.h>
20 #include <graphics/rastport.h>
21 #include <graphics/text.h>
22 #include <utility/tagitem.h>
23 #include <devices/inputevent.h>
24 #include <proto/alib.h>
25 #include <proto/utility.h>
26
27 #include <string.h> /* memset() */
28 #include <stdlib.h>
29
30 #define SDEBUG 0
31 #define DEBUG 0
32 #include <aros/debug.h>
33
34 #include "gadtools_intern.h"
35
36 /**********************************************************************************************/
37
38 #define HSPACING 2
39 #define VSPACING 2
40
41 #define HBORDER HSPACING
42 #define VBORDER VSPACING
43
44
45 #define HSELBORDER 1
46 #define VSELBORDER 1
47
48 #define GadToolsBase ((struct GadToolsBase_intern *)cl->cl_UserData)
49
50 /**********************************************************************************************/
51
52 STATIC VOID RenderFrame(struct PaletteData *data, struct RastPort *rp, struct IBox *gadbox,
53 struct DrawInfo *dri, BOOL recessed, BOOL edgesonly, Class *cl);
54
55 /**********************************************************************************************/
56
57 STATIC VOID GetGadgetIBox(struct Gadget *g, struct GadgetInfo *gi, struct IBox *ibox)
58 {
59 ibox->Left = g->LeftEdge;
60 ibox->Top = g->TopEdge;
61 ibox->Width = g->Width;
62 ibox->Height = g->Height;
63
64 if (gi)
65 {
66 if (g->Flags & GFLG_RELRIGHT)
67 ibox->Left += gi->gi_Domain.Width - 1;
68
69 if (g->Flags & GFLG_RELBOTTOM)
70 ibox->Top += gi->gi_Domain.Height - 1;
71
72 if (g->Flags & GFLG_RELWIDTH)
73 ibox->Width += gi->gi_Domain.Width;
74
75 if (g->Flags & GFLG_RELHEIGHT)
76 ibox->Height += gi->gi_Domain.Height;
77 }
78 }
79
80 /**********************************************************************************************/
81
82 STATIC UWORD GetPalettePen(struct PaletteData *data, UWORD idx)
83 {
84 UWORD pen;
85
86 if (data->pd_ColorTable)
87 pen = data->pd_ColorTable[idx];
88 else
89 pen = idx + data->pd_ColorOffset;
90
91 return (pen);
92 }
93
94 /**********************************************************************************************/
95
96 STATIC BOOL InsidePalette(struct PaletteData *data, WORD x, WORD y)
97 {
98 (void)data;
99 (void)x;
100 (void)y;
101
102 return TRUE;
103 }
104
105 /**********************************************************************************************/
106
107 STATIC UWORD ComputeColor(struct PaletteData *data, WORD x, WORD y)
108 {
109 UWORD row, col;
110
111 WORD color;
112
113 col = (x - data->pd_PaletteBox.Left) / data->pd_ColWidth;
114 row = (y - data->pd_PaletteBox.Top) / data->pd_RowHeight;
115
116 color = data->pd_NumCols *row + col;
117
118 if (color < 0)
119 {
120 color = 0;
121 }
122 else if (color >= data->pd_NumColors)
123 {
124 color = data->pd_NumColors - 1;
125 }
126
127 return (UWORD)color;
128 }
129
130 /**********************************************************************************************/
131
132 #define MIN(a, b) (( a < b) ? a : b)
133
134 STATIC VOID RenderPalette(struct PaletteData *data, struct RastPort *rp, Class *cl)
135 {
136 UWORD currentcolor = data->pd_ColorOffset, colors_left;
137 WORD left, top;
138 register UWORD col, row;
139 struct IBox *pbox = &(data->pd_PaletteBox);
140
141 EnterFunc(bug("RenderPalette(data=%p, rp=%p)\n", data, rp));
142
143 top = pbox->Top;
144
145 colors_left = data->pd_NumColors;
146 SetDrMd(rp, JAM1);
147
148 for (row = data->pd_NumRows; row; row --)
149 {
150 left = pbox->Left;
151 for (col = MIN(data->pd_NumCols, colors_left); col; col --)
152 {
153
154 SetAPen(rp, GetPalettePen(data, currentcolor));
155
156 RectFill( rp, left, top,
157 left + data->pd_ColWidth - VSPACING - 1,
158 top + data->pd_RowHeight - HSPACING - 1 );
159
160 D(bug( "Rectfilling area (%d, %d, %d, %d)\n with color %d", left, top,
161 left + data->pd_ColWidth - VSPACING - 1, top + data->pd_RowHeight - HSPACING,
162 currentcolor));
163
164 currentcolor ++;
165
166 left += data->pd_ColWidth;
167
168 } /* for (each row) */
169 top += data->pd_RowHeight;
170
171 colors_left -= data->pd_NumCols;
172
173 } /* for (each column) */
174
175 ReturnVoid("RenderPalette");
176 }
177
178 /**********************************************************************************************/
179
180 VOID UpdateActiveColor( struct PaletteData *data,
181 struct DrawInfo *dri,
182 struct RastPort *rp,
183 Class *cl)
184 {
185 struct IBox framebox;
186 WORD left, top, right, bottom;
187
188 EnterFunc(bug("UpdateActiveColor(data=%p, dri=%p, rp=%p)\n",
189 data, dri, rp));
190
191 SetAPen(rp, dri->dri_Pens[BACKGROUNDPEN]);
192 SetDrMd(rp, JAM1);
193
194 if (data->pd_OldColor != data->pd_Color)
195 {
196
197 left = data->pd_PaletteBox.Left + (data->pd_OldColor % data->pd_NumCols) *data->pd_ColWidth;
198 top = data->pd_PaletteBox.Top + (data->pd_OldColor / data->pd_NumCols) *data->pd_RowHeight;
199
200 D(bug( "clearing old selected: (%d, %d, %d, %d) oldcolor=%d\n",
201 left, top, left + data->pd_ColWidth, top + data->pd_RowHeight, data->pd_OldColor));
202
203 /* Clear area with BACKGROUNDPEN */
204 RectFill( rp,
205 left - VBORDER,
206 top - HBORDER,
207 left + data->pd_ColWidth - 1,
208 top + data->pd_RowHeight - 1);
209
210 /* Rerender in original color */
211 SetAPen(rp, GetPalettePen(data, data->pd_OldColor + data->pd_ColorOffset));
212
213 RectFill( rp, left, top,
214 left + data->pd_ColWidth - VSPACING - 1,
215 top + data->pd_RowHeight - HSPACING - 1);
216
217 }
218
219 left = data->pd_PaletteBox.Left + (data->pd_Color % data->pd_NumCols) *data->pd_ColWidth;
220 top = data->pd_PaletteBox.Top + (data->pd_Color / data->pd_NumCols) *data->pd_RowHeight;
221
222 /* Right & bottom of *colored* area */
223 right = left + data->pd_ColWidth - VSPACING - 1;
224 bottom = top + data->pd_RowHeight - HSPACING - 1;
225
226 /* Render new active entry */
227 D(bug( "rendering new selected: (%d, %d, %d, %d), color=%d\n",
228 left, top, right, bottom, data->pd_Color));
229
230
231 if ((right - left >= 6) && (bottom - top >= 6))
232 {
233 /* Draw some borders */
234
235 SetAPen(rp, dri->dri_Pens[BACKGROUNDPEN]);
236
237 /* We draw left & right from top to bottom, but draw top & bottom
238 ** so they don't overlap with what's allready drawn
239 */
240
241 /* left */
242 RectFill( rp, left, top,
243 left + 1, bottom);
244
245 /* right */
246 RectFill( rp, right - 1, top,
247 right, bottom);
248
249 /* top */
250 RectFill( rp, left + 2, top,
251 right - 2, top + 1);
252
253 /* bottom */
254 RectFill( rp, left + 2, bottom - 1,
255 right - 2, bottom);
256 }
257
258 /* Draw recessed frame around selected color */
259 framebox.Left = left - VBORDER;
260 framebox.Top = top - HBORDER;
261 framebox.Width = data->pd_ColWidth + VBORDER;
262 framebox.Height = data->pd_RowHeight + HBORDER;
263
264 RenderFrame(data, rp, &framebox, dri, TRUE, TRUE, cl);
265
266 /* The newly update color becomes the new OldColor */
267 data->pd_OldColor = data->pd_Color;
268
269 ReturnVoid("UpdateActiveColor");
270 }
271
272 /**********************************************************************************************/
273
274 STATIC VOID RenderFrame(struct PaletteData *data, struct RastPort *rp, struct IBox *gadbox,
275 struct DrawInfo *dri, BOOL recessed, BOOL edgesonly, Class *cl)
276 {
277 WORD left, top;
278
279 EnterFunc(bug( "RenderFrame(rp=%p, gadbox=%p, dri=%p)\n",
280 rp, gadbox, dri));
281
282 left = gadbox->Left; top = gadbox->Top;
283
284 if (!data->pd_Frame)
285 {
286 struct TagItem frame_tags[] =
287 {
288 {IA_Resolution , (dri->dri_Resolution.X << 16) + dri->dri_Resolution.Y},
289 {IA_FrameType , FRAME_BUTTON},
290 {IA_EdgesOnly , edgesonly},
291 {TAG_DONE}
292 };
293
294 data->pd_Frame = NewObjectA(NULL, FRAMEICLASS, frame_tags);
295 }
296
297 if (data->pd_Frame)
298 {
299 struct TagItem frameset_tags[] =
300 {
301 {IA_Width , gadbox->Width},
302 {IA_Height , gadbox->Height},
303 {IA_Recessed , recessed},
304 {IA_EdgesOnly , edgesonly},
305 {TAG_DONE}
306 };
307
308 SetAttrsA(data->pd_Frame, frameset_tags);
309
310 DrawImageState(rp,
311 (struct Image *)data->pd_Frame,
312 left,
313 top,
314 IDS_NORMAL,
315 dri);
316
317 }
318
319 ReturnVoid("RenderFrame");
320 }
321
322 /**********************************************************************************************/
323
324 STATIC IPTR palette_set(Class *cl, Object *o, struct opSet *msg)
325 {
326 struct TagItem *tag, *tstate = msg->ops_AttrList;
327 struct PaletteData *data = INST_DATA(cl, o);
328 BOOL labelplace_set = FALSE, relayout = FALSE;
329 BOOL colortag_found = FALSE, numcolorstag_found = FALSE;
330 IPTR retval = 0UL;
331
332
333 EnterFunc(bug("Palette::Set()\n"));
334
335 while ((tag = NextTagItem(&tstate)))
336 {
337 IPTR tidata = tag->ti_Data;
338
339
340 switch (tag->ti_Tag)
341 {
342 case GTPA_Depth: /* [ISU] */
343 /* NumColors tag overrides Depth tag! */
344 if (!numcolorstag_found)
345 {
346 data->pd_NumColors = (1 << ((UBYTE)tidata));
347
348 D(bug("Depth initialized to %d\n", tidata));
349 relayout = TRUE;
350 retval = 1UL;
351 }
352 break;
353
354 case GTPA_Color: /* [IS] */
355 colortag_found = TRUE;
356
357 data->pd_OldColor = data->pd_Color;
358 data->pd_Color = (UBYTE)tidata;
359 D(bug("Color set to %d\n", tidata));
360 retval = 1UL;
361 break;
362
363 case GTPA_ColorOffset: /* [I] */
364 data->pd_ColorOffset = (UBYTE)tidata;
365 D(bug("ColorOffset initialized to %d\n", tidata));
366 retval = 1UL;
367 break;
368
369 case GTPA_IndicatorWidth: /* [I] */
370 data->pd_IndWidth = (UWORD)tidata;
371 D(bug("Indicatorwidth set to %d\n", tidata));
372
373 /* If palette has an indictor on left, GA_LabelPlace
374 ** defaults to GV_LabelPlace_Left
375 */
376 if (!labelplace_set)
377 data->pd_LabelPlace = GV_LabelPlace_Left;
378 break;
379
380 case GTPA_IndicatorHeight: /* [I] */
381 data->pd_IndHeight = (UWORD)tidata;
382 D(bug("Indicatorheight set to %d\n", tidata));
383 break;
384
385 case GA_LabelPlace: /* [I] */
386 data->pd_LabelPlace = (LONG)tidata;
387 D(bug("Labelplace set to %d\n", tidata));
388
389 labelplace_set = TRUE;
390 break;
391
392 case GA_TextAttr: /* [I] */
393 data->pd_TAttr = (struct TextAttr *)tidata;
394 D(bug("TextAttr set to %s %d\n",
395 data->pd_TAttr->ta_Name, data->pd_TAttr->ta_YSize));
396 break;
397
398 case GTPA_ColorTable:
399 data->pd_ColorTable = (UBYTE *)tidata;
400 break;
401
402 case GTPA_NumColors:
403 numcolorstag_found = TRUE;
404
405 data->pd_NumColors = (UWORD)tidata;
406 relayout = TRUE;
407 break;
408
409 } /* switch (tag->ti_Tag) */
410
411 } /* for (each attr in attrlist) */
412
413 if (colortag_found)
414 {
415 /* convert pen number to index */
416
417 if (data->pd_ColorTable)
418 {
419 WORD i;
420
421 /* convert pen number to index number */
422 for(i = 0; i < data->pd_NumColors; i++)
423 {
424 if (data->pd_ColorTable[i] == data->pd_Color)
425 {
426 data->pd_Color = i;
427 break;
428 }
429 }
430
431 }
432 else
433 {
434 data->pd_Color -= data->pd_ColorOffset;
435 }
436 } /* if (colortag_found) */
437
438 if (relayout)
439 {
440 /* Check if the old selected fits into the new depth */
441 if (data->pd_Color > data->pd_NumColors - 1)
442 {
443 data->pd_Color = 0;
444 data->pd_OldColor = 0; /* So that UpdateActiveColor() don't get confused */
445 }
446
447 /* Relayout the gadget */
448 DoMethod(o, GM_LAYOUT, (IPTR) msg->ops_GInfo, FALSE);
449 }
450
451 ReturnPtr ("Palette::Set", IPTR, retval);
452 }
453
454 /**********************************************************************************************/
455
456 IPTR GTPalette__OM_GET(Class *cl, Object *o, struct opGet *msg)
457 {
458 struct PaletteData *data = INST_DATA(cl, o);
459 IPTR retval = 0;
460
461 switch (msg->opg_AttrID)
462 {
463 case GTA_GadgetKind:
464 case GTA_ChildGadgetKind:
465 *(msg->opg_Storage) = PALETTE_KIND;
466 retval = 1UL;
467 break;
468
469 case GTPA_Color:
470 *msg->opg_Storage = (IPTR)GetPalettePen(data, data->pd_Color);
471 break;
472
473 case GTPA_ColorOffset:
474 *msg->opg_Storage = (IPTR)data->pd_ColorOffset;
475 break;
476
477 case GTPA_ColorTable:
478 *msg->opg_Storage = (IPTR)data->pd_ColorTable;
479 break;
480
481 default:
482 retval = DoSuperMethodA(cl, o, (Msg)msg);
483 break;
484 }
485
486 return retval;
487 }
488
489 /**********************************************************************************************/
490
491 IPTR GTPalette__OM_NEW(Class *cl, Object *o, struct opSet *msg)
492 {
493 struct opSet ops;
494 struct TagItem tags[] =
495 {
496 {GA_RelSpecial , TRUE},
497 {TAG_MORE , (IPTR)NULL}
498 };
499
500 EnterFunc(bug("Palette::New()\n"));
501
502 tags[1].ti_Data = (IPTR)msg->ops_AttrList;
503
504 ops.MethodID = OM_NEW;
505 ops.ops_GInfo = NULL;
506 ops.ops_AttrList = &tags[0];
507
508 o = (Object *)DoSuperMethodA(cl, o, (Msg)&ops);
509 if (o)
510 {
511 struct PaletteData *data = INST_DATA(cl, o);
512
513 /* Set some defaults */
514 data->pd_NumColors = 2;
515 data->pd_ColorTable = NULL;
516 data->pd_Color = 0;
517 data->pd_OldColor = 0 ; /* = data->pd_OldColor */
518 data->pd_ColorOffset = 0;
519 data->pd_IndWidth = 0;
520 data->pd_IndHeight = 0;
521 data->pd_LabelPlace = GV_LabelPlace_Above;
522
523 palette_set(cl, o, msg);
524
525 }
526 ReturnPtr ("Palette::New", IPTR, (IPTR)o);
527 }
528
529 /**********************************************************************************************/
530
531 IPTR GTPalette__OM_DISPOSE(Class *cl, Object *o, Msg msg)
532 {
533 struct PaletteData *data = INST_DATA(cl, o);
534
535 if (data->pd_Frame)
536 DisposeObject(data->pd_Frame);
537
538 return DoSuperMethodA(cl, o, msg);
539 }
540
541 /**********************************************************************************************/
542
543 IPTR GTPalette__GM_LAYOUT(Class *cl, struct Gadget *g, struct gpLayout *msg)
544 {
545
546 /* The palette gadget has been resized and we need to update our layout */
547
548 struct PaletteData *data = INST_DATA(cl, g);
549 struct IBox *gbox = &(data->pd_GadgetBox),
550 *pbox = &(data->pd_PaletteBox),
551 *indbox = &(data->pd_IndicatorBox);
552 UWORD cols, rows, cols_p2;
553 WORD leftover_width, leftover_height;
554
555 EnterFunc(bug("Palette::Layout()\n"));
556
557 if (!msg->gpl_GInfo)
558 ReturnInt("Palette::Layout", IPTR, 0); /* We MUST have a GInfo to get screen aspect ratio */
559
560 /* Delete the old gadget box */
561 if (!msg->gpl_Initial)
562 {
563
564 struct RastPort *rp;
565
566 if ((rp = ObtainGIRPort(msg->gpl_GInfo)))
567 {
568 SetAPen(rp, msg->gpl_GInfo->gi_DrInfo->dri_Pens[BACKGROUNDPEN]);
569 D(bug( "Clearing area (%d, %d, %d, %d)\n",
570 gbox->Left, gbox->Top, gbox->Left + gbox->Width, gbox->Top + gbox->Height));
571 RectFill( rp, gbox->Left, gbox->Top,
572 gbox->Left + gbox->Width - 1, gbox->Top + gbox->Height - 1);
573
574 ReleaseGIRPort(rp);
575 }
576 }
577
578 /* get the IBox surrounding the whole palette */
579 GetGadgetIBox(g, msg->gpl_GInfo, gbox);
580
581 D(bug( "Got palette ibox: (%d, %d, %d, %d)\n",
582 gbox->Left, gbox->Top, gbox->Width, gbox->Height));
583
584 /* Get the palette box */
585 pbox->Left = gbox->Left + VBORDER + VSPACING;
586 pbox->Top = gbox->Top + HBORDER + HSPACING;
587 pbox->Width = gbox->Width - VBORDER *2 - VSPACING *2;
588 pbox->Height = gbox->Height - HBORDER *2 - HSPACING *2;
589
590
591 /* If we have an indicator box then account for this */
592 if (data->pd_IndHeight)
593 {
594 indbox->Top = pbox->Top;
595 indbox->Left = pbox->Left;
596 indbox->Width = pbox->Width;
597 indbox->Height = data->pd_IndHeight;
598
599 pbox->Height -= (indbox->Height + HSPACING *2);
600 pbox->Top += (data->pd_IndHeight + HSPACING *2);
601 }
602 else if (data->pd_IndWidth)
603 {
604 indbox->Left = pbox->Left;
605 indbox->Top = pbox->Top;
606 indbox->Width = data->pd_IndWidth;
607 indbox->Height = pbox->Height;
608
609 pbox->Width -= (indbox->Width + VSPACING *2);
610 pbox->Left += (data->pd_IndWidth + VSPACING *2);
611 }
612
613
614 /* Compute initial aspect ratio */
615 cols = 1;
616 cols_p2 = data->pd_NumColors * pbox->Width / pbox->Height;
617 while ((cols*cols) <= cols_p2)
618 {
619 cols++;
620 }
621 if ((cols * cols) > cols_p2)
622 {
623 cols--;
624 }
625 rows = (data->pd_NumColors + cols - 1) / cols;
626
627 data->pd_NumCols = (UBYTE)cols;
628 data->pd_NumRows = (UBYTE)rows;
629
630 data->pd_ColWidth = pbox->Width / data->pd_NumCols;
631 data->pd_RowHeight = pbox->Height / data->pd_NumRows;
632
633 D(bug("cols=%d, rows=%d\n", data->pd_NumCols, data->pd_NumRows));
634 D(bug("colwidth=%d, rowheight=%d\n", data->pd_ColWidth, data->pd_RowHeight));
635
636 /* Adjust the pbox's and indbox's height according to leftovers */
637
638 leftover_width = pbox->Width % data->pd_NumCols;
639 leftover_height = pbox->Height % data->pd_NumRows;
640
641 pbox->Width -= leftover_width;
642 pbox->Height -= leftover_height;
643
644 if (data->pd_IndHeight)
645 indbox->Width -= leftover_width;
646 else if (data->pd_IndWidth)
647 indbox->Height -= leftover_height;
648
649 ReturnInt ("Palette::Layout", IPTR, 0);
650
651 }
652
653 /**********************************************************************************************/
654
655 IPTR GTPalette__GM_RENDER(Class *cl, struct Gadget *g, struct gpRender *msg)
656 {
657 struct PaletteData *data = INST_DATA(cl, g);
658
659 struct DrawInfo *dri = msg->gpr_GInfo->gi_DrInfo;
660 struct RastPort *rp;
661 struct IBox *gbox = &(data->pd_GadgetBox);
662
663 EnterFunc(bug("Palette::Render()\n"));
664
665 rp = msg->gpr_RPort;
666
667 switch (msg->gpr_Redraw)
668 {
669 case GREDRAW_REDRAW:
670 D(bug("Doing total redraw\n"));
671
672 /* Render gadget label in correct position */
673 renderlabel(GadToolsBase, g, rp, data->pd_LabelPlace);
674
675 RenderFrame(data, rp, gbox, dri, FALSE, FALSE, cl);
676
677 RenderPalette(data, rp, cl);
678
679 /* Render frame aroun ibox */
680 if (data->pd_IndWidth || data->pd_IndHeight)
681 {
682 RenderFrame(data, rp, &(data->pd_IndicatorBox), dri, TRUE, TRUE, cl);
683 }
684
685 case GREDRAW_UPDATE:
686 D(bug("Doing redraw update\n"));
687
688 UpdateActiveColor(data, dri, rp, cl);
689
690 if (data->pd_IndWidth || data->pd_IndHeight)
691 {
692 struct IBox *ibox = &(data->pd_IndicatorBox);
693
694 SetAPen(rp, GetPalettePen(data, data->pd_Color));
695
696 D(bug( "Drawing indocator at: (%d, %d, %d, %d)\n",
697 ibox->Left, ibox->Top,
698 ibox->Left + ibox->Width, ibox->Top + ibox->Height));
699
700 RectFill( msg->gpr_RPort,
701 ibox->Left + VBORDER + VSPACING,
702 ibox->Top + HBORDER + HSPACING,
703 ibox->Left + ibox->Width - 1 - VBORDER - VSPACING,
704 ibox->Top + ibox->Height - 1 - HBORDER - HSPACING);
705
706 }
707 break;
708
709 } /* switch (redraw method) */
710
711 if (g->Flags & GFLG_DISABLED)
712 {
713 DoDisabledPattern( rp,
714 gbox->Left,
715 gbox->Top,
716 gbox->Left + gbox->Width - 1,
717 gbox->Top + gbox->Height - 1,
718 dri->dri_Pens[SHADOWPEN],
719 GadToolsBase);
720 }
721
722 ReturnInt ("Palette::Render", IPTR, 0);
723 }
724
725 /**********************************************************************************************/
726
727 IPTR GTPalette__GM_HITTEST(Class *cl, Object *o, struct gpHitTest *msg)
728 {
729 struct PaletteData *data = INST_DATA(cl, o);
730 WORD x, y;
731
732 IPTR retval = 0UL;
733
734 EnterFunc(bug("Palette::HitTest()\n"));
735
736 /* One might think that this method is not necessary to implement,
737 ** but here is an example to show the opposite:
738 ** Consider a 16 color palette with 8 rows and 2 cols.
739 ** Gadget is 87 pix. heigh. Each row will then be 10 pix hight + 7 pix
740 ** of "nowhere". To prevent anything from happening when this area is
741 ** clicked, we rule it out here.
742 */
743
744 x = msg->gpht_Mouse.X + data->pd_GadgetBox.Left;
745 y = msg->gpht_Mouse.Y + data->pd_GadgetBox.Top;
746
747 if( (x > data->pd_PaletteBox.Left)
748 && (x < data->pd_PaletteBox.Left + data->pd_PaletteBox.Width - 1)
749 && (y > data->pd_PaletteBox.Top)
750 && (y < data->pd_PaletteBox.Top + data->pd_PaletteBox.Height - 1) )
751 {
752 retval = GMR_GADGETHIT;
753 }
754
755 ReturnInt ("Palette::HitTest", IPTR, retval);
756 }
757
758 /**********************************************************************************************/
759
760 IPTR GTPalette__GM_GOACTIVE(Class *cl, struct Gadget *g, struct gpInput *msg)
761 {
762 struct PaletteData *data = INST_DATA(cl, g);
763 IPTR retval = 0UL;
764
765 EnterFunc(bug("Palette::GoActive()\n"));
766 if (g->Flags & GFLG_DISABLED)
767 {
768 retval = GMR_NOREUSE;
769 }
770 else
771 {
772 if (msg->gpi_IEvent)
773 {
774 UBYTE clicked_color;
775
776 /* Set temporary active to the old active */
777 data->pd_ColorBackup = data->pd_Color;
778
779 clicked_color = ComputeColor( data,
780 msg->gpi_Mouse.X + data->pd_GadgetBox.Left,
781 msg->gpi_Mouse.Y + data->pd_GadgetBox.Top);
782
783 if (clicked_color != data->pd_Color)
784 {
785 struct RastPort *rp;
786
787 data->pd_Color = clicked_color;
788
789 if ((rp = ObtainGIRPort(msg->gpi_GInfo)))
790 {
791 DoMethod((Object *)g, GM_RENDER, (IPTR) msg->gpi_GInfo, (IPTR) rp, GREDRAW_UPDATE);
792
793 ReleaseGIRPort(rp);
794 }
795 }
796
797 retval = GMR_MEACTIVE;
798
799 } /* if (gadget activated is a result of user input) */
800 else
801 {
802 retval = GMR_NOREUSE;
803 }
804
805 } /* if (gadget isn't disabled) */
806
807 ReturnInt("Palette::GoActive", IPTR, retval);
808 }
809
810 /**********************************************************************************************/
811
812 IPTR GTPalette__GM_HANDLEINPUT(Class *cl, Object *o, struct gpInput *msg)
813 {
814 struct PaletteData *data = INST_DATA(cl, o);
815 struct InputEvent *ie = msg->gpi_IEvent;
816 IPTR retval = 0UL;
817
818 EnterFunc(bug("Palette::HandleInput\n"));
819
820 retval = GMR_MEACTIVE;
821
822 if (ie->ie_Class == IECLASS_RAWMOUSE)
823 {
824 WORD x = msg->gpi_Mouse.X + data->pd_GadgetBox.Left;
825 WORD y = msg->gpi_Mouse.Y + data->pd_GadgetBox.Top;
826
827 if (x <= data->pd_PaletteBox.Left)
828 x = data->pd_PaletteBox.Left + 1;
829
830 if (y <= data->pd_PaletteBox.Top)
831 y = data->pd_PaletteBox.Top + 1;
832
833 if (x >= data->pd_PaletteBox.Left + data->pd_PaletteBox.Width - 1)
834 x = data->pd_PaletteBox.Left + data->pd_PaletteBox.Width - 2;
835
836 if (y >= data->pd_PaletteBox.Top + data->pd_PaletteBox.Height - 1)
837 y = data->pd_PaletteBox.Top + data->pd_PaletteBox.Height - 2;
838
839 switch (ie->ie_Code)
840 {
841 case SELECTUP:
842 {
843 /* If the button was released outside the gadget, then
844 ** go back to old state --> no longer: stegerg
845 */
846
847 D(bug("IECLASS_RAWMOUSE: SELECTUP\n"));
848 #if 0
849 if (!InsidePalette(data, x, y))
850 {
851 struct RastPort *rp;
852
853 /* Left released outside of gadget area, go back
854 ** to old state
855 */
856 data->pd_Color = data->pd_ColorBackup;
857 D(bug("Left released outside gadget\n"));
858
859 if ((rp = ObtainGIRPort(msg->gpi_GInfo)))
860 {
861 DoMethod(o, GM_RENDER, msg->gpi_GInfo, rp, GREDRAW_UPDATE);
862
863 ReleaseGIRPort(rp);
864 }
865 }
866 else
867 {
868 #endif
869 D(bug( "Left released inside gadget, color=%d\n", GetPalettePen(data, data->pd_Color)));
870 *(msg->gpi_Termination) = GetPalettePen(data, data->pd_Color);
871 retval = GMR_VERIFY;
872 #if 0
873 }
874 #endif
875
876 retval |= GMR_NOREUSE;
877 break;
878 }
879
880 case IECODE_NOBUTTON:
881 {
882
883 UBYTE over_color;
884
885 D(bug("IECLASS_POINTERPOS\n"));
886
887 if (InsidePalette(data, x, y))
888 {
889
890 over_color = ComputeColor(data, x, y);
891
892 if (over_color != data->pd_Color)
893 {
894 struct RastPort *rp;
895
896 data->pd_Color = over_color;
897 if ((rp = ObtainGIRPort(msg->gpi_GInfo)))
898 {
899 DoMethod(o, GM_RENDER, (IPTR) msg->gpi_GInfo, (IPTR) rp, GREDRAW_UPDATE);
900
901 ReleaseGIRPort(rp);
902 }
903
904 } /* if (mouse is over a different color) */
905
906 } /* if (mouse is over gadget) */
907
908 retval = GMR_MEACTIVE;
909
910 }
911 break;
912
913
914 case MENUUP:
915 {
916 /* Right released on gadget, go back to old state */
917
918 struct RastPort *rp;
919
920 data->pd_Color = data->pd_ColorBackup;
921 D(bug("Right mouse pushed \n"));
922
923 if ((rp = ObtainGIRPort(msg->gpi_GInfo)))
924 {
925 DoMethod(o, GM_RENDER, (IPTR) msg->gpi_GInfo, (IPTR) rp, GREDRAW_UPDATE);
926
927 ReleaseGIRPort(rp);
928 }
929
930 retval = GMR_NOREUSE;
931 break;
932 }
933
934 } /* switch (ie->ie_Code) */
935
936 } /* if (mouse event) */
937
938 ReturnInt("Palette::HandleInput", IPTR, retval);
939 }
940
941 /**********************************************************************************************/
942
943 IPTR GTPalette__OM_SET(Class *cl, Object *o, struct opSet *msg)
944 {
945 IPTR retval = DoSuperMethodA(cl, o, (Msg)msg);
946 retval += (IPTR)palette_set(cl, o, msg);
947 /* If we have been subclassed, OM_UPDATE should not cause a GM_RENDER
948 *because it would circumvent the subclass from fully overriding it.
949 *The check of cl == OCLASS(o) should fail if we have been
950 *subclassed, and we have gotten here via DoSuperMethodA().
951 */
952 if ( retval && ((msg->MethodID != OM_UPDATE) || (cl == OCLASS(o))) )
953 {
954 struct GadgetInfo *gi = msg->ops_GInfo;
955
956 if (gi)
957 {
958 struct RastPort *rp = ObtainGIRPort(gi);
959
960 if (rp)
961 {
962 DoMethod( o,
963 GM_RENDER,
964 (IPTR) gi,
965 (IPTR) rp,
966 FindTagItem(GA_Disabled, msg->ops_AttrList) ? GREDRAW_REDRAW : GREDRAW_UPDATE);
967
968 ReleaseGIRPort(rp);
969
970 } /* if */
971
972 } /* if */
973
974 } /* if */
975
976 return retval;
977 }
978
979 /**********************************************************************************************/
Mirror of AROS' svn.