workbench/classes/zune/calltips/Calltips.c

   1 /*
   2     Copyright © 2014, Thore Böckelmann. All rights reserved.
   3     Copyright © 2014, The AROS Development Team. All rights reserved.
   4     $Id$
   5 */
   6
   7 #include <proto/alib.h>
   8 #include <proto/intuition.h>
   9 #include <proto/utility.h>
  10
  11 #include <libraries/mui.h>
  12
  13 #include "Calltips_mcc.h"
  14 #include "Calltips_private.h"
  15
  16 #define VERSION  20
  17 #define REVISION 12
  18
  19 static void setRectangle(struct IClass *cl, Object *obj)
  20 {
  21     struct Data *data = INST_DATA(cl, obj);
  22     struct Window *parentWin = _window(data->source);
  23     LONG left = parentWin->LeftEdge + data->rectangle.MinX - ((data->marginLeft == TRUE) ? _mleft(data->rootGroup) : 0);
  24     LONG top = parentWin->TopEdge + data->rectangle.MinY - ((data->marginLeft == TRUE) ? _mtop(data->rootGroup) : 0);
  25     LONG width = data->rectangle.MaxX - data->rectangle.MinX + 1;
  26     LONG height = data->rectangle.MaxY - data->rectangle.MinY + 1;
  27
  28     // setting the position/dimension depends on the window's open state
  29     if(XGET(obj, MUIA_Window_Open) == TRUE)
  30     {
  31         struct Window *thisWin = _window(data->rootGroup);
  32
  33         if(left != thisWin->LeftEdge || top != thisWin->TopEdge || width != thisWin->Width || height != thisWin->Height)
  34         {
  35             ChangeWindowBox(thisWin, left, top, width, height);
  36             MoveWindowInFrontOf(thisWin, parentWin);
  37         }
  38     }
  39     else
  40     {
  41         SetSuperAttrs(cl, obj,
  42             MUIA_Window_LeftEdge, left,
  43             MUIA_Window_TopEdge, top,
  44             MUIA_Window_Width, width,
  45             MUIA_Window_Height, height,
  46             TAG_DONE);
  47     }
  48 }
  49
  50 /* ------------------------------------------------------------------------- */
  51
  52 IPTR Calltips__OM_NEW(struct IClass *cl, Object *obj, struct opSet *msg)
  53 {
  54     Object *source = NULL;
  55     struct Rect32 *rectangle = NULL;
  56     ULONG layout = MUIV_Calltips_Layout_Exact;
  57     BOOL marginLeft = TRUE;
  58     BOOL marginTop = TRUE;
  59     struct TagItem  *tstate = msg->ops_AttrList;
  60     struct TagItem  *tag;
  61
  62     while ((tag = NextTagItem(&tstate)) != NULL)
  63     {
  64         switch(tag->ti_Tag)
  65         {
  66             case MUIA_Calltips_Source:
  67             {
  68                 source = (Object *)tag->ti_Data;
  69             }
  70             break;
  71
  72             case MUIA_Calltips_Rectangle:
  73             {
  74                 rectangle = (struct Rect32 *)tag->ti_Data;
  75             }
  76             break;
  77
  78             case MUIA_Calltips_Layout:
  79             {
  80                 layout = tag->ti_Data;
  81             }
  82             break;
  83
  84             case MUIA_Calltips_MarginLeft:
  85             {
  86                 marginLeft = tag->ti_Data ? TRUE : FALSE;
  87             }
  88             break;
  89
  90             case MUIA_Calltips_MarginTop:
  91             {
  92                 marginTop = tag->ti_Data ? TRUE : FALSE;
  93             }
  94             break;
  95         }
  96     }
  97
  98     if(source != NULL)
  99     {
 100         if((obj = (Object *)DoSuperNewTags(cl, obj, NULL,
 101             MUIA_Window_Screen, _screen(source),
 102             MUIA_Window_Borderless, TRUE,
 103             MUIA_Window_SizeGadget, FALSE,
 104             MUIA_Window_DragBar, FALSE,
 105             MUIA_Window_DepthGadget, FALSE,
 106             MUIA_Window_CloseGadget, FALSE,
 107             MUIA_Window_NoMenus, TRUE,
 108 //            MUIA_Window_IsPopup, TRUE,
 109             MUIA_Window_Activate, FALSE,
 110 //            MUIA_Window_StayTop, TRUE,
 111             TAG_MORE, msg->ops_AttrList)) != NULL)
 112         {
 113             struct Data *data = INST_DATA(cl, obj);
 114
 115             data->source = source;
 116             data->rootGroup = (Object *)XGET(obj, MUIA_Window_RootObject);
 117             data->layout = layout;
 118             data->marginLeft = marginLeft;
 119             data->marginTop = marginTop;
 120             if(rectangle != NULL)
 121             {
 122                 data->rectangle = *rectangle;
 123             }
 124             else
 125             {
 126                 data->rectangle.MinX = _mleft(source);
 127                 data->rectangle.MinY = _mbottom(source)+1;
 128                 data->rectangle.MaxX = _mright(source);
 129                 data->rectangle.MaxY = _mbottom(source)+1+100;
 130             }
 131
 132             setRectangle(cl, obj);
 133         }
 134     }
 135     else
 136     {
 137         obj = NULL;
 138     }
 139
 140     return (IPTR)obj;
 141 }
 142
 143
 144 IPTR Calltips__OM_GET(struct IClass *cl, Object *obj, struct opGet *msg)
 145 {
 146     IPTR *store = msg->opg_Storage;
 147
 148     switch(msg->opg_AttrID)
 149     {
 150         case MUIA_Version:        *store = VERSION; return TRUE;
 151         case MUIA_Revision:       *store = REVISION; return TRUE;
 152     }
 153
 154     return DoSuperMethodA(cl, obj, (Msg)msg);
 155 }
 156
 157
 158 IPTR Calltips__OM_SET(struct IClass *cl, Object *obj, struct opSet *msg)
 159 {
 160     struct Data     *data = INST_DATA(cl, obj);
 161     struct TagItem  *tstate = msg->ops_AttrList;
 162     struct TagItem  *tag;
 163
 164     while ((tag = NextTagItem(&tstate)) != NULL)
 165     {
 166         switch(tag->ti_Tag)
 167         {
 168             case MUIA_Calltips_Rectangle:
 169             {
 170                 struct Rect32 *rectangle = (struct Rect32 *)tag->ti_Data;
 171
 172                 if(rectangle != NULL)
 173                 {
 174                     data->rectangle = *rectangle;
 175                     setRectangle(cl, obj);
 176                 }
 177             }
 178             break;
 179
 180             case MUIA_Calltips_Layout:
 181             {
 182                 data->layout = tag->ti_Data;
 183             }
 184             break;
 185         }
 186     }
 187
 188     return DoSuperMethodA(cl, obj, (Msg)msg);
 189 }
 190
 191
 192 IPTR Calltips__MUIM_Calltips_SetRectangle(struct IClass *cl, Object *obj, struct MUIP_Calltips_SetRectangle *msg)
 193 {
 194     struct Data *data = INST_DATA(cl, obj);
 195
 196     data->rectangle.MinX = msg->MinX;
 197     data->rectangle.MinY = msg->MinY;
 198     data->rectangle.MaxX = msg->MaxX;
 199     data->rectangle.MaxY = msg->MaxY;
 200     setRectangle(cl, obj);
 201
 202     return 0;
 203 }
 204
 205
 206 IPTR Calltips__MUIM_Calltips_ParentSetup( struct IClass *cl, Object *obj, Msg msg)
 207 {
 208     return 0;
 209 }
 210
 211
 212 IPTR Calltips__MUIM_Calltips_ParentCleanup(struct IClass *cl, Object *obj, Msg msg)
 213 {
 214     return 0;
 215 }
 216
 217
 218 IPTR Calltips__MUIM_Calltips_ParentShow(struct IClass *cl, Object *obj, Msg msg)
 219 {
 220     struct Data *data = INST_DATA(cl, obj);
 221
 222     setRectangle(cl, obj);
 223
 224     // open our window if it was not opened before
 225     if(XGET(obj, MUIA_Window_Open) == FALSE)
 226     {
 227         set(obj, MUIA_Window_Open, TRUE);
 228         // check again if we opened successfully
 229         if(XGET(obj, MUIA_Window_Open) == TRUE)
 230         {
 231             // make sure we are in front of our parent window
 232             MoveWindowInFrontOf(_window(data->rootGroup), _window(data->source));
 233         }
 234     }
 235
 236     return 0;
 237 }
 238
 239
 240 IPTR Calltips__MUIM_Calltips_ParentHide(struct IClass *cl, Object *obj, Msg msg)
 241 {
 242     set(obj, MUIA_Window_Open, FALSE);
 243
 244     return 0;
 245 }
 246
 247
 248 IPTR Calltips__MUIM_Calltips_ParentWindowArranged(struct IClass *cl, Object *obj, Msg msg)
 249 {
 250     setRectangle(cl, obj);
 251
 252     return 0;
 253 }