workbench/libs/muimaster/bubbleengine.c

   1 /*
   2     Copyright © 1999, David Le Corfec.
   3     Copyright © 2002, The AROS Development Team.
   4     All rights reserved.
   5
   6     $Id$
   7 */
   8
   9 #include <ctype.h>
  10 #include <stdlib.h>
  11 #include <string.h>
  12 #include <stdio.h>
  13
  14 #include <exec/types.h>
  15 #include <exec/memory.h>
  16
  17 #include <clib/alib_protos.h>
  18 #include <intuition/screens.h>
  19 #include <proto/exec.h>
  20 #include <proto/graphics.h>
  21 #include <proto/utility.h>
  22 #include <proto/intuition.h>
  23 #include <proto/muimaster.h>
  24
  25 #include "mui.h"
  26 #include "textengine.h"
  27 #include "bubbleengine.h"
  28 #include "support.h"
  29
  30 #include "muimaster_intern.h"
  31
  32 //#define MYDEBUG 1
  33 #include "debug.h"
  34
  35 extern struct Library *MUIMasterBase;
  36
  37 /************************************************************************/
  38
  39 #ifndef __AROS__
  40 #define WA_Shape WA_ShapeRegion
  41 #endif
  42
  43 /************************************************************************/
  44
  45 typedef struct ZBubble
  46 {
  47     struct Window *win;
  48     ZText         *ztext;
  49     STRPTR         text;
  50     UBYTE          flags;
  51     struct Region *shape;
  52 } ZBubble;
  53
  54 #define BUBBLEF_CREATESHORTHELP_CALLED 1
  55
  56 /************************************************************************/
  57
  58
  59 /*                [][][][]
  60               [][]
  61           [][]
  62         []
  63       []
  64     []
  65     []
  66   []
  67   []
  68 []
  69 []
  70 []
  71 []
  72
  73 */
  74
  75 #define ROUNDEDGE_SIZE 13
  76 #define BORDER_X 5
  77 #define BORDER_Y 5
  78
  79 static WORD roundtab[ROUNDEDGE_SIZE] =
  80 {
  81     9,
  82     7,
  83     5,
  84     4,
  85     3,
  86     2,
  87     2,
  88     1,
  89     1,
  90     0,
  91     0,
  92     0,
  93     0
  94 };
  95
  96 static struct Region *zune_bubble_shape_create(Object *obj, ZBubble *bubble, WORD w, WORD h)
  97 {
  98     struct Region       *shape = NewRegion();
  99     struct Rectangle     r;
 100     WORD                 y;
 101
 102     if (!shape) return NULL;
 103
 104     for(y = 0; y < ROUNDEDGE_SIZE; y++)
 105     {
 106         r.MinX = roundtab[y];
 107         r.MinY = y;
 108         r.MaxX = w - 1 - r.MinX;
 109         r.MaxY = y;
 110
 111         OrRectRegion(shape, &r);
 112
 113         r.MinY = h - 1 - y;
 114         r.MaxY = h - 1 - y;
 115
 116         OrRectRegion(shape, &r);
 117     }
 118
 119     r.MinX = 0;
 120     r.MinY = y;
 121     r.MaxX = w - 1;
 122     r.MaxY = h - 1 - y;
 123
 124     OrRectRegion(shape, &r);
 125
 126     return shape;
 127
 128 }
 129
 130 static void zune_bubble_draw(Object *obj, ZBubble *bubble)
 131 {
 132     struct RastPort *rp = bubble->win->RPort, *objrp;
 133     WORD             x1, x2, y, w, h, prev_x1 = -1;
 134
 135     w = bubble->win->Width;
 136     h = bubble->win->Height;
 137
 138     for(y = 0; y < ROUNDEDGE_SIZE; y++, prev_x1 = x1)
 139     {
 140         x1 = roundtab[y];
 141         x2 = w - 1 - x1;
 142
 143         if (prev_x1 == -1)
 144         {
 145             SetAPen(rp, _pens(obj)[MPEN_SHADOW]);
 146         }
 147         else
 148         {
 149             SetAPen(rp, _pens(obj)[MPEN_SHINE]);
 150         }
 151
 152         RectFill(rp, x1, y, x2, y);
 153         RectFill(rp, x1, h - 1 - y, x2, h - 1 - y);
 154
 155         if (prev_x1 != -1)
 156         {
 157             if (prev_x1 != x1) prev_x1--;
 158             SetAPen(rp, _pens(obj)[MPEN_SHADOW]);
 159             RectFill(rp, x1, y, prev_x1, y);
 160             RectFill(rp, x1, h - 1 - y, prev_x1, h - 1 - y);
 161             RectFill(rp, w - 1 - prev_x1, y, w - 1 - x1, y);
 162             RectFill(rp, w - 1 - prev_x1, h - 1 - y, w - 1 - x1, h - 1 - y);
 163         }
 164
 165     }
 166
 167     SetAPen(rp, _pens(obj)[MPEN_SHINE]);
 168     RectFill(rp, 1, y, w - 2, h - 1 - y);
 169
 170     SetAPen(rp, _pens(obj)[MPEN_SHADOW]);
 171     RectFill(rp, 0, y, 0, h - 1 - y);
 172     RectFill(rp, w - 1, y, w - 1, h - 1 - y);
 173
 174     objrp = _rp(obj);
 175     _rp(obj) = rp;
 176
 177     zune_text_draw(bubble->ztext, obj, ROUNDEDGE_SIZE + BORDER_X,
 178                    ROUNDEDGE_SIZE + BORDER_X + bubble->ztext->width - 1,
 179                    (bubble->win->Height - bubble->ztext->height + 1) / 2);
 180
 181    _rp(obj) = objrp;
 182 }
 183
 184 APTR zune_bubble_create(Object *obj, LONG x, LONG y, char *text, ULONG flags)
 185 {
 186     ZBubble *bubble;
 187
 188     if (!(_flags(obj) & MADF_CANDRAW)) return NULL;
 189
 190     bubble = mui_alloc_struct(ZBubble);
 191     if (!bubble) return NULL;
 192
 193     if (!text)
 194     {
 195         text = (STRPTR)DoMethod(obj, MUIM_CreateShortHelp, x, y);
 196         bubble->flags |= BUBBLEF_CREATESHORTHELP_CALLED;
 197     }
 198
 199     if (!text)
 200     {
 201         mui_free(bubble);
 202         return NULL;
 203     }
 204
 205     bubble->text = text;
 206
 207     bubble->ztext = zune_text_new(NULL, bubble->text, ZTEXT_ARG_NONE, 0);
 208     if (!bubble->ztext)
 209     {
 210         zune_bubble_delete(obj, bubble);
 211         return NULL;
 212     }
 213
 214     zune_text_get_bounds(bubble->ztext, obj);
 215
 216     #define WINLEFT   _window(obj)->LeftEdge + x
 217     #define WINTOP    _window(obj)->TopEdge  + y
 218
 219     #define WINWIDTH  bubble->ztext->width   + (ROUNDEDGE_SIZE + BORDER_X) * 2
 220     #define WINHEIGHT ((bubble->ztext->height  + BORDER_Y * 2) < ROUNDEDGE_SIZE * 2 + 1) ? \
 221                       ROUNDEDGE_SIZE * 2 + 1 : (bubble->ztext->height + BORDER_Y * 2)
 222
 223     bubble->shape = zune_bubble_shape_create(obj, bubble, WINWIDTH, WINHEIGHT);
 224
 225     bubble->win = OpenWindowTags(NULL, WA_CustomScreen, (IPTR)_screen(obj),
 226                                        WA_Left, WINLEFT,
 227                                        WA_Top, WINTOP,
 228                                        WA_Width, WINWIDTH,
 229                                        WA_Height, WINHEIGHT,
 230                                        WA_AutoAdjust, TRUE,
 231                                        WA_Activate, FALSE,
 232                                        WA_Borderless, TRUE,
 233                                        WA_BackFill, (IPTR)LAYERS_NOBACKFILL,
 234                                        WA_Shape, (IPTR)bubble->shape,
 235                                        TAG_DONE);
 236
 237     if (!bubble->win)
 238     {
 239         zune_bubble_delete(obj, bubble);
 240         return NULL;
 241     }
 242
 243     zune_bubble_draw(obj, bubble);
 244
 245     return bubble;
 246 }
 247
 248 void zune_bubble_delete(Object *obj, APTR bubble)
 249 {
 250     ZBubble *b = (ZBubble *)bubble;
 251
 252     if (b)
 253     {
 254         if (b->win) CloseWindow(b->win);
 255         if (b->shape) DisposeRegion(b->shape);
 256         if (b->ztext) zune_text_destroy(b->ztext);
 257
 258         if (b->flags & BUBBLEF_CREATESHORTHELP_CALLED)
 259         {
 260             DoMethod(obj, MUIM_DeleteShortHelp, (IPTR)b->text);
 261         }
 262
 263         mui_free(b);
 264     }
 265 }
 266