scalos/main/MainWait.c

   1 // MainWait.c
   2 // $Date$
   3 // $Revision$
   4
   5
   6 #include <exec/types.h>
   7 #include <graphics/rastport.h>
   8 #include <utility/hooks.h>
   9 #include <intuition/gadgetclass.h>
  10 #include <workbench/workbench.h>
  11 #include <workbench/startup.h>
  12 #include <workbench/icon.h>
  13 #include <devices/timer.h>
  14 #include <rexx/errors.h>
  15 #include <libraries/gadtools.h>
  16 #include <libraries/iffparse.h>
  17 #include <datatypes/pictureclass.h>
  18 #include <dos/dostags.h>
  19
  20 #define __USE_SYSBASE
  21
  22 #include <proto/dos.h>
  23 #include <proto/exec.h>
  24 #include <proto/layers.h>
  25 #include <proto/intuition.h>
  26 #include <proto/graphics.h>
  27 #include <proto/utility.h>
  28 #include <proto/icon.h>
  29 #include <proto/iconobject.h>
  30 #include <proto/rexxsyslib.h>
  31 #include <proto/timer.h>
  32 #include "debug.h"
  33 #include <proto/scalos.h>
  34
  35 #include <clib/alib_protos.h>
  36
  37 #include <defs.h>
  38 #include <datatypes/iconobject.h>
  39 #include <scalos/palette.h>
  40 #include <scalos/pattern.h>
  41 #include <scalos/scalos.h>
  42
  43 #include <stdlib.h>
  44 #include <stdio.h>
  45 #include <string.h>
  46
  47 #include "scalos_structures.h"
  48 #include "functions.h"
  49 #include "Variables.h"
  50
  51 //----------------------------------------------------------------------------
  52
  53 // local data structures
  54
  55 #define TIMER_PREFS_CHANGE      2
  56 #define TIMER_MAINTASK_COUNT    2
  57
  58 //----------------------------------------------------------------------------
  59
  60 // local functions
  61
  62 static void ProcessWBMessages(struct MainTask *mainTask);
  63 static void ProcessTimerMessage(struct MainTask *mainTask);
  64 static void ProcessScalosMessage(struct MainTask *mainTask, struct ScalosMessage *sMsg);
  65 static void ProcessWblMessage(struct MainTask *mainTask, struct WblMessage *wMsg);
  66 static void ProcessRexxMessage(struct MainTask *mainTask, struct RexxMsg *RxMsg);
  67 static void ProcessPrefsChanges(struct MainTask *mainTask);
  68 static void UpdatePrefs(void);
  69 static void QuitScalos(struct ScaWindowTask *iwtMain, struct RexxMsg *msg);
  70
  71 //----------------------------------------------------------------------------
  72
  73 // local data items
  74
  75 // Notice: ARexx functions are called with mainTask->mwt.iwt_WindowTask as wtMain
  76 static struct ARexxCmdEntry ARexxCommandTable[] =
  77         {
  78         { "about",      ACEFLAGF_RunFromMainTask,       (AREXXFUNC) AboutProg   },
  79         { "quit",       ACEFLAGF_RunFromMainTask,       (AREXXFUNC) QuitScalos  },
  80         { NULL,         0,                              NULL                    },
  81         };
  82
  83 //----------------------------------------------------------------------------
  84
  85 // public data items
  86
  87 //----------------------------------------------------------------------------
  88
  89
  90 void MainWait(struct MainTask *mainTask)
  91 {
  92         ULONG WBPortMask = (1L << wbPort->mp_SigBit);
  93         ULONG MainPortMask = (1L << iInfos.xii_iinfos.ii_MainMsgPort->mp_SigBit);
  94
  95         d1(KPrintF("%s/%s/%ld: START  iwt=%08lx\n", __FILE__, __FUNC__, __LINE__, &mainTask->mwt));
  96
  97         do      {
  98                 ULONG SigsRcvd = Wait(WBPortMask | MainPortMask);
  99
 100                 d1(KPrintF("%s/%s/%ld: SigsRcvd=%08lx\n", __FILE__, __FUNC__, __LINE__, SigsRcvd));
 101
 102                 if (SigsRcvd & WBPortMask)
 103                         {
 104                         //.wbmessage
 105                         ProcessWBMessages(mainTask);
 106                         }
 107                 if (SigsRcvd & MainPortMask)
 108                         {
 109                         //.mainwait2
 110                         struct Message *msg;
 111
 112                         while (!mainTask->mwt.iwt_CloseWindow && (msg = GetMsg(iInfos.xii_iinfos.ii_MainMsgPort)))
 113                                 {
 114                                 struct NotifyMessage *nMsg = (struct NotifyMessage *) msg;
 115                                 struct RexxMsg *RxMsg = (struct RexxMsg *) msg;
 116                                 struct ScalosMessage *sMsg = (struct ScalosMessage *) msg;
 117                                 struct WblMessage *wMsg = (struct WblMessage *) msg;
 118                                 struct AppMessage *appMsg = (struct AppMessage *) msg;
 119
 120                                 d1(KPrintF("%s/%s/%ld: msg=%08lx\n", __FILE__, __FUNC__, __LINE__, msg));
 121
 122                                 if (msg == &mainTask->iorequest->tr_node.io_Message)
 123                                         {
 124                                         //.mytimermsg
 125                                         d1(KPrintF("%s/%s/%ld: Timer Message msg=%08lx\n", __FILE__, __FUNC__, __LINE__, msg));
 126                                         ProcessTimerMessage(mainTask);
 127                                         continue;
 128                                         }
 129
 130                                 if (NOTIFY_CLASS == nMsg->nm_Class && NOTIFY_CODE == nMsg->nm_Code)
 131                                         {
 132                                         const struct NotifyNode *non;
 133                                         BOOL Found = FALSE;
 134
 135                                         d1(KPrintF("%s/%s/%ld: Notify Msg  UserData=%08lx\n", __FILE__, __FUNC__, __LINE__, nMsg->nm_NReq->nr_UserData));
 136
 137                                         ScalosObtainSemaphoreShared(&mainTask->mwt_MainNotifyListSema);
 138                                         for (non = mainTask->mainnotifylist; non; non = (const struct NotifyNode *) non->non_Node.mln_Succ)
 139                                                 {
 140                                                 if (non->non_NotifyRequest.nr_UserData == nMsg->nm_NReq->nr_UserData)
 141                                                         {
 142                                                         struct NotifyTab *nft = (struct NotifyTab *) nMsg->nm_NReq->nr_UserData;
 143
 144                                                         ScalosReleaseSemaphore(&mainTask->mwt_MainNotifyListSema);
 145                                                         Found = TRUE;
 146
 147                                                         d1(KPrintF("%s/%s/%ld: Notify Msg nft=%08lx  nft_FileName=<%s>  nft_Entry=%08lx\n", \
 148                                                                 __FILE__, __FUNC__, __LINE__, nft, nft->nft_FileName, nft->nft_Entry));
 149
 150                                                         (*nft->nft_Entry)(&mainTask->mwt, nMsg);
 151                                                         break;
 152                                                         }
 153                                                 }
 154                                         if (!Found)
 155                                                 ScalosReleaseSemaphore(&mainTask->mwt_MainNotifyListSema);
 156
 157                                         d1(KPrintF("%s/%s/%ld: Notify Message\n", __FILE__, __FUNC__, __LINE__));
 158                                         ReplyMsg(&nMsg->nm_ExecMessage);
 159
 160                                         continue;
 161                                         }
 162
 163                                 if (ID_IMSG == sMsg->sm_Signature)
 164                                         {
 165                                         d1(KPrintF("%s/%s/%ld: ScalosMessage\n", __FILE__, __FUNC__, __LINE__));
 166                                         ProcessScalosMessage(mainTask, sMsg);
 167                                         continue;
 168                                         }
 169
 170                                 if (ID_WBLM == wMsg->wbl_Magic)
 171                                         {
 172                                         d1(KPrintF("%s/%s/%ld: WBL Message\n", __FILE__, __FUNC__, __LINE__));
 173                                         ProcessWblMessage(mainTask, wMsg);
 174                                         continue;
 175                                         }
 176
 177                                 if (msg->mn_Length >= sizeof(struct AppMessage)
 178                                         && ID_APPM == appMsg->am_Reserved[0])
 179                                         {
 180                                         //freeappmsg
 181                                         d1(KPrintF("%s/%s/%ld: AppMessage\n", __FILE__, __FUNC__, __LINE__));
 182
 183                                         SCA_FreeWBArgs(appMsg->am_ArgList,
 184                                                 appMsg->am_NumArgs,
 185                                                 SCAF_FreeLocks | SCAF_FreeNames);
 186
 187                                         FreeVec(appMsg);
 188                                         continue;
 189                                         }
 190
 191                                 if (IsRexxMsg((struct RexxMsg *)RxMsg))
 192                                         {
 193                                         //rexxmsggot
 194                                         d1(KPrintF("%s/%s/%ld: Rexx Message\n", __FILE__, __FUNC__, __LINE__));
 195                                         ProcessRexxMessage(mainTask, RxMsg);
 196                                         continue;
 197                                         }
 198
 199                                 d1(KPrintF("%s/%s/%ld: unknown Msg Type\n", __FILE__, __FUNC__, __LINE__));
 200
 201                                 // unknown message type
 202                                 ReplyMsg(msg);
 203                                 }
 204                         }
 205
 206                 d1(KPrintF("%s/%s/%ld: SigsRcvd=%08lx\n", __FILE__, __FUNC__, __LINE__, SigsRcvd));
 207
 208                 } while (!mainTask->mwt.iwt_CloseWindow);
 209
 210         d1(KPrintF("%s/%s/%ld: END\n", __FILE__, __FUNC__, __LINE__));
 211 }
 212
 213
 214 static void ProcessWBMessages(struct MainTask *mainTask)
 215 {
 216         struct WBStartup *sMsg;
 217
 218         d1(KPrintF("%s/%s/%ld: \n", __FILE__, __FUNC__, __LINE__));
 219
 220         while ((sMsg = (struct WBStartup *) GetMsg(wbPort)))
 221                 {
 222                 ULONG n;
 223                 struct DoWait *dw, *dwNext;
 224
 225                 d1(KPrintF("%s/%s/%ld: sMsg=%08lx\n", __FILE__, __FUNC__, __LINE__, sMsg));
 226
 227                 ScalosObtainSemaphore(&DoWaitSemaphore);
 228
 229                 for (dw = DoWaitList; dw; dw = dwNext)
 230                         {
 231                         dwNext = (struct DoWait *) dw->dwai_Node.mln_Succ;
 232
 233                         d1(KPrintF("%s/%s/%ld: dw=%08lx  wbmsg=%08lx\n", __FILE__, __FUNC__, __LINE__, dw, dw->dwai_wbmsg));
 234
 235                         if (sMsg == dw->dwai_wbmsg)
 236                                 {
 237                                 struct DoWaitFinished *dwf = AllocVec(sizeof(struct DoWaitFinished), MEMF_PUBLIC | MEMF_CLEAR);
 238
 239                                 d1(KPrintF("%s/%s/%ld: dw=%08lx  dwf=%08lx\n", __FILE__, __FUNC__, __LINE__, dw, dwf));
 240
 241                                 if (dwf)
 242                                         {
 243                                         dwf->dwf_DoWait = dw;
 244                                         PutMsg(dw->dwai_msgport, &dwf->dwf_Message);
 245                                         }
 246                                 break;
 247                                 }
 248                         }
 249
 250                 ScalosReleaseSemaphore(&DoWaitSemaphore);
 251
 252                 d1(KPrintF("%s/%s/%ld: numArgs=%ld\n", __FILE__, __FUNC__, __LINE__, sMsg->sm_NumArgs));
 253
 254                 for (n=0; n<sMsg->sm_NumArgs; n++)
 255                         {
 256                         d1(KPrintF("%s/%s/%ld: n=%ld Name=%08lx <%s>  Lock=%08lx\n", \
 257                                 __FILE__, __FUNC__, __LINE__, n, sMsg->sm_ArgList[n].wa_Name, \
 258                                 sMsg->sm_ArgList[n].wa_Name, \
 259                                 sMsg->sm_ArgList[n].wa_Lock));
 260                         debugLock_d1(sMsg->sm_ArgList[n].wa_Lock);
 261
 262                         if (NULL == sMsg->sm_ArgList[n].wa_Name && BNULL == sMsg->sm_ArgList[n].wa_Lock)
 263                                 break;
 264
 265                         UnLock(sMsg->sm_ArgList[n].wa_Lock);
 266                         FreeCopyString(sMsg->sm_ArgList[n].wa_Name);
 267                         }
 268
 269                 d1(KPrintF("%s/%s/%ld: \n", __FILE__, __FUNC__, __LINE__));
 270
 271                 RemWBProgram(sMsg);
 272                 }
 273 }
 274
 275
 276 static void ProcessTimerMessage(struct MainTask *mainTask)
 277 {
 278         d1(KPrintF("%s/%s/%ld: Start\n", __FILE__, __FUNC__, __LINE__));
 279
 280         // called every 0.25s
 281
 282         if (mainTask->mt_TimerCounter++ >= TIMER_MAINTASK_COUNT)
 283                 {
 284                 T_TIMEVAL Now;
 285
 286                 // called every second
 287
 288                 mainTask->mt_TimerCounter = 0;
 289
 290                 GetSysTime(&Now);
 291
 292                 ClassTimerToolTipMsg(&mainTask->mwt);
 293
 294                 d1(KPrintF("%s/%s/%ld: \n", __FILE__, __FUNC__, __LINE__));
 295
 296                 if (SCA_LockWindowList(SCA_LockWindowList_AttemptShared))
 297                         {
 298                         struct ScaWindowStruct *ws;
 299
 300                         d1(KPrintF("%s/%s/%ld: \n", __FILE__, __FUNC__, __LINE__));
 301
 302                         for (ws=winlist.wl_WindowStruct; ws; ws = (struct ScaWindowStruct *) ws->ws_Node.mln_Succ)
 303                                 {
 304                                 d1(KPrintF("%s/%s/%ld: ws=%08lx  ws_Flags=%08lx  iwt_MoveGadId=%ld\n", __FILE__, __FUNC__, __LINE__, ws, ws->ws_Flags, \
 305                                         ((struct internalScaWindowTask *) ws->ws_WindowTask)->iwt_MoveGadId));
 306
 307                                 if ((ws->ws_Flags & (WSV_FlagF_CheckUpdatePending | WSV_FlagF_Typing | WSV_FlagF_NeedsTimerMsg))
 308                                         && !(ws->ws_Flags & (WSV_FlagF_TaskSleeps | WSV_FlagF_TimerMsgSent)))
 309                                         {
 310                                         struct SM_Timer *msg;
 311
 312                                         ws->ws_Flags |= WSV_FlagF_TimerMsgSent;
 313
 314                                         msg = (struct SM_Timer *) SCA_AllocMessage(MTYP_Timer, 0);
 315                                         d1(KPrintF("%s/%s/%ld: msg=%08lx\n", __FILE__, __FUNC__, __LINE__, msg));
 316                                         if (msg)
 317                                                 {
 318                                                 msg->ScalosMessage.sm_Message.mn_ReplyPort = iInfos.xii_iinfos.ii_MainMsgPort;
 319                                                 msg->smtm_WindowStruct = ws;
 320                                                 msg->smtm_Time = Now;
 321
 322                                                 PutMsg(ws->ws_MessagePort, &msg->ScalosMessage.sm_Message);
 323                                                 }
 324                                         }
 325                                 }
 326
 327                         SCA_UnLockWindowList();
 328                         }
 329                 }
 330
 331         d1(KPrintF("%s/%s/%ld: \n", __FILE__, __FUNC__, __LINE__));
 332
 333         ProcessPrefsChanges(mainTask);
 334
 335         d1(KPrintF("%s/%s/%ld: \n", __FILE__, __FUNC__, __LINE__));
 336
 337         // Restart timer
 338         StartMainTaskTimer(mainTask);
 339
 340         d1(KPrintF("%s/%s/%ld: Finished\n", __FILE__, __FUNC__, __LINE__));
 341 }
 342
 343
 344 static void ProcessScalosMessage(struct MainTask *mainTask, struct ScalosMessage *sMsg)
 345 {
 346         APTR ArgPtr = (APTR) (((UBYTE *) &sMsg->sm_MessageType) + sizeof(sMsg->sm_MessageType));
 347         short mIndex = sMsg->sm_MessageType - 1;
 348
 349         d1(KPrintF("%s/%s/%ld: Msg=%08lx  MsgType=%ld, ln_Type=%ld\n", \
 350                 __FILE__, __FUNC__, __LINE__, sMsg, sMsg->sm_MessageType, sMsg->sm_Message.mn_Node.ln_Type));
 351
 352         if (NT_REPLYMSG == sMsg->sm_Message.mn_Node.ln_Type)
 353                 {
 354                 if (mIndex > 0 && mIndex < MTYP_MAX)
 355                         {
 356                         d1(KPrintF("%s/%s/%ld: ReplyFunc=%08lx\n", __FILE__, __FUNC__, __LINE__, iMsgTable[mIndex].ReplyFunc));
 357
 358                         if (iMsgTable[mIndex].ReplyFunc)
 359                                 (*iMsgTable[mIndex].ReplyFunc)(&mainTask->mwt, &sMsg->sm_Message, ArgPtr);
 360                         }
 361
 362                 SCA_FreeMessage(sMsg);
 363                 }
 364         else
 365                 {
 366                 d1(KPrintF("%s/%s/%ld: MsgFunc=%08lx\n", __FILE__, __FUNC__, __LINE__, iMsgTable[mIndex].MsgFunc));
 367
 368                 if (mIndex > 0 && mIndex < MTYP_MAX)
 369                         {
 370                         if (iMsgTable[mIndex].MsgFunc)
 371                                 (*iMsgTable[mIndex].MsgFunc)(&mainTask->mwt, &sMsg->sm_Message, ArgPtr);
 372                         }
 373
 374                 if (sMsg->sm_Message.mn_ReplyPort)
 375                         ReplyMsg(&sMsg->sm_Message);
 376                 else
 377                         SCA_FreeMessage(sMsg);
 378                 }
 379
 380 }
 381
 382
 383 static void ProcessWblMessage(struct MainTask *mainTask, struct WblMessage *wMsg)
 384 {
 385         struct DoWait *dw, *dwNext;
 386
 387         d1(KPrintF("%s/%s/%ld: wMsg=%08lx\n", __FILE__, __FUNC__, __LINE__, wMsg));
 388
 389         ScalosObtainSemaphore(&DoWaitSemaphore);
 390
 391         for (dw = DoWaitList; dw; dw = dwNext)
 392                 {
 393                 dwNext = (struct DoWait *) dw->dwai_Node.mln_Succ;
 394
 395                 if (wMsg == dw->dwai_wblmsg)
 396                         {
 397                         d1(KPrintF("%s/%s/%ld: dw=%08lx\n", __FILE__, __FUNC__, __LINE__, dw));
 398
 399                         dw->dwai_wbmsg = wMsg->wbl_IO.wbl_Return.wblr_WBStartup;
 400                         break;
 401                         }
 402                 }
 403
 404         ScalosReleaseSemaphore(&DoWaitSemaphore);
 405         FreeVec(wMsg);
 406
 407 }
 408
 409
 410 static void ProcessRexxMessage(struct MainTask *mainTask, struct RexxMsg *RxMsg)
 411 {
 412         struct ARexxCmdEntry *ace;
 413         BOOL Found = FALSE;
 414
 415         d1(KPrintF("%s/%s/%ld: RxMsg=%08lx  Arg[0]=<%s>\n", __FILE__, __FUNC__, __LINE__, RxMsg, RxMsg->rm_Args[0]));
 416
 417         for (ace=ARexxCommandTable; !Found && ace->ace_CmdName; ace++)
 418                 {
 419                 if (0 == Stricmp(ace->ace_CmdName, (STRPTR) RxMsg->rm_Args[0]))
 420                         {
 421                         Found = TRUE;
 422
 423                         RxMsg->rm_Result1 = RC_OK;
 424                         RxMsg->rm_Result2 = 0;
 425
 426                         d1(KPrintF("%s/%s/%ld: EntryPoint=%08lx  Flags=%08lx\n", \
 427                                 __FILE__, __FUNC__, __LINE__, ace->ace_EntryPoint, ace->ace_Flags));
 428
 429                         if (ace->ace_Flags & ACEFLAGF_RunFromMainTask)
 430                                 {
 431                                 struct SM_ARexxRoutine *smrx;
 432
 433                                 smrx = (struct SM_ARexxRoutine *) SCA_AllocMessage(MTYP_ARexxRoutine, 0);
 434                                 if (smrx)
 435                                         {
 436                                         smrx->smrx_RexxMsg = RxMsg;
 437                                         smrx->smrx_EntryPoint = ace->ace_EntryPoint;
 438
 439                                         PutMsg(iInfos.xii_iinfos.ii_MainMsgPort, &smrx->ScalosMessage.sm_Message);
 440                                         }
 441                                 }
 442                         else
 443                                 {
 444                                 (*ace->ace_EntryPoint)(&mainTask->mwt.iwt_WindowTask, RxMsg);
 445                                 ReplyMsg(&RxMsg->rm_Node);
 446                                 }
 447                         }
 448                 }
 449
 450         if (!Found)
 451                 {
 452                 ReplyMsg(&RxMsg->rm_Node);
 453
 454                 RxMsg->rm_Result1 = RC_FATAL;
 455                 }
 456 }
 457
 458
 459 static void ProcessPrefsChanges(struct MainTask *mainTask)
 460 {
 461         if (mainTask->mt_PrefsChangedTimer++ >= TIMER_PREFS_CHANGE)
 462                 {
 463                 if (mainTask->mt_PrefsChangedFlags)
 464                         {
 465                         BOOL Changed = FALSE;
 466                         BOOL PaletteChanged = FALSE;
 467
 468                         d1(KPrintF("%s/%s/%ld: mt_PrefsChangedFlags=%08lx\n", __FILE__, __FUNC__, __LINE__, MainWindowTask->mt_PrefsChangedFlags));
 469
 470                         if (mainTask->mt_PrefsChangedFlags & SMNPFLAGF_FONTPREFS)
 471                                 Changed |= ChangedFontPrefs(mainTask);
 472                         if (mainTask->mt_PrefsChangedFlags & SMNPFLAGF_FILETYPESPREFS)
 473                                 Changed |= ChangedFileTypesPrefs(mainTask);
 474                         if (mainTask->mt_PrefsChangedFlags & SMNPFLAGF_DEFICONSPREFS)
 475                                 Changed |= ChangedDefIconsPrefs();
 476                         if (mainTask->mt_PrefsChangedFlags & SMNPFLAGF_LOCALEPREFS)
 477                                 Changed |= ChangedLocalePrefs(mainTask);
 478                         if (mainTask->mt_PrefsChangedFlags & SMNPFLAGF_PATTERNPREFS)
 479                                 Changed |= ChangedPatternPrefs(mainTask);
 480                         if (mainTask->mt_PrefsChangedFlags & SMNPFLAGF_SCALOSPREFS)
 481                                 Changed |= ChangedMainPrefs(mainTask);
 482                         if (mainTask->mt_PrefsChangedFlags & (SMNPFLAGF_MENUPREFS))
 483                                 Changed |= ChangedMenuPrefs(mainTask);
 484                         if (mainTask->mt_PrefsChangedFlags & SMNPFLAGF_PALETTEPREFS)
 485                                 Changed |= PaletteChanged = ChangedPalettePrefs(mainTask);
 486
 487                         d1(KPrintF("%s/%s/%ld: Changed=%lu\n", __FILE__, __FUNC__, __LINE__, Changed));
 488
 489                         if (Changed && !PaletteChanged)
 490                                 UpdatePrefs();
 491
 492                         if (mainTask->mt_ChangedMenuPrefsName)
 493                                 {
 494                                 FreeCopyString(mainTask->mt_ChangedMenuPrefsName);
 495                                 mainTask->mt_ChangedMenuPrefsName = NULL;
 496                                 }
 497                         if (mainTask->mt_ChangedPalettePrefsName)
 498                                 {
 499                                 FreeCopyString(mainTask->mt_ChangedPalettePrefsName);
 500                                 mainTask->mt_ChangedPalettePrefsName = NULL;
 501                                 }
 502
 503                         mainTask->mt_PrefsChangedFlags = 0;
 504                         }
 505                 mainTask->mt_PrefsChangedTimer = 0;
 506                 }
 507 }
 508
 509
 510 static void UpdatePrefs(void)
 511 {
 512         struct ScaWindowStruct *ws;
 513
 514         d1(KPrintF("%s/%s/%ld: START\n", __FILE__, __FUNC__, __LINE__));
 515
 516         SCA_LockWindowList(SCA_LockWindowList_Shared);
 517
 518         for (ws=winlist.wl_WindowStruct; ws; ws = (struct ScaWindowStruct *) ws->ws_Node.mln_Succ)
 519                 {
 520                 d1(KPrintF("%s/%s/%ld:  Name=<%s>  Flags=%08lx\n", __FILE__, __FUNC__, __LINE__, ws->ws_Name, ws->ws_Flags));
 521
 522                 if (!(ws->ws_Flags & WSV_FlagF_TaskSleeps))
 523                         {
 524                         struct SM_PrefsChanged *smpc;
 525
 526                         smpc = (struct SM_PrefsChanged *) SCA_AllocMessage(MTYP_PrefsChanged, 0);
 527
 528                         if (smpc)
 529                                 {
 530                                 smpc->smpc_Flags = 0;
 531                                 PutMsg(ws->ws_MessagePort, &smpc->ScalosMessage.sm_Message);
 532                                 }
 533                         }
 534                 }
 535
 536         SCA_UnLockWindowList();
 537
 538         d1(KPrintF("%s/%s/%ld: END\n", __FILE__, __FUNC__, __LINE__));
 539
 540 }
 541
 542
 543
 544
 545 void RememberPrefsChanges(struct internalScaWindowTask *iwt, ULONG PrefsChangeFlags)
 546 {
 547         struct MainTask *mainTask = MainWindowTask;
 548
 549         if (iwt == &mainTask->mwt)
 550                 {
 551                 mainTask->mt_PrefsChangedFlags |= PrefsChangeFlags;
 552                 d1(KPrintF("%s/%s/%ld: PrefsChangeFlags=%08lx\n", __FILE__, __FUNC__, __LINE__, PrefsChangeFlags));
 553                 d1(KPrintF("%s/%s/%ld: mt_PrefsChangedFlags=%08lx\n", __FILE__, __FUNC__, __LINE__, mainTask->mt_PrefsChangedFlags));
 554                 mainTask->mt_PrefsChangedTimer = 0;
 555                 }
 556 }
 557
 558
 559 void StartMainTaskTimer(struct MainTask *mt)
 560 {
 561         mt->iorequest->tr_node.io_Command = TR_ADDREQUEST;
 562         mt->iorequest->tr_time.tv_secs = 0;
 563         mt->iorequest->tr_time.tv_micro = 250000;       // 0.25s period
 564
 565         SendIO(&mt->iorequest->tr_node);
 566 }
 567
 568
 569 struct NotifyNode *AddToMainNotifyList(struct NotifyTab *nft, ULONG Flags)
 570 {
 571         struct NotifyNode *non;
 572
 573         do      {
 574                 struct MainTask *mainTask = MainWindowTask;
 575
 576                 ScalosObtainSemaphore(&MainWindowTask->mwt_MainNotifyListSema);
 577                 non = (struct NotifyNode *) SCA_AllocNode((struct ScalosNodeList *) &mainTask->mainnotifylist, sizeof(struct NotifyNode));
 578                 ScalosReleaseSemaphore(&MainWindowTask->mwt_MainNotifyListSema);
 579                 d1(KPrintF("%s/%s/%ld:  non=%08lx\n", __FILE__, __FUNC__, __LINE__, non));
 580                 if (NULL == non)
 581                         break;
 582
 583                 non->non_NotifyRequest.nr_UserData = (IPTR) nft;
 584                 non->non_NotifyRequest.nr_Name = (STRPTR) nft->nft_FileName;
 585                 non->non_NotifyRequest.nr_stuff.nr_Msg.nr_Port = iInfos.xii_iinfos.ii_MainMsgPort;
 586                 non->non_NotifyRequest.nr_Flags = NRF_SEND_MESSAGE | Flags;
 587
 588                 if (!StartNotify(&non->non_NotifyRequest))
 589                         {
 590                         // free ffi_NotifyNode, but continue and add ffi!
 591                         d1(kprintf("%s/%s/%ld:  StartNotify() failed\n", __FILE__, __FUNC__, __LINE__));
 592
 593                         SCA_FreeNode((struct ScalosNodeList *) &mainTask->mainnotifylist, &non->non_Node);
 594                         non = NULL;
 595                         }
 596                 d1(kprintf("%s/%s/%ld:  StartNotify() OK\n", __FILE__, __FUNC__, __LINE__));
 597                 } while (0);
 598
 599         d1(KPrintF("%s/%s/%ld: AddToMainNotifyList return=%8lx\n",
 600                 __FILE__, __FUNC__, __LINE__, non));
 601
 602         return non;
 603 }
 604
 605
 606 void RemFromMainNotifyList(struct NotifyNode *nonOld)
 607 {
 608         struct MainTask *mainTask = MainWindowTask;
 609         struct NotifyNode *non;
 610
 611         d1(KPrintF("%s/%s/%ld: RemFromMainNotifyList %8lx\n",
 612                 __FILE__, __FUNC__, __LINE__, nonOld));
 613
 614         if (MainWindowTask)
 615                 {
 616                 ScalosObtainSemaphore(&MainWindowTask->mwt_MainNotifyListSema);
 617
 618                 d1(KPrintF("%s/%s/%ld:\n", __FILE__, __FUNC__, __LINE__));
 619
 620                 // make sure nonOld is still present in mainnotifylist
 621                 for (non = mainTask->mainnotifylist;
 622                         non;
 623                         non = (struct NotifyNode *) non->non_Node.mln_Succ)
 624                         {
 625                         d1(KPrintF("%s/%s/%ld: non(%08lx) nonOld(%08lx)\n", __FILE__, __FUNC__, __LINE__,
 626                                 non, nonOld));
 627                         if (non == nonOld)
 628                                 {
 629                                 ScalosEndNotify(&nonOld->non_NotifyRequest);
 630                                 SCA_FreeNode((struct ScalosNodeList *) &mainTask->mainnotifylist, &nonOld->non_Node);
 631                                 break;
 632                                 }
 633                         }
 634
 635                 d1(KPrintF("%s/%s/%ld:\n", __FILE__, __FUNC__, __LINE__));
 636
 637                 ScalosReleaseSemaphore(&MainWindowTask->mwt_MainNotifyListSema);
 638                 }
 639 }
 640
 641
 642 static void QuitScalos(struct ScaWindowTask *wtMain, struct RexxMsg *msg)
 643 {
 644         struct internalScaWindowTask *iwtMain = (struct internalScaWindowTask *) iInfos.xii_iinfos.ii_MainWindowStruct->ws_WindowTask;
 645
 646         (void) wtMain;
 647         (void) msg;
 648
 649         iwtMain->iwt_CloseWindow = TRUE;
 650 }
 651
 652