workbench/libs/desktop/support.c

   1 /*
   2    Copyright © 1995-2003, The AROS Development Team. All rights reserved.
   3    $Id$
   4 */
   5
   6 #define MUIMASTER_YES_INLINE_STDARG
   7
   8 #include <exec/types.h>
   9 #include <exec/memory.h>
  10 #include <exec/nodes.h>
  11 #include <dos/dos.h>
  12 #include <dos/dostags.h>
  13 #include <dos/dosextens.h>
  14 #include <intuition/classes.h>
  15 #include <libraries/desktop.h>
  16 #include <libraries/gadtools.h>
  17 #include <utility/tagitem.h>
  18
  19 #include <proto/dos.h>
  20 #include <proto/exec.h>
  21 #include <proto/intuition.h>
  22
  23 #include "desktop_intern.h"
  24 #include "support.h"
  25
  26 #include "desktop_intern_protos.h"
  27
  28 #define DEBUG 1
  29 #include <aros/debug.h>
  30
  31 BOOL startDesktopHandler(void)
  32 {
  33     /*
  34         NOTE: the OPEN vector (the only caller of this function)
  35         already has a mutex on the library base at this point
  36     */
  37     struct Process *process = NULL;
  38     struct Message *msg     = NULL;
  39     struct MsgPort *port    = (struct MsgPort *) CreateMsgPort();
  40
  41     if (port == NULL)
  42     {
  43         D(bug("[desktop handler starter] ERROR: Could not create message port!\n"));
  44         return FALSE;
  45     }
  46
  47     D(bug("*** Starting desktop handler\n"));
  48     process = CreateNewProcTags
  49     (
  50         NP_Entry,     (IPTR) desktopHandler,
  51         NP_Name,      (IPTR) "Desktop Handler",
  52         NP_StackSize,        8192,
  53         NP_UserData,  (IPTR) port,
  54
  55         TAG_DONE
  56     );
  57
  58     if (process == NULL)
  59     {
  60         // FIXME: deallocate msgport??
  61         D(bug("[desktop handler starter] ERROR: Could not start desktop handler process!\n"));
  62         return FALSE;
  63     }
  64
  65     WaitPort(port);
  66     msg = GetMsg(port);
  67     ReplyMsg(msg);
  68
  69     D(bug("*** Desktop Handler started OK\n"));
  70
  71     return TRUE;
  72 }
  73
  74 BOOL handlerAddUser(void)
  75 {
  76     struct MsgPort *port;
  77     struct DesktopInternMsg msg;
  78
  79     kprintf("/// Attempting to obtain semaphore\n");
  80     if (!AttemptSemaphoreShared(&DesktopBase->db_HandlerSafety))
  81         return FALSE;
  82
  83     port = CreateMsgPort();
  84     if (port)
  85     {
  86         msg.di_Message.mn_Node.ln_Type = NT_MESSAGE;
  87         msg.di_Message.mn_ReplyPort = port;
  88         msg.di_Message.mn_Length = sizeof(struct DesktopInternMsg);
  89         msg.di_Command = DIMC_ADDUSER;
  90
  91         PutMsg(DesktopBase->db_HandlerPort, (struct Message *) &msg);
  92
  93         kprintf("/// addmsg: awaitng reply from handler\n");
  94         WaitPort(port);
  95         GetMsg(port);
  96     }
  97     kprintf("/// addmsg: got reply, releasing semaphore\n");
  98
  99     ReleaseSemaphore(&DesktopBase->db_HandlerSafety);
 100
 101     return TRUE;
 102 }
 103
 104 BOOL handlerSubUser(void)
 105 {
 106     struct MsgPort *port;
 107     struct DesktopInternMsg msg;
 108
 109     port = CreateMsgPort();
 110     if (port)
 111     {
 112         msg.di_Message.mn_Node.ln_Type = NT_MESSAGE;
 113         msg.di_Message.mn_ReplyPort = port;
 114         msg.di_Message.mn_Length = sizeof(struct DesktopInternMsg);
 115         msg.di_Command = DIMC_SUBUSER;
 116
 117         PutMsg(DesktopBase->db_HandlerPort, (struct Message *) &msg);
 118
 119         WaitPort(port);
 120         GetMsg(port);
 121     }
 122
 123     return TRUE;
 124 }
 125
 126 struct HandlerScanRequest *createScanMessage(ULONG command,
 127                                              struct MsgPort *replyPort,
 128                                              BPTR dirLock, Object * callback,
 129                                              Object * app)
 130 {
 131     struct HandlerScanRequest *hsr;
 132
 133     hsr =
 134         (struct HandlerScanRequest *)
 135         AllocVec(sizeof(struct HandlerScanRequest), MEMF_ANY);
 136     hsr->hsr_Message.di_Message.mn_Length = sizeof(struct HandlerScanRequest);
 137     hsr->hsr_Message.di_Message.mn_Node.ln_Type = NT_MESSAGE;
 138     hsr->hsr_Message.di_Message.mn_ReplyPort = replyPort;
 139     hsr->hsr_Message.di_Command = command;
 140     hsr->hsr_CallBack = callback;
 141     hsr->hsr_DirLock = dirLock;
 142     hsr->hsr_Application = app;
 143
 144     return hsr;
 145 }
 146
 147 struct HandlerTopLevelRequest *createTLScanMessage(ULONG command,
 148                                                    struct MsgPort *replyPort,
 149                                                    ULONG types,
 150                                                    Object * callback,
 151                                                    Object * app)
 152 {
 153     struct HandlerTopLevelRequest *htl;
 154
 155     htl =
 156         (struct HandlerTopLevelRequest *)
 157         AllocVec(sizeof(struct HandlerTopLevelRequest), MEMF_ANY);
 158     htl->htl_Message.di_Message.mn_Length = sizeof(struct HandlerScanRequest);
 159     htl->htl_Message.di_Message.mn_Node.ln_Type = NT_MESSAGE;
 160     htl->htl_Message.di_Message.mn_ReplyPort = replyPort;
 161     htl->htl_Message.di_Command = command;
 162     htl->htl_Types = types;
 163     htl->htl_CallBack = callback;
 164     htl->htl_Application = app;
 165
 166     return htl;
 167 }
 168
 169
 170 struct WorkingMessageNode *findWorkedMessage(struct MinList *list, ULONG id)
 171 {
 172     struct WorkingMessageNode *wmn;
 173     BOOL            found = FALSE;
 174
 175     wmn = (struct WorkingMessageNode *)list->mlh_Head;
 176     while (!found && wmn->wm_Node.mln_Succ)
 177     {
 178         if (wmn->wm_ID == id)
 179             found = TRUE;
 180         else
 181             wmn = (struct WorkingMessageNode *)wmn->wm_Node.mln_Succ;
 182     }
 183
 184     return wmn;
 185 }
 186
 187
 188 BOOL findOperationItem(LONG menuNumber, struct DesktopOperationItem * doi,
 189                        struct NewMenu * menuDat, LONG * i)
 190 {
 191     LONG            j = 0,
 192         k;
 193     BOOL            found = FALSE;
 194
 195
 196     while (!found && doi[j].doi_Code != 0)
 197     {
 198     // find menu number in doi
 199         if (doi[j].doi_Number == menuNumber)
 200         {
 201         // find matching entry in menudat
 202             k = 0;
 203             while (!found && menuDat[k].nm_Type != NM_END)
 204             {
 205                 if (menuDat[k].nm_UserData == doi[j].doi_Code)
 206                 {
 207                 // kprintf("found mutex to exclude : %s\n", doi[j].doi_Name);
 208                     found = TRUE;
 209                     *i = k;
 210                 }
 211                 k++;
 212             }
 213         }
 214
 215         if (doi[j].doi_SubItems)
 216         {
 217             LONG            m = 0;
 218
 219             while (!found && doi[j].doi_SubItems[m].doi_Code != 0)
 220             {
 221                 if (doi[j].doi_SubItems[m].doi_Number == menuNumber)
 222                 {
 223                 // find matching entry in menudat
 224                     k = 0;
 225                     while (!found && menuDat[k].nm_Type != NM_END)
 226                     {
 227                         if (menuDat[k].nm_UserData ==
 228                             doi[j].doi_SubItems[m].doi_Code)
 229                         {
 230                             found = TRUE;
 231                             *i = k;
 232                         }
 233                         k++;
 234                     }
 235                 }
 236                 m++;
 237             }
 238         }
 239
 240         j++;
 241     }
 242
 243     return found;
 244 }
 245
 246 LONG getItemPosition(struct NewMenu * menuDat, LONG i)
 247 {
 248     LONG            j = i - 1;
 249     UBYTE           menuType;
 250
 251     while (menuDat[j].nm_Type == menuDat[i].nm_Type)
 252         j--;
 253
 254     return i - j - 1;
 255 }
 256
 257 void doExclude(struct DesktopOperationItem *doi, struct NewMenu *menuDat,
 258                LONG n)
 259 {
 260     LONG            i = 0,
 261         j = 0;
 262     LONG            bitNum;
 263
 264     while (doi[j].doi_Code != 0)
 265     {
 266         if (doi[j].doi_MutualExclude)
 267         {
 268             bitNum = 0;
 269             while (bitNum < 32)
 270             {
 271                 if (bitNum & doi[j].doi_MutualExclude)
 272                 {
 273                     if (findOperationItem(bitNum, doi, menuDat, &i))
 274                         menuDat[n].nm_MutualExclude |=
 275                             (1 << getItemPosition(menuDat, i));
 276                 }
 277
 278                 bitNum++;
 279             }
 280         }
 281
 282         n++;
 283         if (doi[j].doi_SubItems)
 284         {
 285             LONG            k = 0;
 286
 287             while (doi[j].doi_SubItems[k].doi_Code != 0)
 288             {
 289                 if (doi[j].doi_SubItems[k].doi_MutualExclude)
 290                 {
 291                     bitNum = 0;
 292                     while (bitNum < 32)
 293                     {
 294                         if ((1 << bitNum) & doi[j].doi_SubItems[k].
 295                             doi_MutualExclude)
 296                         {
 297                             if (findOperationItem(bitNum, doi, menuDat, &i))
 298                                 menuDat[n].nm_MutualExclude |=
 299                                     (1 << getItemPosition(menuDat, i));
 300                         }
 301
 302                         bitNum++;
 303                     }
 304                     k++;
 305                 }
 306                 n++;
 307             }
 308         }
 309
 310         j++;
 311         n++;
 312     }
 313 }
 314
 315 void processOperationItem(LONG * reali, LONG * realj,
 316                           struct DesktopOperationItem *doi,
 317                           struct NewMenu *menuDat)
 318 {
 319     LONG            i = *reali,
 320         j = *realj;
 321
 322     menuDat[i].nm_Type = NM_ITEM;
 323     menuDat[i].nm_Label = doi[j].doi_Name;
 324     menuDat[i].nm_CommKey = 0;
 325     menuDat[i].nm_Flags = 0;
 326     menuDat[i].nm_MutualExclude = 0;
 327
 328     if (doi[j].doi_Flags & DOIF_CHECKABLE)
 329     {
 330         menuDat[i].nm_Flags |= CHECKIT;
 331         if (doi[j].doi_Flags & DOIF_CHECKED)
 332             menuDat[i].nm_Flags |= CHECKED;
 333     }
 334
 335     menuDat[i].nm_UserData = doi[j].doi_Code;
 336     i++;
 337
 338     if (doi[j].doi_SubItems)
 339     {
 340         ULONG           k = 0;
 341
 342         while (doi[j].doi_SubItems[k].doi_Code != 0
 343                && doi[j].doi_SubItems[k].doi_Name != NULL)
 344         {
 345             menuDat[i].nm_Type = NM_SUB;
 346             menuDat[i].nm_Label = doi[j].doi_SubItems[k].doi_Name;
 347             menuDat[i].nm_CommKey = 0;
 348             menuDat[i].nm_Flags = 0;
 349             menuDat[i].nm_MutualExclude = 0;
 350
 351             if (doi[j].doi_SubItems[k].doi_Flags & DOIF_CHECKABLE)
 352             {
 353                 menuDat[i].nm_Flags |= CHECKIT;
 354                 if (doi[j].doi_SubItems[k].doi_Flags & DOIF_CHECKED)
 355                     menuDat[i].nm_Flags |= CHECKED;
 356             }
 357
 358             menuDat[i].nm_UserData = doi[j].doi_SubItems[k].doi_Code;
 359             i++;
 360             k++;
 361         }
 362     }
 363     j++;
 364
 365     *reali = i;
 366     *realj = j;
 367 }