workbench/libs/desktop/newhandler.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 #define DEBUG 1
   9 #include <aros/debug.h>
  10
  11 #include <exec/types.h>
  12 #include <exec/memory.h>
  13 #include <intuition/classes.h>
  14 #include <libraries/mui.h>
  15
  16 #include <proto/exec.h>
  17 #include <proto/dos.h>
  18 #include <proto/intuition.h>
  19 #include <proto/icon.h>
  20
  21 #include "desktop_intern.h"
  22 #include "support.h"
  23 #include "worker.h"
  24
  25 #include "desktop_intern_protos.h"
  26 #include "worker_protos.h"
  27 #include "iconcontainerobserver.h"
  28
  29 #include <string.h>
  30
  31 // Handler states
  32 #define HS_STARTING 1
  33 #define HS_RUNNING  2
  34 #define HS_STOPPING 3
  35
  36 void startedMessage(void)
  37 {
  38     struct Message *m;
  39
  40     m = (struct Message *) AllocVec(sizeof(struct Message), MEMF_ANY);
  41     m->mn_Node.ln_Type = NT_MESSAGE;
  42     m->mn_ReplyPort = DesktopBase->db_HandlerPort;
  43     m->mn_Length = sizeof(struct Message);
  44
  45     PutMsg((struct MsgPort *) ((struct Process *) FindTask(NULL))->pr_Task.
  46            tc_UserData, m);
  47 }
  48
  49 ULONG desktopHandler(void)
  50 {
  51     struct DesktopInternMsg *msg,
  52                    *finalMsg;
  53     ULONG           handlerState = HS_STARTING;
  54     BOOL            replyNow = TRUE,
  55         running = TRUE;
  56     ULONG           userCount = 0,
  57         appCount = 0;
  58     ULONG           idCount = 0;
  59     struct MinList  workingMessages;
  60
  61     NEWLIST((struct List *) &workingMessages);
  62
  63 // The library's OPEN vector gets a mutex on the library
  64 // base.  Trouble will come our way if someone started this
  65 // handler elsewhere
  66     DesktopBase->db_HandlerPort = CreateMsgPort();
  67
  68     kprintf("--- starting desktop handler\n");
  69
  70 // let the creater know that it's now safe to send the handler
  71 // messages
  72     startedMessage();
  73
  74     kprintf("--- desktop handler accepting messages\n");
  75
  76     while (running)
  77     {
  78         WaitPort(DesktopBase->db_HandlerPort);
  79         while ((msg =
  80                 ((struct DesktopInternMsg *)
  81                  GetMsg(DesktopBase->db_HandlerPort))))
  82         {
  83             if (msg->di_Message.mn_Node.ln_Type == NT_MESSAGE)
  84             {
  85                 if (handlerState == HS_STARTING)
  86                 {
  87                     switch (msg->di_Command)
  88                     {
  89                         case DIMC_ADDUSER:
  90                             userCount++;
  91                             replyNow = TRUE;
  92                             handlerState = HS_RUNNING;
  93                             break;
  94                         default:
  95                             break;
  96                     }
  97                 }
  98                 else if (handlerState == HS_STOPPING)
  99                 {
 100                     switch (msg->di_Command)
 101                     {
 102                         case DIMC_ADDUSER:
 103                             userCount++;
 104                             replyNow = TRUE;
 105                             handlerState = HS_RUNNING;
 106                             break;
 107                         default:
 108                             break;
 109                     }
 110                 }
 111                 else if (handlerState == HS_RUNNING)
 112                 {
 113                     switch (msg->di_Command)
 114                     {
 115                         case DIMC_ADDUSER:
 116                             {
 117                                 userCount++;
 118                                 replyNow = TRUE;
 119                                 break;
 120                             }
 121                         case DIMC_SUBUSER:
 122                             {
 123                                 kprintf("--- DIMC_SUBUSER\n");
 124                                 userCount--;
 125                                 if (userCount == 0 && appCount == 0)
 126                                 {
 127                                     kprintf("--- time to exit...\n");
 128                                     handlerState = HS_STOPPING;
 129                                     replyNow = TRUE;
 130                                     kprintf("--- attempting semaphore\n");
 131                                     if (AttemptSemaphore
 132                                         (&DesktopBase->db_BaseMutex))
 133                                     {
 134                                         if (AttemptSemaphore
 135                                             (&DesktopBase->db_HandlerSafety))
 136                                         {
 137                                             running = FALSE;
 138                                             replyNow = FALSE;
 139                                             finalMsg = msg;
 140                                         }
 141                                         else
 142                                             ReleaseSemaphore(&DesktopBase->
 143                                                              db_BaseMutex);
 144                                     }
 145                                 }
 146                                 break;
 147                             }
 148                         case DIMC_SCANDIRECTORY:
 149                             {
 150                                 struct HandlerScanRequest *scanMsg =
 151                                     (struct HandlerScanRequest *) msg;
 152                                 struct WorkingMessageNode *wmn;
 153
 154                                 wmn =
 155                                     AllocVec(sizeof
 156                                              (struct WorkingMessageNode),
 157                                              MEMF_ANY);
 158                                 wmn->wm_Working =
 159                                     (struct DesktopInternMsg *) scanMsg;
 160                                 wmn->wm_ID = ++idCount;
 161                                 AddTail((struct List *) &workingMessages,
 162                                         (struct Node *) wmn);
 163
 164                                 wmn->wm_Port =
 165                                     startScannerWorker(idCount,
 166                                                        scanMsg->hsr_DirLock,
 167                                                        DesktopBase->
 168                                                        db_HandlerPort);
 169
 170                                 replyNow = TRUE;
 171
 172                                 break;
 173                             }
 174                         case DIMC_TOPLEVEL:
 175                             {
 176                                 struct TempNode
 177                                 {
 178                                     struct Node     t_Node;
 179                                     UBYTE          *t_Name;
 180                                 };
 181                                 struct HandlerTopLevelRequest *htl =
 182                                     (struct HandlerTopLevelRequest *) msg;
 183                                 struct DosList *dl;
 184                                 struct TempNode *tn;
 185                                 struct List     tnList;
 186                                 UWORD           i = 0,
 187                                     j = 0;
 188                                 struct SingleResult *sr;
 189                                 UBYTE          *fullPath;
 190
 191                                 NEWLIST(&tnList);
 192
 193                                 dl = LockDosList(htl->htl_Types | LDF_READ);
 194                                 while
 195                                 (
 196                                     (dl = NextDosEntry(dl, htl->htl_Types))
 197                                 )
 198                                 {
 199                                     ULONG length = strlen(dl->dol_DevName) + 1;
 200
 201                                     tn = (struct TempNode *) AllocVec
 202                                     (
 203                                         sizeof(struct TempNode), MEMF_ANY
 204                                     );
 205                                     tn->t_Name = AllocVec
 206                                     (
 207                                         length + 1, MEMF_ANY
 208                                     );
 209                                     strlcpy(tn->t_Name, dl->dol_DevName, length);
 210                                     AddTail(&tnList, (struct Node *) tn);
 211                                     i++;
 212                                 }
 213
 214                                 UnLockDosList(htl->htl_Types | LDF_READ);
 215
 216                                 sr = (struct SingleResult *)
 217                                     AllocVec(sizeof(struct SingleResult) * i,
 218                                              MEMF_ANY);
 219                                 tn = tnList.lh_Head;
 220                                 while (tn->t_Node.ln_Succ)
 221                                 {
 222                                     ULONG length = strlen(tn->t_Name) + 2;
 223
 224                                     sr[j].sr_Name = tn->t_Name;
 225
 226                                     fullPath = AllocVec(length + 2, MEMF_ANY);
 227
 228                                     strlcpy(fullPath, tn->t_Name, length);
 229                                     strlcat(fullPath, ":", length);
 230
 231                                     sr[j].sr_DiskObject = GetDiskObjectNew
 232                                     (
 233                                         fullPath
 234                                     );
 235                                     tn = (struct TempNode *) tn->t_Node.ln_Succ;
 236                                     j++;
 237                                 }
 238
 239                                 DoMethod
 240                                 (
 241                                     htl->htl_Application,
 242                                     MUIM_Application_PushMethod,
 243                                     htl->htl_CallBack, 3,
 244                                     ICOM_AddIcons, i, sr
 245                                 );
 246
 247                                 break;
 248                             }
 249                         default:
 250                             break;
 251                     }
 252                 }
 253
 254                 if (replyNow)
 255                     ReplyMsg((struct Message *) msg);
 256             }
 257             else if (msg->di_Message.mn_Node.ln_Type == NT_REPLYMSG)
 258             {
 259                 struct WorkerMessage *wm = (struct WorkerMessage *) msg;
 260
 261                 switch (wm->w_Action)
 262                 {
 263                     case WA_SCANNER:
 264                         {
 265                             struct WorkerMessage *newMsg;
 266                             struct WorkingMessageNode *wmn;
 267                             struct WorkerScanRequest *wsr =
 268                                 (struct WorkerScanRequest *) wm;
 269
 270                             wmn =
 271                                 findWorkedMessage(&workingMessages,
 272                                                   wsr->wsr_WMessage.w_ID);
 273
 274                             DoMethod(((struct HandlerScanRequest *) wmn->
 275                                       wm_Working)->hsr_Application,
 276                                      MUIM_Application_PushMethod,
 277                                      ((struct HandlerScanRequest *) wmn->
 278                                       wm_Working)->hsr_CallBack, 3,
 279                                      ICOM_AddIcons, wsr->wsr_Results,
 280                                      wsr->wsr_ResultsArray);
 281                             DoMethod(((struct HandlerScanRequest *) wmn->
 282                                       wm_Working)->hsr_Application,
 283                                      MUIM_Application_PushMethod,
 284                                      ((struct HandlerScanRequest *) wmn->
 285                                       wm_Working)->hsr_CallBack, 2,
 286                                      OM_FreeList_Add, wsr->wsr_ExAllBuffer);
 287
 288                             if (wsr->wsr_More)
 289                             {
 290                                 newMsg =
 291                                     createWorkerScanMessage(WM_RESUME,
 292                                                             WA_SCANNER,
 293                                                             wmn->wm_ID,
 294                                                             DesktopBase->
 295                                                             db_HandlerPort,
 296                                                             wsr->wsr_DirLock);
 297                                 PutMsg(wmn->wm_Port,
 298                                        (struct Message *) newMsg);
 299                             }
 300                             else
 301                             {
 302                                 Remove((struct Node *) wmn);
 303                                 ReplyMsg((struct Message *) wmn->wm_Working);
 304                             }
 305
 306                             FreeVec(wsr);
 307
 308                             break;
 309                         }
 310                 }
 311             // FreeVec(msg);
 312             }
 313         }
 314     }
 315
 316     kprintf("deleting port\n");
 317     DeleteMsgPort(DesktopBase->db_HandlerPort);
 318     DesktopBase->db_HandlerPort = NULL;
 319
 320     kprintf("releasing semaphores\n");
 321     ReleaseSemaphore(&DesktopBase->db_HandlerSafety);
 322     ReleaseSemaphore(&DesktopBase->db_BaseMutex);
 323
 324     kprintf("replying to msg\n");
 325     ReplyMsg((struct Message *) finalMsg);
 326
 327     kprintf("--- shutting down desktop handler\n");
 328
 329     return 0;
 330 }