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