workbench/classes/zune/listtree/listtree.c

   1 /*
   2     Copyright © 2012-2015, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #define MUIMASTER_YES_INLINE_STDARG
   7
   8 #include <proto/muimaster.h>
   9 #include <proto/intuition.h>
  10 #include <proto/utility.h>
  11 #include <proto/graphics.h>
  12 #include <clib/alib_protos.h>
  13 #include <mui/NListtree_mcc.h>
  14 #include <mui/NList_mcc.h>
  15
  16 #undef TNF_OPEN
  17 #undef TNF_LIST
  18 #include "Listtree_mcc.h"
  19 #include "listtree_private.h"
  20
  21 #include <aros/debug.h>
  22
  23 struct MUIS_Listtree_TreeNodeInt
  24 {
  25     struct MUIS_Listtree_TreeNode base;
  26     struct MUI_NListtree_TreeNode *ref;
  27 };
  28
  29 #define NEWHANDLE(attrname)                                         \
  30     case(attrname):                                                 \
  31         bug("[Listtree] OM_NEW:%s - unsupported\n", #attrname);     \
  32         break;
  33
  34 #define CONV(AATTR, BATTR)                                          \
  35     case(AATTR):                                                    \
  36         convtags[i].ti_Tag = BATTR;                                 \
  37         convtags[i++].ti_Data = tag->ti_Data;                       \
  38         break;
  39
  40 #define CONVFIN                     \
  41     convtags[i].ti_Tag  = TAG_DONE; \
  42     convtags[i].ti_Data = TAG_DONE;
  43
  44 /*** Methods ****************************************************************/
  45 Object *Listtree__OM_NEW(struct IClass *cl, Object *obj, struct opSet *msg)
  46 {
  47     struct Listtree_DATA *data = NULL;
  48     struct TagItem *tag;
  49     struct TagItem *tags;
  50     Object *nlisttree = NULL;
  51     struct TagItem convtags[20];
  52     LONG i = 0;
  53
  54     /* Convert tags designated for NListtree */
  55     for (tags = msg->ops_AttrList; (tag = NextTagItem(&tags)); )
  56     {
  57         switch (tag->ti_Tag)
  58         {
  59         CONV(MUIA_Frame,                    MUIA_Frame)
  60         CONV(MUIA_Listtree_Format,          MUIA_NListtree_Format)
  61         CONV(MUIA_Listtree_Title,           MUIA_NListtree_Title)
  62         CONV(MUIA_Listtree_DragDropSort,    MUIA_NListtree_DragDropSort)
  63         CONV(MUIA_List_Title,               MUIA_NList_Title)
  64         CONV(MUIA_List_DragSortable,        MUIA_NList_DragSortable)
  65 //        CONV(MUIA_ContextMenu,              MUIA_ContextMenu) // FIXME causes a crash when right clicking
  66         CONV(MUIA_List_MinLineHeight,       MUIA_NList_MinLineHeight)
  67         }
  68     }
  69     CONVFIN
  70
  71     /* TODO:
  72      * set up a DestructHook which will call proxy MUIS_Listtree_TreeNode destrhook and
  73      * free it afterwards
  74      */
  75     obj = (Object *) DoSuperNewTags(cl, obj, 0,
  76             Child, nlisttree = (Object *) NListtreeObject,
  77                                 TAG_MORE, (IPTR)convtags,
  78                                 End,
  79             );
  80
  81     if (!obj) return FALSE;
  82
  83     data = INST_DATA(cl, obj);
  84     data->nlisttree = nlisttree;
  85
  86     data->pool = CreatePool(MEMF_ANY | MEMF_CLEAR, 16 * 1024, 8 * 1024);
  87
  88     /* parse initial taglist */
  89     for (tags = msg->ops_AttrList; (tag = NextTagItem(&tags)); )
  90     {
  91         switch (tag->ti_Tag)
  92         {
  93         case(MUIA_Listtree_ConstructHook):
  94             data->constrhook = (struct Hook *)tag->ti_Data;
  95             break;
  96         case(MUIA_Listtree_DestructHook):
  97             data->destrhook = (struct Hook *)tag->ti_Data;
  98             break;
  99         case(MUIA_List_MinLineHeight):
 100         case(MUIA_ContextMenu):
 101         case(MUIA_List_DragSortable):
 102         case(MUIA_List_Title):
 103         case(MUIA_Listtree_DragDropSort):
 104         case(MUIA_Listtree_Format):
 105         case(MUIA_Listtree_Title):
 106         case(MUIA_Frame):
 107             /* Forwarded to NListtree */
 108             break;
 109         NEWHANDLE(MUIA_Listtree_DisplayHook)
 110         NEWHANDLE(MUIA_Listtree_SortHook)
 111         default:
 112             bug("[Listtree] OM_NEW: unhandled %x\n", tag->ti_Tag);
 113         }
 114     }
 115
 116     return obj;
 117 }
 118
 119 #define SETHANDLE(attrname)                                         \
 120     case(attrname):                                                 \
 121         bug("[Listtree] OM_SET:%s - unsupported\n", #attrname);     \
 122         break;
 123
 124 #define FORWARDSET(AATTR, BATTR)                    \
 125     case(AATTR):                                    \
 126         set(data->nlisttree, BATTR, tag->ti_Data);  \
 127         break;
 128
 129 #define IGNORESET(AATTR)    case(AATTR): break;
 130
 131 IPTR Listtree__OM_SET(struct IClass *cl, Object *obj, struct opSet *msg)
 132 {
 133     struct Listtree_DATA *data = INST_DATA(cl, obj);
 134     struct TagItem      *tstate = msg->ops_AttrList;
 135     struct TagItem      *tag;
 136
 137     if (!data->nlisttree)
 138         return DoSuperMethodA(cl, obj, (Msg) msg);
 139
 140     while ((tag = NextTagItem(&tstate)) != NULL)
 141     {
 142         switch (tag->ti_Tag)
 143         {
 144         FORWARDSET(MUIA_Listtree_Quiet, MUIA_NListtree_Quiet)
 145         FORWARDSET(MUIA_List_Active, MUIA_NList_Active)
 146
 147         IGNORESET(MUIA_Listview_SelectChange)
 148
 149         case(MUIA_Listtree_Active):
 150             set(data->nlisttree, MUIA_NListtree_Active,
 151                     ((struct MUIS_Listtree_TreeNodeInt *)tag->ti_Data)->ref);
 152             break;
 153
 154         SETHANDLE(MUIA_Listtree_DoubleClick)
 155         case MUIB_List | 0x00000010: break;
 156         case MUIA_Prop_First: break;
 157         case MUIA_Prop_DoSmooth: break;
 158         case MUIA_NoNotify: break;
 159         case MUIA_Prop_Entries: break;
 160         case MUIA_Prop_Visible: break;
 161         case MUIA_Prop_DeltaFactor: break;
 162         default:
 163             bug("[Listtree] OM_SET: passing to parent class %x\n", tag->ti_Tag);
 164         }
 165     }
 166
 167
 168     return DoSuperMethodA(cl, obj, (Msg) msg);
 169 }
 170
 171 #define GETHANDLE(attrname)                                         \
 172     case(attrname):                                                 \
 173         bug("[Listtree] OM_GET:%s - unsupported\n", #attrname);     \
 174         break;
 175
 176
 177 #define MUIA_List_Prop_Entries  /* PRIV */ \
 178     (MUIB_MUI | 0x0042a8f5)     /* .sg LONG  PRIV */
 179 #define MUIA_List_Prop_Visible  /* PRIV */ \
 180     (MUIB_MUI | 0x004273e9)     /* .sg LONG  PRIV */
 181 #define MUIA_List_Prop_First    /* PRIV */ \
 182     (MUIB_MUI | 0x00429df3)     /* .sg LONG  PRIV */
 183
 184 #define MUIA_List_VertProp_Entries  /* PRIV */ \
 185     MUIA_List_Prop_Entries     /* PRIV */
 186 #define MUIA_List_VertProp_Visible  /* PRIV */ \
 187     MUIA_List_Prop_Visible     /* PRIV */
 188 #define MUIA_List_VertProp_First  /* PRIV */ \
 189     MUIA_List_Prop_First       /* PRIV */
 190
 191 #define FORWARDGET(AATTR, BATTR)                            \
 192     case(AATTR):                                            \
 193         *(msg->opg_Storage) = XGET(data->nlisttree, BATTR); \
 194         return TRUE;
 195
 196 IPTR Listtree__OM_GET(struct IClass *cl, Object *obj, struct opGet *msg)
 197 {
 198     struct Listtree_DATA *data = INST_DATA(cl, obj);
 199
 200     if (!data->nlisttree)
 201         return FALSE;
 202
 203     switch (msg->opg_AttrID)
 204     {
 205     FORWARDGET(MUIA_Frame, MUIA_Frame)
 206     FORWARDGET(MUIA_Listtree_DoubleClick, MUIA_NListtree_DoubleClick)
 207     FORWARDGET(MUIA_List_Active, MUIA_NList_Active)
 208     FORWARDGET(MUIA_Listtree_Active, MUIA_NListtree_Active)
 209     FORWARDGET(MUIA_Listtree_Quiet, MUIA_NListtree_Quiet)
 210     FORWARDGET(MUIA_List_Visible, MUIA_NList_Visible)
 211
 212     GETHANDLE(MUIA_List_VertProp_Entries)
 213     GETHANDLE(MUIA_List_VertProp_Visible)
 214     GETHANDLE(MUIA_List_VertProp_First)
 215     case MUIA_Disabled: break;
 216     case MUIA_Parent: break;
 217     case MUIA_Group_ChildList: break;
 218     case MUIA_Prop_First: break;
 219     case MUIA_Prop_DoSmooth: break;
 220     case MUIA_Listview_List: break;
 221     case MUIA_Virtgroup_Left: break;
 222     case MUIA_Virtgroup_Top: break;
 223     case 0x9d510020 /*MUIA_NListview_NList*/: break;
 224     default:
 225         bug("[Listtree] OM_GET: passing to parent class %x\n", msg->opg_AttrID);
 226     }
 227
 228     return DoSuperMethodA(cl, obj, (Msg) msg);
 229 }
 230
 231 #define METHODSTUB(methodname)                                          \
 232 IPTR Listtree__##methodname(struct IClass *cl, Object *obj, Msg msg)    \
 233 {                                                                       \
 234     bug("[Listtree] Usupported : %s\n", #methodname);                   \
 235     return (IPTR)FALSE;                                                 \
 236 }
 237
 238 METHODSTUB(MUIM_Listtree_Rename)
 239 METHODSTUB(MUIM_Listtree_Open)
 240 METHODSTUB(MUIM_Listtree_Close)
 241 METHODSTUB(MUIM_Listtree_SetDropMark)
 242 METHODSTUB(MUIM_Listtree_FindName)
 243
 244 IPTR Listtree__MUIM_Listtree_Insert(struct IClass *cl, Object *obj, struct MUIP_Listtree_Insert *msg)
 245 {
 246     struct Listtree_DATA *data = INST_DATA(cl, obj);
 247     struct MUIS_Listtree_TreeNodeInt * _int = AllocPooled(data->pool, sizeof(struct MUIS_Listtree_TreeNodeInt));
 248     struct MUIS_Listtree_TreeNode * _return = &_int->base;
 249
 250     if (_return == NULL)
 251         return (IPTR)NULL;
 252
 253     _return->tn_Flags = (UWORD)msg->Flags;
 254     if (msg->Name)
 255     {
 256         LONG len = strlen(msg->Name) + 1;
 257         _return->tn_Name = AllocPooled(data->pool, len);
 258         CopyMem(msg->Name, _return->tn_Name, len);
 259     }
 260
 261     if (data->constrhook)
 262         _return->tn_User = (APTR)CallHookPkt(data->constrhook, data->pool, msg->User);
 263     else
 264         _return->tn_User = msg->User;
 265
 266     /* TEMP */
 267     if (msg->ListNode != (APTR)MUIV_Listtree_Insert_ListNode_Root)
 268         bug("[Listtree] MUIM_Listtree_Insert - unhandled value of ListNode %x\n", msg->ListNode);
 269
 270     if ((msg->PrevNode != (APTR)MUIV_Listtree_Insert_PrevNode_Tail)
 271         && (msg->PrevNode != (APTR)MUIV_Listtree_Insert_PrevNode_Sorted))
 272         bug("[Listtree] MUIM_Listtree_Insert - unhandled value of PrevNode %x\n", msg->PrevNode);
 273     /* TEMP */
 274     /* TODO
 275      * add handling for cases where ListNode and PrevNode actually point to Treenode structure
 276
 277      * handle remaining enumeration values
 278      */
 279
 280     _int->ref = (struct MUI_NListtree_TreeNode *)DoMethod(data->nlisttree,
 281                     MUIM_NListtree_Insert, _return->tn_Name, _return, msg->ListNode,
 282                     msg->PrevNode, _return->tn_Flags);
 283
 284     return (IPTR)_return;
 285 }
 286
 287 IPTR Listtree__MUIM_Listtree_GetEntry(struct IClass *cl, Object *obj, struct MUIP_Listtree_GetEntry *msg)
 288 {
 289     struct Listtree_DATA *data = INST_DATA(cl, obj);
 290     struct MUI_NListtree_TreeNode * n = NULL;
 291
 292     switch ((IPTR)msg->Node)
 293     {
 294     case(MUIV_Listtree_GetEntry_ListNode_Root):
 295     case(MUIV_Listtree_GetEntry_ListNode_Active):
 296         n = msg->Node;
 297         break;
 298     default:
 299         n = ((struct MUIS_Listtree_TreeNodeInt *)msg->Node)->ref;
 300     }
 301
 302     struct MUI_NListtree_TreeNode * tn = (struct MUI_NListtree_TreeNode *) DoMethod(data->nlisttree,
 303             MUIM_NListtree_GetEntry, n, msg->Position, msg->Flags);
 304
 305     if (tn)
 306         return (IPTR)tn->tn_User;
 307     else
 308         return (IPTR)NULL;
 309 }
 310
 311 IPTR Listtree__MUIM_Listtree_Remove(struct IClass *cl, Object *obj, struct MUIP_Listtree_Remove *msg)
 312 {
 313     struct Listtree_DATA *data = INST_DATA(cl, obj);
 314
 315     /* TODO: handle remaining enumeration values */
 316     if ((msg->ListNode == (APTR)MUIV_Listtree_Remove_ListNode_Root) &&
 317             ((msg->TreeNode == (APTR)MUIV_Listtree_Remove_TreeNode_Active) ||
 318              (msg->TreeNode == (APTR)MUIV_Listtree_Remove_TreeNode_All)))
 319     {
 320         /* Deallocating of MUIS_Listtree_TreeNode is happening in the DestructHook */
 321         return DoMethod(data->nlisttree, MUIM_NListtree_Remove, msg->ListNode, msg->TreeNode, msg->Flags);
 322     }
 323
 324     /* TODO
 325      * add handling for cases where ListNode/TreeNode actually point to Treenode structure
 326      */
 327     bug("[Listtree] MUIM_Listtree_Remove unsupported code path Listnode: %x, Treenode: %x, Flags: %d\n", msg->ListNode, msg->TreeNode, msg->Flags);
 328
 329     return (IPTR)FALSE;
 330 }
 331
 332 IPTR Listtree__MUIM_List_TestPos(struct IClass *cl, Object *obj, struct MUIP_List_TestPos *msg)
 333 {
 334     struct Listtree_DATA *data = INST_DATA(cl, obj);
 335
 336     struct MUI_NList_TestPos_Result res;
 337     if (DoMethod(data->nlisttree, MUIM_List_TestPos, msg->x, msg->y, &res))
 338     {
 339         msg->res->entry     = res.entry;
 340         msg->res->column    = res.column;
 341         msg->res->flags     = res.flags;
 342         msg->res->xoffset   = res.xoffset;
 343         msg->res->yoffset   = res.yoffset;
 344         return TRUE;
 345     }
 346
 347     return FALSE;
 348 }
 349
 350 IPTR Listtree__MUIM_Listtree_TestPos(struct IClass *cl, Object *obj, struct MUIP_Listtree_TestPos *msg)
 351 {
 352     struct Listtree_DATA *data = INST_DATA(cl, obj);
 353
 354     struct MUI_NListtree_TestPos_Result res;
 355     struct MUIS_Listtree_TestPos_Result * _ret = (struct MUIS_Listtree_TestPos_Result *)msg->Result;
 356
 357     _ret->tpr_TreeNode = NULL;
 358
 359     DoMethod(data->nlisttree, MUIM_NListtree_TestPos, msg->X, msg->Y, &res);
 360
 361     _ret->tpr_Flags     = res.tpr_Type;
 362     _ret->tpr_ListEntry = res.tpr_ListEntry;
 363     _ret->tpr_ListFlags = res.tpr_ListFlags;
 364
 365     if (res.tpr_TreeNode != NULL)
 366     {
 367         _ret->tpr_TreeNode  = res.tpr_TreeNode->tn_User;
 368         return TRUE;
 369     }
 370
 371     return FALSE;
 372 }
 373
 374 IPTR Listtree__MUIM_Listtree_GetNr(struct IClass *cl, Object *obj, struct MUIP_Listtree_GetNr *msg)
 375 {
 376     struct Listtree_DATA *data = INST_DATA(cl, obj);
 377     struct MUI_NListtree_TreeNode * tn = NULL;
 378
 379     switch((IPTR)msg->TreeNode)
 380     {
 381     case(MUIV_Listtree_GetNr_TreeNode_Active):
 382         tn = msg->TreeNode;
 383         break;
 384     default:
 385         tn = ((struct MUIS_Listtree_TreeNodeInt *)msg->TreeNode)->ref;
 386     }
 387
 388     return DoMethod(data->nlisttree, MUIM_NListtree_GetNr, tn, msg->Flags);
 389 }