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     obj = (Object *) DoSuperNewTags(cl, obj, 0,
  66             Child, nlisttree = (Object *) NListtreeObject,
  67                                 TAG_MORE, (IPTR)convtags,
  68                                 End,
  69             );
  70
  71     if (!obj) return FALSE;
  72
  73     data = INST_DATA(cl, obj);
  74     data->nlisttree = nlisttree;
  75
  76     data->pool = CreatePool(MEMF_ANY | MEMF_CLEAR, 16 * 1024, 8 * 1024);
  77
  78     /* parse initial taglist */
  79     for (tags = msg->ops_AttrList; (tag = NextTagItem(&tags)); )
  80     {
  81         switch (tag->ti_Tag)
  82         {
  83         case(MUIA_Listtree_ConstructHook):
  84             data->constrhook = (struct Hook *)tag->ti_Data;
  85             break;
  86         case(MUIA_Listtree_DestructHook):
  87             data->destrhook = (struct Hook *)tag->ti_Data;
  88             break;
  89         case(MUIA_List_MinLineHeight):
  90         case(MUIA_ContextMenu):
  91         case(MUIA_List_DragSortable):
  92         case(MUIA_List_Title):
  93         case(MUIA_Listtree_DragDropSort):
  94         case(MUIA_Listtree_Format):
  95         case(MUIA_Listtree_Title):
  96         case(MUIA_Frame):
  97             /* Forwarded to NListtree */
  98             break;
  99         NEWHANDLE(MUIA_Listtree_DisplayHook)
 100         NEWHANDLE(MUIA_Listtree_SortHook)
 101         default:
 102             bug("[Listtree] OM_NEW: unhandled %x\n", tag->ti_Tag);
 103         }
 104     }
 105
 106     return obj;
 107 }
 108
 109 #define SETHANDLE(attrname)                                         \
 110     case(attrname):                                                 \
 111         bug("[Listtree] OM_SET:%s - unsupported\n", #attrname);     \
 112         break;
 113
 114 IPTR Listtree__OM_SET(struct IClass *cl, Object *obj, struct opSet *msg)
 115 {
 116     struct TagItem      *tstate = msg->ops_AttrList;
 117     struct TagItem      *tag;
 118
 119     while ((tag = NextTagItem(&tstate)) != NULL)
 120     {
 121         switch (tag->ti_Tag)
 122         {
 123         SETHANDLE(MUIA_Listtree_Active)
 124         SETHANDLE(MUIA_Listtree_Quiet)
 125         SETHANDLE(MUIA_Listtree_DoubleClick)
 126         case MUIB_List | 0x00000010: break;
 127         case MUIA_Prop_First: break;
 128         case MUIA_Prop_DoSmooth: break;
 129         case MUIA_NoNotify: break;
 130         case MUIA_Prop_Entries: break;
 131         case MUIA_Prop_Visible: break;
 132         case MUIA_Prop_DeltaFactor: break;
 133         default:
 134             bug("[Listtree] OM_SET: passing to parent class %x\n", tag->ti_Tag);
 135         }
 136     }
 137
 138
 139     return DoSuperMethodA(cl, obj, (Msg) msg);
 140 }
 141
 142 #define GETHANDLE(attrname)                                         \
 143     case(attrname):                                                 \
 144         bug("[Listtree] OM_GET:%s - unsupported\n", #attrname);     \
 145         break;
 146
 147
 148 #define MUIA_List_Prop_Entries  /* PRIV */ \
 149     (MUIB_MUI | 0x0042a8f5)     /* .sg LONG  PRIV */
 150 #define MUIA_List_Prop_Visible  /* PRIV */ \
 151     (MUIB_MUI | 0x004273e9)     /* .sg LONG  PRIV */
 152 #define MUIA_List_Prop_First    /* PRIV */ \
 153     (MUIB_MUI | 0x00429df3)     /* .sg LONG  PRIV */
 154
 155 #define MUIA_List_VertProp_Entries  /* PRIV */ \
 156     MUIA_List_Prop_Entries     /* PRIV */
 157 #define MUIA_List_VertProp_Visible  /* PRIV */ \
 158     MUIA_List_Prop_Visible     /* PRIV */
 159 #define MUIA_List_VertProp_First  /* PRIV */ \
 160     MUIA_List_Prop_First       /* PRIV */
 161
 162 IPTR Listtree__OM_GET(struct IClass *cl, Object *obj, struct opGet *msg)
 163 {
 164     switch (msg->opg_AttrID)
 165     {
 166     GETHANDLE(MUIA_Listtree_Active)
 167     GETHANDLE(MUIA_Listtree_Quiet)
 168     GETHANDLE(MUIA_Listtree_DoubleClick)
 169     GETHANDLE(MUIA_List_Active)
 170     GETHANDLE(MUIA_Frame)
 171     GETHANDLE(MUIA_List_VertProp_Entries)
 172     GETHANDLE(MUIA_List_VertProp_Visible)
 173     GETHANDLE(MUIA_List_VertProp_First)
 174     case MUIA_Disabled: break;
 175     case MUIA_Parent: break;
 176     case MUIA_Group_ChildList: break;
 177     case MUIA_Prop_First: break;
 178     case MUIA_Prop_DoSmooth: break;
 179     case MUIA_Listview_List: break;
 180     case MUIA_Virtgroup_Left: break;
 181     case MUIA_Virtgroup_Top: break;
 182     case 0x9d510020 /*MUIA_NListview_NList*/: break;
 183     default:
 184         bug("[Listtree] OM_GET: passing to parent class %x\n", msg->opg_AttrID);
 185     }
 186
 187     return DoSuperMethodA(cl, obj, (Msg) msg);
 188 }
 189
 190 #define METHODSTUB(methodname)                                          \
 191 IPTR Listtree__##methodname(struct IClass *cl, Object *obj, Msg msg)    \
 192 {                                                                       \
 193     bug("[Listtree] Usupported : %s\n", #methodname);                   \
 194     return (IPTR)FALSE;                                                 \
 195 }
 196
 197 METHODSTUB(MUIM_Listtree_Rename)
 198 METHODSTUB(MUIM_Listtree_Open)
 199 METHODSTUB(MUIM_Listtree_Close)
 200 METHODSTUB(MUIM_Listtree_TestPos)
 201 METHODSTUB(MUIM_Listtree_SetDropMark)
 202 METHODSTUB(MUIM_Listtree_FindName)
 203 METHODSTUB(MUIM_List_TestPos)
 204 METHODSTUB(MUIM_Listtree_Remove)
 205 METHODSTUB(MUIM_Listtree_GetNr)
 206
 207 IPTR Listtree__MUIM_Listtree_Insert(struct IClass *cl, Object *obj, struct MUIP_Listtree_Insert *msg)
 208 {
 209     struct Listtree_DATA *data = INST_DATA(cl, obj);
 210     struct MUIS_Listtree_TreeNode * _return = AllocPooled(data->pool, sizeof(struct MUIS_Listtree_TreeNode));
 211
 212     if (_return == NULL)
 213         return (IPTR)NULL;
 214
 215     _return->tn_Flags = (UWORD)msg->Flags;
 216     if (msg->Name)
 217     {
 218         LONG len = strlen(msg->Name) + 1;
 219         _return->tn_Name = AllocPooled(data->pool, len);
 220         CopyMem(msg->Name, _return->tn_Name, len);
 221     }
 222
 223     if (data->constrhook)
 224         _return->tn_User = (APTR)CallHookPkt(data->constrhook, data->pool, msg->User);
 225     else
 226         _return->tn_User = msg->User;
 227
 228     /* TEMP */
 229     if (msg->ListNode != (APTR)MUIV_Listtree_Insert_ListNode_Root)
 230         bug("[Listtree] MUIM_Listtree_Insert - unhandled value of ListNode %x\n", msg->ListNode);
 231
 232     if ((msg->PrevNode != (APTR)MUIV_Listtree_Insert_PrevNode_Tail)
 233         && (msg->PrevNode != (APTR)MUIV_Listtree_Insert_PrevNode_Sorted))
 234         bug("[Listtree] MUIM_Listtree_Insert - unhandled value of PrevNode %x\n", msg->PrevNode);
 235     /* TEMP */
 236     /* TODO
 237      * add handling for cases where ListNode and PrevNode actually point to Treenode structure
 238      * The internal TreeNode structure needs to have then the poiter to NListTree node to be
 239      * able to traslate. The pointer is acquired as return from below DoMethod call
 240      */
 241
 242     DoMethod(data->nlisttree, MUIM_NListtree_Insert, _return->tn_Name, _return, msg->ListNode,
 243             msg->PrevNode, _return->tn_Flags);
 244
 245     return (IPTR)_return;
 246 }
 247
 248 IPTR Listtree__MUIM_Listtree_GetEntry(struct IClass *cl, Object *obj, struct MUIP_Listtree_GetEntry *msg)
 249 {
 250     struct Listtree_DATA *data = INST_DATA(cl, obj);
 251
 252     /* TEMP */
 253     if ((msg->Node != (APTR)MUIV_Listtree_GetEntry_ListNode_Root)
 254         && (msg->Node != (APTR)MUIV_Listtree_GetEntry_ListNode_Active))
 255         bug("[Listtree] MUIM_Listtree_GetEntry - unhandled value of Node %x\n", msg->Node);
 256     /* TEMP */
 257     /* TODO
 258      * add handling for cases where Node actually point to Treenode structure
 259      */
 260
 261     struct MUI_NListtree_TreeNode * tn = (struct MUI_NListtree_TreeNode *) DoMethod(data->nlisttree,
 262             MUIM_NListtree_GetEntry, msg->Node, msg->Position, msg->Flags);
 263
 264     if (tn)
 265         return (IPTR)tn->tn_User;
 266     else
 267         return (IPTR)NULL;
 268 }