scalos/main/Functions.c

   1 // Functions.c
   2 // $Date$
   3 // $Revision$
   4
   5
   6 #include <exec/types.h>
   7 #include <graphics/gels.h>
   8 #include <graphics/rastport.h>
   9 #include <intuition/classes.h>
  10 #include <intuition/classusr.h>
  11 #include <utility/hooks.h>
  12 #include <intuition/gadgetclass.h>
  13 #include <workbench/workbench.h>
  14 #include <workbench/startup.h>
  15 #include <dos/dostags.h>
  16 #include <dos/datetime.h>
  17
  18 #define __USE_SYSBASE
  19
  20 #include <proto/dos.h>
  21 #include <proto/exec.h>
  22 #include <proto/layers.h>
  23 #include <proto/intuition.h>
  24 #include <proto/graphics.h>
  25 #include <proto/utility.h>
  26 #include <proto/iconobject.h>
  27 #include "debug.h"
  28 #include <proto/scalos.h>
  29
  30 #include <clib/alib_protos.h>
  31
  32 #include <defs.h>
  33 #include <datatypes/iconobject.h>
  34 #include <scalos/scalos.h>
  35
  36 #include <stdlib.h>
  37 #include <stdio.h>
  38 #include <string.h>
  39
  40 #include "scalos_structures.h"
  41 #include "functions.h"
  42 #include "Variables.h"
  43
  44 //----------------------------------------------------------------------------
  45
  46 // local data structures
  47
  48 //----------------------------------------------------------------------------
  49
  50 // local data items
  51
  52 // remapping of SCA_OpenIconWindow() tags to ws_Flags values
  53 static const struct TagItem FlagMapTable[] =
  54         {
  55         { SCA_Iconify, WSV_FlagF_Iconify },
  56         { SCA_NoStatusBar, WSV_FlagF_NoStatusBar },
  57         { SCA_NoActivateWindow, WSV_FlagF_NoActivateWindow },
  58         { SCA_BrowserMode, WSV_FlagF_BrowserMode },
  59         { SCA_CheckOverlappingIcons, WSV_FlagF_CheckOverlappingIcons },
  60         { SCA_DdPopupWindow, WSV_FlagF_DdPopupWindow },
  61         { TAG_END, 0 },
  62         };
  63
  64 // remapping of SCA_OpenIconWindow() tags to ws_MoreFlags values
  65 static const struct TagItem MoreFlagMapTable[] =
  66         {
  67         { SCA_NoControlBar, WSV_MoreFlagF_NoControlBar },
  68         { TAG_END, 0 },
  69         };
  70
  71 //----------------------------------------------------------------------------
  72
  73 // local functions
  74
  75 static Object *ReadDeviceIconObject(CONST_STRPTR Path);
  76 static Object *FindIconInScalosWindows(BPTR Lock, CONST_STRPTR IconName,
  77         struct ScaWindowStruct **wsLocked, BOOL *windowListLocked);
  78 static Object *FindIconInDeviceWindow(CONST_STRPTR IconName,
  79         struct ScaWindowStruct **wsLocked, BOOL *windowListLocked);
  80 static BOOL MatchDeviceIcon(CONST_STRPTR SearchPath, struct ScaIconNode *in);
  81 static BOOL MatchPath(CONST_STRPTR VolPath, CONST_STRPTR DevIconPath);
  82
  83 //----------------------------------------------------------------------------
  84
  85 // implementation of SCA_OpenIconWindow()
  86
  87 LIBFUNC_P2(BOOL, sca_OpenIconWindow,
  88         A0, struct TagItem *, TagList,
  89         A6, struct ScalosBase *, ScalosBase, 0)
  90 {
  91         Object *IconObj = NULL;
  92         Object *allocIconObj = NULL;
  93         struct MsgPort *allocMsgPort = NULL;
  94         struct ScaWindowStruct *wsNew = NULL;
  95         struct ScaWindowStruct *dummyList = NULL;
  96         struct SM_StartWindow *msgStart = NULL;
  97         BOOL Success = FALSE;
  98         struct ScaWindowStruct *wsIconListLocked = NULL;
  99         BOOL WindowListLocked = FALSE;
 100
 101         (void)ScalosBase;
 102
 103         d1(KPrintF("%s/%s/%ld: START\n", __FILE__, __FUNC__, __LINE__));
 104
 105         do      {
 106                 STATIC_PATCHFUNC(WindowTask)
 107                 struct ScaWindowStruct *ws;
 108                 struct ScaWindowStruct **ReturnWs;
 109                 struct IBox *WindowRect;
 110                 struct ScaIconNode *in;
 111                 struct MsgPort *ReplyPort;
 112                 STRPTR Path;
 113                 STRPTR TaskName;
 114                 ULONG WindowFlags;
 115                 CONST_STRPTR clp;
 116                 BOOL Found;
 117                 size_t length;
 118
 119                 ReturnWs = (struct ScaWindowStruct **) GetTagData(SCA_WindowStruct, (ULONG)NULL, TagList);
 120                 d1(KPrintF("%s/%s/%ld: ReturnWs=%08lx\n", __FILE__, __FUNC__, __LINE__, ReturnWs));
 121
 122                 in = (struct ScaIconNode *) GetTagData(SCA_IconNode, (ULONG)NULL, TagList);
 123                 if (in)
 124                         IconObj = in->in_Icon;
 125
 126                 IconObj = (Object *) GetTagData(SCA_IconObject, (ULONG) IconObj, TagList);
 127
 128                 d1(KPrintF("%s/%s/%ld: in=%08lx  IconObj=%08lx\n", __FILE__, __FUNC__, __LINE__, in, IconObj));
 129
 130                 WindowFlags = GetTagData(SCA_Flags, 0, TagList);
 131
 132                 ReplyPort = (struct MsgPort *) GetTagData(SCA_MessagePort, (ULONG)NULL, TagList);
 133                 d1(KPrintF("%s/%s/%ld: ReplyPort=%08lx\n", __FILE__, __FUNC__, __LINE__, ReplyPort));
 134                 if (NULL == ReplyPort)
 135                         ReplyPort = allocMsgPort = CreateMsgPort();
 136                 if (NULL == ReplyPort)
 137                         break;
 138
 139                 wsNew = (struct ScaWindowStruct *) SCA_AllocStdNode((struct ScalosNodeList *)(APTR) &dummyList, NTYP_WindowStruct);
 140                 if (NULL == wsNew)
 141                         break;
 142
 143                 wsNew->ws_Left = CurrentPrefs.pref_DefWindowBox.Left;
 144                 wsNew->ws_Top = CurrentPrefs.pref_DefWindowBox.Top;
 145                 wsNew->ws_Width = CurrentPrefs.pref_DefWindowBox.Width;
 146                 wsNew->ws_Height = CurrentPrefs.pref_DefWindowBox.Height;
 147
 148                 wsNew->ws_WindowOpacityActive = CurrentPrefs.pref_ActiveWindowTransparency;
 149                 wsNew->ws_WindowOpacityInactive = CurrentPrefs.pref_InactiveWindowTransparency;
 150
 151                 wsNew->ws_IconSizeConstraints = CurrentPrefs.pref_IconSizeConstraints;
 152                 wsNew->ws_IconScaleFactor = CurrentPrefs.pref_IconScaleFactor;
 153
 154                 Path = (STRPTR) GetTagData(SCA_Path, (ULONG)NULL, TagList);
 155                 d1(KPrintF("%s/%s/%ld: Path=%08lx  <%s>\n", __FILE__, __FUNC__, __LINE__, Path, Path ? Path : (STRPTR) ""));
 156                 if (Path)
 157                         {
 158                         BPTR parentLock;
 159
 160                         wsNew->ws_Lock = Lock(Path, ACCESS_READ);
 161                         debugLock_d1(wsNew->ws_Lock);
 162                         if ((BPTR)NULL == wsNew->ws_Lock)
 163                                 break;
 164
 165                         wsNew->ws_Name = GetWsNameFromLock(wsNew->ws_Lock);
 166                         d1(KPrintF("%s/%s/%ld: ws_Name=<%s>\n", __FILE__, __FUNC__, __LINE__, wsNew->ws_Name));
 167
 168                         IconObj = FunctionsFindIconObjectForPath(Path, &WindowListLocked,
 169                                 &wsIconListLocked, &allocIconObj);
 170
 171                         parentLock = ParentDir(wsNew->ws_Lock);
 172                         debugLock_d1(parentLock);
 173                         if (parentLock)
 174                                 {
 175                                 UnLock(parentLock);
 176                                 }
 177                         else
 178                                 {
 179                                 // this is a root window
 180                                 wsNew->ws_Flags |= WSV_FlagF_RootWindow;
 181                                 }
 182                         }
 183
 184                 d1(KPrintF("%s/%s/%ld: IconObj=%08lx  ws_Name=%08lx\n", __FILE__, __FUNC__, __LINE__, IconObj, wsNew->ws_Name));
 185
 186                 WindowRect = (struct IBox *) GetTagData(SCA_WindowRect, (ULONG)NULL, TagList);
 187                 d1(KPrintF("%s/%s/%ld: WindowRect=%08lx\n", __FILE__, __FUNC__, __LINE__, WindowRect));
 188                 if (NULL == WindowRect)
 189                         GetAttr(IDTA_WindowRect, IconObj, (APTR) &WindowRect);
 190
 191                 d1(kprintf("%s/%s/%ld: WindowRect=%08lx\n", __FILE__, __FUNC__, __LINE__, WindowRect));
 192                 if (WindowRect)
 193                         {
 194                         wsNew->ws_Left = WindowRect->Left;
 195                         wsNew->ws_Top = WindowRect->Top;
 196                         wsNew->ws_Width = WindowRect->Width;
 197                         wsNew->ws_Height = WindowRect->Height;
 198                         }
 199
 200                 wsNew->ws_xoffset = wsNew->ws_yoffset = 0;
 201                 wsNew->ws_Viewmodes = GetTagData(SCA_ViewModes, IDTV_ViewModes_Default, TagList);
 202
 203                 wsNew->ws_ThumbnailView = CurrentPrefs.pref_ShowThumbnails;
 204
 205                 // determine default pattern number
 206                 if (IsViewByIcon(wsNew->ws_Viewmodes))
 207                         wsNew->ws_PatternNumber = PATTERNNR_IconWindowDefault;   // default icon window pattern no.
 208                 else
 209                         wsNew->ws_PatternNumber = PATTERNNR_TextWindowDefault;   // default text window pattern no.
 210
 211                 wsNew->ws_ThumbnailsLifetimeDays = CurrentPrefs.pref_ThumbnailMaxAge;
 212
 213                 wsNew->ws_Flags = PackBoolTags(wsNew->ws_Flags, TagList, (struct TagItem *) FlagMapTable);
 214                 wsNew->ws_MoreFlags = PackBoolTags(wsNew->ws_MoreFlags, TagList, (struct TagItem *) MoreFlagMapTable);
 215
 216                 d1(KPrintF("%s/%s/%ld: ws_Flags=%08lx\n", __FILE__, __FUNC__, __LINE__, wsNew->ws_Flags));
 217
 218                 if (IconObj)
 219                         {
 220                         struct IconWindowProperties iwp;
 221
 222                         iwp.iwp_SortOrder = wsNew->ws_SortOrder;
 223                         iwp.iwp_ThumbnailView = wsNew->ws_ThumbnailView;
 224                         iwp.iwp_ThumbnailsLifetimeDays = wsNew->ws_ThumbnailsLifetimeDays;
 225                         iwp.iwp_ShowAll = wsNew->ws_ViewAll;
 226                         iwp.iwp_Viewmodes = wsNew->ws_Viewmodes;
 227                         iwp.iwp_PatternNumber = wsNew->ws_PatternNumber;
 228                         iwp.iwp_CheckOverlap = (wsNew->ws_Flags & WSV_FlagF_CheckOverlappingIcons) != 0;
 229                         iwp.iwp_XOffset = iwp.iwp_YOffset = 0;
 230                         iwp.iwp_OpacityActive = wsNew->ws_WindowOpacityActive;
 231                         iwp.iwp_OpacityInactive = wsNew->ws_WindowOpacityInactive;
 232                         iwp.iwp_IconSizeConstraints = wsNew->ws_IconSizeConstraints;
 233                         iwp.iwp_IconScaleFactor = wsNew->ws_IconScaleFactor;
 234
 235                         FunctionsGetSettingsFromIconObject(&iwp, IconObj);
 236
 237                         wsNew->ws_SortOrder = iwp.iwp_SortOrder;
 238                         wsNew->ws_ViewAll = iwp.iwp_ShowAll;
 239                         wsNew->ws_ThumbnailsLifetimeDays = iwp.iwp_ThumbnailsLifetimeDays;
 240                         wsNew->ws_PatternNumber = iwp.iwp_PatternNumber;
 241                         wsNew->ws_Viewmodes = iwp.iwp_Viewmodes;
 242                         wsNew->ws_ThumbnailView = iwp.iwp_ThumbnailView;
 243                         wsNew->ws_WindowOpacityActive = iwp.iwp_OpacityActive;
 244                         wsNew->ws_WindowOpacityInactive = iwp.iwp_OpacityInactive;
 245                         wsNew->ws_IconSizeConstraints = iwp.iwp_IconSizeConstraints;
 246                         wsNew->ws_IconScaleFactor = iwp.iwp_IconScaleFactor;
 247
 248                         if (iwp.iwp_NoStatusBar)
 249                                 wsNew->ws_Flags |= WSV_FlagF_NoStatusBar;
 250                         if (iwp.iwp_NoControlBar)
 251                                 wsNew->ws_MoreFlags |= WSV_MoreFlagF_NoControlBar;
 252                         if (iwp.iwp_BrowserMode)
 253                                 wsNew->ws_Flags |= WSV_FlagF_BrowserMode;
 254
 255                         if (iwp.iwp_CheckOverlap)
 256                                 wsNew->ws_Flags |= WSV_FlagF_CheckOverlappingIcons;
 257                         else
 258                                 wsNew->ws_Flags &= ~WSV_FlagF_CheckOverlappingIcons;
 259                         }
 260
 261                 // SCA_ShowAllMode and SCA_ShowAllFiles tags explicitly given
 262                 // take precedence over window/icon settings
 263                 wsNew->ws_ViewAll = GetTagData(SCA_ShowAllMode, wsNew->ws_ViewAll, TagList);
 264                 if (NULL == FindTagItem(SCA_ShowAllMode, TagList)
 265                                 && FindTagItem(SCA_ShowAllFiles, TagList))
 266                         {
 267                         wsNew->ws_ViewAll = GetTagData(SCA_ShowAllFiles, FALSE, TagList)
 268                                 ? DDFLAGS_SHOWALL : DDFLAGS_SHOWDEFAULT;
 269                         }
 270
 271                 if (IsShowAll(wsNew))
 272                         wsNew->ws_Flags |= WSV_FlagF_ShowAllFiles;
 273                 else
 274                         wsNew->ws_Flags &= ~WSV_FlagF_ShowAllFiles;
 275
 276                 wsNew->ws_xoffset = GetTagData(SCA_XOffset, wsNew->ws_xoffset, TagList);
 277                 wsNew->ws_yoffset = GetTagData(SCA_YOffset, wsNew->ws_yoffset, TagList);
 278
 279                 wsNew->ws_PatternNumber = GetTagData(SCA_PatternNumber, wsNew->ws_PatternNumber, TagList);
 280                 wsNew->ws_PatternNode = GetPatternNode(wsNew->ws_PatternNumber, NULL);
 281
 282                 wsNew->ws_Viewmodes = GetTagData(SCA_ViewModes, wsNew->ws_Viewmodes, TagList);
 283
 284                 wsNew->ws_WindowOpacityActive = GetTagData(SCA_TransparencyActive, wsNew->ws_WindowOpacityActive, TagList);
 285                 wsNew->ws_WindowOpacityInactive = GetTagData(SCA_TransparencyInactive, wsNew->ws_WindowOpacityInactive, TagList);
 286
 287                 d1(kprintf("%s/%s/%ld: ws_ViewModes=%ld\n", __FILE__, __FUNC__, __LINE__, wsNew->ws_Viewmodes));
 288                 d1(KPrintF("%s/%s/%ld: ws_Flags=%08lx\n", __FILE__, __FUNC__, __LINE__, wsNew->ws_Flags));
 289
 290                 if (IsViewByIcon(wsNew->ws_Viewmodes))
 291                         wsNew->ms_ClassName = (STRPTR) "IconWindow.sca";
 292                 else
 293                         wsNew->ms_ClassName = (STRPTR) "TextWindow.sca";
 294
 295                 wsNew->ms_ClassName = (STRPTR) GetTagData(SCA_ClassName, (ULONG) wsNew->ms_ClassName, TagList);
 296
 297                 wsNew->ms_Class = (Class *) GetTagData(SCA_Class, (ULONG)NULL, TagList);
 298                 if (wsNew->ms_Class)
 299                         wsNew->ms_ClassName = NULL;
 300
 301                 if ((BPTR)NULL == wsNew->ws_Lock)
 302                         {
 303                         d1(kprintf("%s/%s/%ld: \n", __FILE__, __FUNC__, __LINE__));
 304
 305                         if (in)
 306                                 {
 307                                 d1(kprintf("%s/%s/%ld: \n", __FILE__, __FUNC__, __LINE__));
 308
 309                                 if (in->in_Lock)
 310                                         {
 311                                         // .withlock:
 312                                         BPTR oldDir;
 313
 314                                         if (NULL == in->in_Name)
 315                                                 break;
 316
 317                                         wsNew->ws_Name = AllocCopyString(in->in_Name);
 318                                         if (NULL == wsNew->ws_Name)
 319                                                 break;
 320
 321                                         oldDir = CurrentDir(in->in_Lock);
 322
 323                                         wsNew->ws_Lock = Lock(in->in_Name, ACCESS_READ);
 324
 325                                         CurrentDir(oldDir);
 326
 327                                         if ((BPTR)NULL == wsNew->ws_Lock)
 328                                                 break;
 329                                         }
 330                                 else
 331                                         {
 332                                         d1(kprintf("%s/%s/%ld: \n", __FILE__, __FUNC__, __LINE__));
 333
 334                                         if (in->in_DeviceIcon)
 335                                                 {
 336                                                 wsNew->ws_Lock = DiskInfoLock(in);
 337                                                 debugLock_d1(wsNew->ws_Lock);
 338                                                 if ((BPTR)NULL == wsNew->ws_Lock)
 339                                                         break;
 340
 341                                                 wsNew->ws_Name = AllocCopyString(in->in_DeviceIcon->di_Volume);
 342                                                 d1(kprintf("%s/%s/%ld: ws_Name=%08lx\n", __FILE__, __FUNC__, __LINE__, wsNew->ws_Name));
 343                                                 if (NULL == wsNew->ws_Name)
 344                                                         break;
 345
 346                                                 StripTrailingColon(wsNew->ws_Name);
 347
 348                                                 wsNew->ws_Flags |= WSV_FlagF_RootWindow;
 349                                                 }
 350                                         else
 351                                                 {
 352                                                 // .onlyicon:
 353                                                 if (NULL == in->in_Name)
 354                                                         break;
 355
 356                                                 wsNew->ws_Lock = Lock(in->in_Name, ACCESS_READ);
 357                                                 debugLock_d1(wsNew->ws_Lock);
 358                                                 if ((BPTR)NULL == wsNew->ws_Lock)
 359                                                         break;
 360
 361                                                 wsNew->ws_Name = AllocCopyString(in->in_Name);
 362                                                 d1(kprintf("%s/%s/%ld: ws_Name=%08lx\n", __FILE__, __FUNC__, __LINE__, wsNew->ws_Name));
 363                                                 if (NULL == wsNew->ws_Name)
 364                                                         break;
 365                                                 }
 366                                         }
 367                                 }
 368                         else
 369                                 {
 370                                 // .noiconnode:
 371                                 STRPTR iconName = NULL;
 372                                 ULONG IconType;
 373
 374                                 d1(kprintf("%s/%s/%ld: IconObj=%08lx\n", __FILE__, __FUNC__, __LINE__, IconObj));
 375
 376                                 if (NULL == IconObj)
 377                                         break;
 378
 379                                 GetAttr(DTA_Name, IconObj, (APTR) &iconName);
 380                                 if (NULL == iconName)
 381                                         break;
 382                                 if ('\0' == *iconName)
 383                                         break;
 384
 385                                 d1(kprintf("%s/%s/%ld: iconName=<%s> \n", __FILE__, __FUNC__, __LINE__, iconName));
 386
 387                                 GetAttr(IDTA_Type, IconObj, &IconType);
 388
 389                                 if (':' == iconName[strlen(iconName) - 1])
 390                                         IconType = WBDISK;
 391
 392                                 d1(kprintf("%s/%s/%ld: IconType=%ld\n", __FILE__, __FUNC__, __LINE__, IconType));
 393
 394                                 if (WBDISK == IconType)
 395                                         {
 396                                         wsNew->ws_Name = AllocCopyString(iconName);
 397
 398                                         if (NULL == wsNew->ws_Name)
 399                                                 break;
 400
 401                                         StripTrailingColon(wsNew->ws_Name);
 402
 403                                         wsNew->ws_Flags |= WSV_FlagF_RootWindow;
 404                                         }
 405                                 else
 406                                         {
 407                                         wsNew->ws_Name = AllocCopyString(FilePart(iconName));
 408                                         if (NULL == wsNew->ws_Name)
 409                                                 break;
 410                                         }
 411
 412                                 wsNew->ws_Lock = Lock(iconName, ACCESS_READ);
 413                                 debugLock_d1(wsNew->ws_Lock);
 414                                 if ((BPTR)NULL == wsNew->ws_Lock)
 415                                         break;
 416                                 }
 417                         }
 418                 // .lockok:
 419                 d1(kprintf("%s/%s/%ld: ws_Name=%08lx\n", __FILE__, __FUNC__, __LINE__, wsNew->ws_Name));
 420
 421                 if (wsIconListLocked)
 422                         {
 423                         d1(kprintf("\n" "%s/%s/%ld:  wsLocked=%08lx\n", __FILE__, __FUNC__, __LINE__, wsIconListLocked));
 424                         ScalosReleaseSemaphore(wsIconListLocked->ws_WindowTask->wt_IconSemaphore);
 425                         wsIconListLocked = NULL;
 426                         }
 427                 if (WindowListLocked)
 428                         {
 429                         d1(kprintf("%s/%s/%ld: \n", __FILE__, __FUNC__, __LINE__));
 430                         SCA_UnLockWindowList();
 431                         WindowListLocked = FALSE;
 432                         }
 433
 434                 if (wsNew->ws_Flags & WSV_FlagF_RootWindow)
 435                         clp = CurrentPrefs.pref_MainWindowTitle;
 436                 else
 437                         clp = CurrentPrefs.pref_StandardWindowTitle;
 438
 439                 wsNew->ws_Title = AllocCopyString((STRPTR) GetTagData(SCA_WindowTitle, (ULONG) clp, TagList));
 440                 if (NULL == wsNew->ws_Title)
 441                         break;
 442
 443                 Found = FALSE;
 444                 SCA_LockWindowList(SCA_LockWindowList_Shared);
 445
 446                 d1(kprintf("%s/%s/%ld: \n", __FILE__, __FUNC__, __LINE__));
 447                 debugLock_d1(wsNew->ws_Lock);
 448
 449                 for (ws=winlist.wl_WindowStruct; !Found && ws; ws = (struct ScaWindowStruct *) ws->ws_Node.mln_Succ)
 450                         {
 451                         if (ws != wsNew && ws->ws_Lock &&
 452                                 LOCK_SAME == ScaSameLock(wsNew->ws_Lock, ws->ws_Lock))
 453                                 {
 454                                 Found = TRUE;
 455
 456                                 if (ws->ws_Flags & WSV_FlagF_Iconify)
 457                                         {
 458                                         struct ScalosMessage *msg = SCA_AllocMessage(MTYP_UnIconify, 0);
 459
 460                                         if (msg)
 461                                                 {
 462                                                 d1(kprintf("%s/%s/%ld: PutMsg iwt=%08lx  Msg=%08lx \n", __FILE__, __FUNC__, __LINE__, ws->ws_WindowTask, &msg->sm_Message));
 463                                                 PutMsg(ws->ws_MessagePort, &msg->sm_Message);
 464                                                 }
 465                                         }
 466                                 else
 467                                         {
 468                                         if (ws->ws_Window)
 469                                                 {
 470                                                 ActivateWindow(ws->ws_Window);
 471                                                 WindowToFront(ws->ws_Window);
 472                                                 }
 473                                         }
 474                                 }
 475                         }
 476
 477                 d1(kprintf("%s/%s/%ld: Found=%ld\n", __FILE__, __FUNC__, __LINE__, Found));
 478
 479                 SCA_UnLockWindowList();
 480
 481                 if (Found)
 482                         {
 483                         // requested Scalos window for drawer is already open
 484                         Success = TRUE;
 485                         break;
 486                         }
 487
 488                 msgStart = (struct SM_StartWindow *) SCA_AllocMessage(MTYP_StartWindow, 0);
 489                 d1(kprintf("%s/%s/%ld: msgStart=%08lx\n", __FILE__, __FUNC__, __LINE__, msgStart));
 490                 if (NULL == msgStart)
 491                         break;
 492
 493                 msgStart->ScalosMessage.sm_Message.mn_ReplyPort = ReplyPort;
 494                 msgStart->WindowStruct = wsNew;
 495
 496                 length = 50 + strlen(wsNew->ws_Name);
 497
 498                 wsNew->ws_WindowTaskName = ScalosAlloc(length);
 499                 if (wsNew->ws_WindowTaskName)
 500                         {
 501                         TaskName = wsNew->ws_WindowTaskName;
 502
 503                         ScaFormatStringMaxLength(TaskName, length,
 504                                 "Scalos_Window_Task <%s>", (ULONG) wsNew->ws_Name);
 505                         }
 506                 else
 507                         {
 508                         TaskName = (STRPTR) "Scalos_Window_Task";
 509                         }
 510
 511                 d1(kprintf("%s/%s/%ld: \n", __FILE__, __FUNC__, __LINE__));
 512
 513                 wsNew->ws_Task = CreateNewProcTags(
 514                                 NP_WindowPtr, ~0,
 515                                 NP_StackSize, CurrentPrefs.pref_DefaultStackSize,
 516                                 NP_Priority, 1,
 517                                 NP_Cli, TRUE,
 518                                 NP_CommandName, (ULONG) TaskName,
 519                                 NP_Name, (ULONG) TaskName,
 520                                 NP_Entry, (ULONG) PATCH_NEWFUNC(WindowTask),
 521                                 NP_CurrentDir, wsNew->ws_Lock,
 522                                 NP_Path, DupWBPathList(),
 523                                 TAG_END);
 524
 525                 d1(kprintf("%s/%s/%ld: ws_Task=%08lx\n", __FILE__, __FUNC__, __LINE__, wsNew->ws_Task));
 526                 if (NULL == wsNew->ws_Task)
 527                         break;
 528
 529                 d1(kprintf("%s/%s/%ld: \n", __FILE__, __FUNC__, __LINE__));
 530
 531                 PutMsg(&wsNew->ws_Task->pr_MsgPort, &msgStart->ScalosMessage.sm_Message);
 532                 msgStart = NULL;        // no SCA_FreeMessage()
 533
 534                 d1(kprintf("%s/%s/%ld: \n", __FILE__, __FUNC__, __LINE__));
 535
 536                 if (WindowFlags & SCAF_OpenWindow_ScalosPort)
 537                         {
 538                         d1(kprintf("%s/%s/%ld: \n", __FILE__, __FUNC__, __LINE__));
 539                         WaitReply(ReplyPort, NULL, MTYP_StartWindow);
 540                         }
 541                 else
 542                         {
 543                         BOOL Finished = FALSE;
 544                         struct ScalosMessage *ReplyMsg;
 545
 546                         do      {
 547                                 WaitPort(ReplyPort);
 548
 549                                 ReplyMsg = (struct ScalosMessage *) GetMsg(ReplyPort);
 550
 551                                 d1(kprintf("%s/%s/%ld: MessageType=%ld\n", __FILE__, __FUNC__, __LINE__, ReplyMsg->sm_MessageType));
 552
 553                                 if (ReplyMsg && ID_IMSG == ReplyMsg->sm_Signature
 554                                         && MTYP_StartWindow == ReplyMsg->sm_MessageType)
 555                                         {
 556                                         SCA_FreeMessage(ReplyMsg);
 557                                         Finished = TRUE;
 558                                         }
 559                                 } while (!Finished);
 560                         }
 561
 562                 d1(kprintf("%s/%s/%ld: \n", __FILE__, __FUNC__, __LINE__));
 563
 564                 if (ReturnWs)
 565                         *ReturnWs = wsNew;
 566
 567                 d1(kprintf("%s/%s/%ld: \n", __FILE__, __FUNC__, __LINE__));
 568
 569                 wsNew = NULL;
 570                 Success = TRUE;
 571                 } while (0);
 572
 573         if (wsIconListLocked)
 574                 {
 575                 d1(kprintf("\n" "%s/%s/%ld:  wsLocked=%08lx\n", __FILE__, __FUNC__, __LINE__, wsIconListLocked));
 576                 ScalosReleaseSemaphore(wsIconListLocked->ws_WindowTask->wt_IconSemaphore);
 577                 }
 578         if (WindowListLocked)
 579                 {
 580                 d1(kprintf("%s/%s/%ld: \n", __FILE__, __FUNC__, __LINE__));
 581                 SCA_UnLockWindowList();
 582                 }
 583
 584         if (msgStart)
 585                 SCA_FreeMessage(&msgStart->ScalosMessage);
 586         if (allocIconObj)
 587                 DisposeIconObject(allocIconObj);
 588         if (wsNew)
 589                 {
 590                 if (wsNew->ws_Lock)
 591                         UnLock(wsNew->ws_Lock);
 592                 if (wsNew->ws_Name)
 593                         FreeCopyString(wsNew->ws_Name);
 594
 595                 SCA_FreeAllNodes((struct ScalosNodeList *)(APTR) &dummyList);
 596                 }
 597         if (allocMsgPort)
 598                 DeleteMsgPort(allocMsgPort);
 599
 600         d1(kprintf("%s/%s/%ld: Success=%ld\n", __FILE__, __FUNC__, __LINE__, Success));
 601
 602         return Success;
 603 }
 604 LIBFUNC_END
 605
 606
 607 BPTR DiskInfoLock(const struct ScaIconNode *in)
 608 {
 609         return Lock(in->in_DeviceIcon->di_Device, ACCESS_READ);
 610 }
 611
 612
 613 static Object *ReadDeviceIconObject(CONST_STRPTR Path)
 614 {
 615         Object *IconObj = NULL;
 616         STRPTR internalName;
 617         struct DosList *dList;
 618
 619         do      {
 620                 internalName = AllocPathBuffer();
 621                 if (NULL == internalName)
 622                         break;
 623
 624                 stccpy(internalName, Path, Max_PathLen);
 625                 StripTrailingColon(internalName);
 626
 627                 d1(kprintf("%s/%s/%ld:  Path=<%s>  internalName=<%s>\n", __FILE__, __FUNC__, __LINE__, Path, internalName));
 628
 629                 dList = LockDosList(LDF_ASSIGNS | LDF_DEVICES | LDF_VOLUMES | LDF_READ);
 630                 if ((dList = FindDosEntry(dList, internalName, LDF_ASSIGNS | LDF_DEVICES | LDF_VOLUMES)))
 631                         {
 632                         // First, try to get "VOLNAME:disk" icon
 633
 634                         d1(kprintf("%s/%s/%ld:  FOUND internalName=<%s>  Type=%ld\n", __FILE__, __FUNC__, __LINE__, internalName, dList->dol_Type));
 635
 636                         stccpy(internalName, Path, Max_PathLen - 5);
 637                         AddPart(internalName, "disk", Max_PathLen);
 638
 639                         d1(kprintf("%s/%s/%ld: internalName=<%s>\n", __FILE__, __FUNC__, __LINE__, internalName));
 640
 641                         IconObj = NewIconObjectTags(internalName,
 642                                 IDTA_SizeConstraints, (ULONG) &CurrentPrefs.pref_IconSizeConstraints,
 643                                 IDTA_ScalePercentage, CurrentPrefs.pref_IconScaleFactor,
 644                                 TAG_END);
 645                         d1(kprintf("%s/%s/%ld:  IconObj=%08lx  internalName=<%s>\n", __FILE__, __FUNC__, __LINE__, IconObj, internalName));
 646
 647                         if (NULL == IconObj && CurrentPrefs.pref_DefIconPath)
 648                                 {
 649                                 CONST_STRPTR DeviceName = NULL;
 650
 651                                 switch (dList->dol_Type)
 652                                         {
 653                                 case DLT_DIRECTORY:
 654                                 case DLT_LATE:
 655                                 case DLT_NONBINDING:
 656                                         IconObj = NewIconObjectTags(Path,
 657                                                 IDTA_SizeConstraints, (ULONG) &CurrentPrefs.pref_IconSizeConstraints,
 658                                                 IDTA_ScalePercentage, CurrentPrefs.pref_IconScaleFactor,
 659                                                 TAG_END);
 660                                         break;
 661
 662                                 case DLT_DEVICE:
 663                                         DeviceName = Path;
 664                                         break;
 665
 666                                 case DLT_VOLUME:
 667                                         if (dList->dol_Task)
 668                                                 {
 669                                                 // no "VOLNAME:disk" icon found
 670                                                 // try "ENV:sys/def_DEVNAME"
 671
 672                                                 // get Device name from volume name, e.g. "RAM" from "Ram Disk"
 673                                                 struct Task *SigTask = (struct Task *) dList->dol_Task->mp_SigTask;
 674
 675                                                 if (SigTask)
 676                                                         DeviceName = SigTask->tc_Node.ln_Name;
 677                                                 }
 678                                         break;
 679                                         }
 680
 681                                 if (NULL == IconObj && DeviceName)
 682                                         {
 683                                         stccpy(internalName, CurrentPrefs.pref_DefIconPath, Max_PathLen);
 684
 685                                         AddPart(internalName, "def_", Max_PathLen - 1);
 686
 687                                         SafeStrCat(internalName, DeviceName, Max_PathLen - 1);
 688                                         StripTrailingColon(internalName);
 689                                         SafeStrCat(internalName, "disk", Max_PathLen - 1);
 690
 691                                         // if XXX is our device name, then
 692                                         // look for "ENVARC:sys/def_XXXdisk"
 693
 694                                         d1(kprintf("%s/%s/%ld: DeviceName=<%s>\n", __FILE__, __FUNC__, __LINE__, internalName));
 695
 696                                         IconObj = NewIconObjectTags(internalName,
 697                                                 IDTA_SizeConstraints, (ULONG) &CurrentPrefs.pref_IconSizeConstraints,
 698                                                 IDTA_ScalePercentage, CurrentPrefs.pref_IconScaleFactor,
 699                                                 TAG_END);
 700                                         }
 701                                 }
 702                         }
 703
 704                 UnLockDosList(LDF_ASSIGNS | LDF_VOLUMES | LDF_DEVICES | LDF_READ);
 705                 } while (0);
 706
 707         if (internalName)
 708                 FreePathBuffer(internalName);
 709
 710         return IconObj;
 711 }
 712
 713
 714 static Object *FindIconInScalosWindows(BPTR Lock, CONST_STRPTR IconName,
 715         struct ScaWindowStruct **wsLocked, BOOL *windowListLocked)
 716 {
 717         struct ScaWindowStruct *ws;
 718
 719         *wsLocked = NULL;
 720         *windowListLocked = FALSE;
 721
 722         SCA_LockWindowList(SCA_LockWindowList_Shared);
 723
 724         for (ws=winlist.wl_WindowStruct; ws; ws = (struct ScaWindowStruct *) ws->ws_Node.mln_Succ)
 725                 {
 726                 d1(kprintf("\n" "%s/%s/%ld: ws=%08lx  <%s>\n", __FILE__, __FUNC__, __LINE__, ws, ws->ws_Name));
 727                 debugLock_d1(ws->ws_Lock);
 728
 729                 if (LOCK_SAME == SameLock(ws->ws_Lock, Lock))
 730                         {
 731                         struct internalScaWindowTask *iwt = (struct internalScaWindowTask *) ws->ws_WindowTask;
 732                         struct ScaIconNode *in;
 733
 734                         d1(kprintf("\n" "%s/%s/%ld: found ws=%08lx\n", __FILE__, __FUNC__, __LINE__, ws));
 735
 736                         ScalosLockIconListShared(iwt);
 737
 738                         for (in = iwt->iwt_WindowTask.wt_IconList; in; in = (struct ScaIconNode *) in->in_Node.mln_Succ)
 739                                 {
 740                                 CONST_STRPTR Name = GetIconName(in);
 741
 742                                 if (Name && 0 == Stricmp((STRPTR) IconName, (STRPTR) Name))
 743                                         {
 744                                         *wsLocked = ws;
 745                                         *windowListLocked = TRUE;
 746
 747                                         d1(kprintf("\n" "%s/%s/%ld: ws=%08lx  in=%08lx <%s>  Icon=%08lx\n", __FILE__, __FUNC__, __LINE__, ws, in, Name, in->in_Icon));
 748
 749                                         return in->in_Icon;
 750                                         }
 751                                 }
 752
 753                         d1(kprintf("%s/%s/%ld: \n", __FILE__, __FUNC__, __LINE__));
 754
 755                         ScalosUnLockIconList(iwt);
 756                         }
 757
 758                 }
 759
 760         d1(kprintf("%s/%s/%ld: \n", __FILE__, __FUNC__, __LINE__));
 761
 762         SCA_UnLockWindowList();
 763
 764         d1(kprintf("\n" "%s/%s/%ld: not found\n", __FILE__, __FUNC__, __LINE__));
 765
 766         return NULL;
 767 }
 768
 769
 770 static Object *FindIconInDeviceWindow(CONST_STRPTR IconName,
 771         struct ScaWindowStruct **wsLocked, BOOL *windowListLocked)
 772 {
 773         struct internalScaWindowTask *iwt;
 774         struct ScaIconNode *in;
 775
 776         *windowListLocked = FALSE;
 777
 778         d1(KPrintF("\n" "%s/%s/%ld: IconName=<%s>\n", __FILE__, __FUNC__, __LINE__, IconName));
 779         d1(KPrintF("\n" "%s/%s/%ld: ii_MainWindowStruct=%08lx\n", __FILE__, __FUNC__, __LINE__, iInfos.xii_iinfos.ii_MainWindowStruct));
 780
 781         while (NULL == iInfos.xii_iinfos.ii_MainWindowStruct
 782                 || NULL == iInfos.xii_iinfos.ii_MainWindowStruct->ws_WindowTask)
 783                 {
 784                 d1(KPrintF("\n" "%s/%s/%ld: Wait for ii_MainWindowStruct=%08lx\n", __FILE__, __FUNC__, __LINE__, iInfos.xii_iinfos.ii_MainWindowStruct));
 785                 Delay(10);
 786                 }
 787         iwt = (struct internalScaWindowTask *) iInfos.xii_iinfos.ii_MainWindowStruct->ws_WindowTask;
 788
 789         d1(KPrintF("\n" "%s/%s/%ld: wt_IconSemaphore=%08lx\n", __FILE__, __FUNC__, __LINE__, iwt->iwt_WindowTask.wt_IconSemaphore));
 790
 791         while (NULL == iwt->iwt_WindowTask.wt_IconSemaphore && !iwt->iwt_CloseWindow)
 792                 {
 793                 d1(KPrintF("\n" "%s/%s/%ld: Wait for wt_IconSemaphore=%08lx\n", __FILE__, __FUNC__, __LINE__, iwt->iwt_WindowTask.wt_IconSemaphore));
 794                 Delay(10);
 795                 }
 796
 797         d1(kprintf("%s/%s/%ld: \n", __FILE__, __FUNC__, __LINE__));
 798         ScalosLockIconListShared(iwt);
 799
 800         *wsLocked = iwt->iwt_WindowTask.mt_WindowStruct;
 801
 802         for (in = iwt->iwt_WindowTask.wt_IconList; in; in = (struct ScaIconNode *) in->in_Node.mln_Succ)
 803                 {
 804                 if (MatchDeviceIcon(IconName, in))
 805                         {
 806                         d1(KPrintF("\n" "%s/%s/%ld: iwt=%08lx  in=%08lx <%s>  Icon=%08lx\n", __FILE__, __FUNC__, __LINE__, iwt, in, IconName, in->in_Icon));
 807                         return in->in_Icon;
 808                         }
 809                 }
 810
 811         d1(kprintf("%s/%s/%ld: \n", __FILE__, __FUNC__, __LINE__));
 812
 813         ScalosUnLockIconList(iwt);
 814
 815         *wsLocked = NULL;
 816
 817         d1(kprintf("%s/%s/%ld: \n", __FILE__, __FUNC__, __LINE__));
 818         d1(kprintf("\n" "%s/%s/%ld: not found\n", __FILE__, __FUNC__, __LINE__));
 819
 820         return NULL;
 821 }
 822
 823 // ----------------------------------------------------------
 824
 825 STRPTR GetWsNameFromLock(BPTR WsLock)
 826 {
 827         STRPTR allocPath;
 828         STRPTR WsName = NULL;
 829
 830         do      {
 831                 STRPTR lp;
 832
 833                 allocPath = AllocPathBuffer();
 834                 if (NULL == allocPath)
 835                         break;
 836
 837                 if (!NameFromLock(WsLock, allocPath, Max_PathLen - 1))
 838                         break;
 839
 840                 lp = FilePart(allocPath);
 841                 d1(kprintf("%s/%s/%ld: FilePart=<%s>\n", __FILE__, __FUNC__, __LINE__, lp));
 842                 if (*lp)
 843                         {
 844                         WsName = AllocCopyString(lp);
 845                         if (NULL == WsName)
 846                                 break;
 847                         }
 848                 else
 849                         {
 850                         WsName = AllocCopyString(allocPath);
 851                         if (NULL == WsName)
 852                                 break;
 853
 854                         StripTrailingColon(WsName);
 855                         }
 856                 } while (0);
 857
 858         if (allocPath)
 859                 FreePathBuffer(allocPath);
 860
 861         return WsName;
 862 }
 863
 864 // ----------------------------------------------------------
 865
 866 static BOOL MatchDeviceIcon(CONST_STRPTR SearchPath, struct ScaIconNode *in)
 867 {
 868         if (NULL == in->in_DeviceIcon)
 869                 return FALSE;
 870
 871         return (BOOL) (MatchPath(SearchPath, in->in_DeviceIcon->di_Volume)
 872                         ||  MatchPath(SearchPath, in->in_DeviceIcon->di_Device)
 873                         || MatchPath(SearchPath, GetIconName(in)));
 874 }
 875
 876
 877 static BOOL MatchPath(CONST_STRPTR VolPath, CONST_STRPTR DevIconPath)
 878 {
 879         BOOL Match = FALSE;
 880
 881         if (DevIconPath)
 882                 {
 883                 size_t len = strlen(VolPath);
 884                 size_t diLen = strlen(DevIconPath);
 885
 886                 if (':' == DevIconPath[diLen - 1])
 887                         Match = 0 == Stricmp(VolPath, DevIconPath);
 888                 else
 889                         Match = (diLen + 1 == len) && 0 == Strnicmp(VolPath, DevIconPath, len);
 890                 }
 891
 892         return Match;
 893 }
 894
 895 // ----------------------------------------------------------
 896
 897 Object *FunctionsFindIconObjectForPath(CONST_STRPTR Path, BOOL *WindowListLocked,
 898         struct ScaWindowStruct **wsIconListLocked, Object **allocIconObj)
 899 {
 900         Object *IconObj = NULL;
 901         BPTR pLock;
 902         BPTR parentLock = BNULL;
 903         BPTR oldDir = NOT_A_LOCK;
 904         STRPTR FullPath = NULL;
 905
 906         do      {
 907                 d1(KPrintF("%s/%s/%ld: START  Path=<%s>\n", __FILE__, __FUNC__, __LINE__, Path));
 908
 909                 pLock = Lock(Path, ACCESS_READ);
 910                 debugLock_d1(pLock);
 911                 if (BNULL == pLock)
 912                         break;
 913
 914                 FullPath = AllocPathBuffer();
 915                 if (NULL == FullPath)
 916                         break;
 917
 918                 if (!NameFromLock(pLock, FullPath, Max_PathLen - 1))
 919                         break;
 920
 921                 d1(KPrintF("%s/%s/%ld: FullPath=<%s>\n", __FILE__, __FUNC__, __LINE__, FullPath));
 922
 923                 oldDir = CurrentDir(pLock);
 924                 parentLock = ParentDir(pLock);
 925                 debugLock_d1(parentLock);
 926                 if (parentLock)
 927                         {
 928                         d1(KPrintF("%s/%s/%ld: Drawer window\n", __FILE__, __FUNC__, __LINE__));
 929
 930                         IconObj = FindIconInScalosWindows(parentLock, FullPath,
 931                                         wsIconListLocked, WindowListLocked);
 932
 933                         d1(KPrintF("%s/%s/%ld: IconObj=%08lx\n", __FILE__, __FUNC__, __LINE__, IconObj));
 934                         if (NULL == IconObj)
 935                                 {
 936                                 CurrentDir(parentLock);
 937
 938                                 IconObj = *allocIconObj = NewIconObjectTags(FullPath,
 939                                         IDTA_SizeConstraints, (ULONG) &CurrentPrefs.pref_IconSizeConstraints,
 940                                         IDTA_ScalePercentage, CurrentPrefs.pref_IconScaleFactor,
 941                                         TAG_END);
 942
 943                                 d1(KPrintF("%s/%s/%ld: IconObj=%08lx\n", __FILE__, __FUNC__, __LINE__, IconObj));
 944                                 if (NULL == IconObj)
 945                                         {
 946                                         IconObj = (Object *) DoMethod(iInfos.xii_iinfos.ii_MainWindowStruct->ws_WindowTask->mt_MainObject,
 947                                                 SCCM_IconWin_GetDefIcon,
 948                                                 FullPath,
 949                                                 ST_USERDIR,
 950                                                 0,
 951                                                 WBDRAWER);
 952
 953                                         d1(KPrintF("%s/%s/%ld: IconObj=%08lx\n", __FILE__, __FUNC__, __LINE__, IconObj));
 954                                         }
 955                                 }
 956                         }
 957                 else
 958                         {
 959                         // this is a root window
 960                         d1(KPrintF("%s/%s/%ld: Root window\n", __FILE__, __FUNC__, __LINE__));
 961
 962                         IconObj = FindIconInDeviceWindow(FullPath,
 963                                         wsIconListLocked, WindowListLocked);
 964
 965                         d1(KPrintF("%s/%s/%ld: IconObj=%08lx\n", __FILE__, __FUNC__, __LINE__, IconObj));
 966
 967                         if (NULL == IconObj)
 968                                 IconObj = *allocIconObj = ReadDeviceIconObject(FullPath);
 969                         }
 970                 } while (0);
 971
 972         if (IS_VALID_LOCK(oldDir))
 973                 CurrentDir(oldDir);
 974         if (parentLock)
 975                 UnLock(parentLock);
 976         if (FullPath)
 977                 FreePathBuffer(FullPath);
 978         if (pLock)
 979                 UnLock(pLock);
 980
 981         d1(KPrintF("%s/%s/%ld: END IconObj=%08lx\n", __FILE__, __FUNC__, __LINE__, IconObj));
 982
 983         return IconObj;
 984 }
 985
 986 // ----------------------------------------------------------
 987
 988 void FunctionsGetSettingsFromIconObject(struct IconWindowProperties *iwp, Object *IconObj)
 989 {
 990         ULONG ddFlags;
 991         ULONG ViewBy;
 992         ULONG lDummy;
 993         STRPTR tt;
 994
 995         GetAttr(IDTA_ViewModes, IconObj, &ViewBy);
 996         GetAttr(IDTA_Flags, IconObj, &ddFlags);
 997
 998         iwp->iwp_Viewmodes = TranslateViewModesFromIcon(ViewBy);
 999
1000         d1(KPrintF("%s/%s/%ld: ddFlags=%08lx\n", __FILE__, __FUNC__, __LINE__, ddFlags));
1001
1002         switch (ddFlags & DDFLAGS_SHOWMASK)
1003                 {
1004         case DDFLAGS_SHOWDEFAULT:
1005                 iwp->iwp_ShowAll = DDFLAGS_SHOWDEFAULT;
1006                 break;
1007         case DDFLAGS_SHOWICONS:
1008                 iwp->iwp_ShowAll = DDFLAGS_SHOWICONS;
1009                 break;
1010         case DDFLAGS_SHOWALL:
1011         default:
1012                 iwp->iwp_ShowAll = DDFLAGS_SHOWALL;
1013                 break;
1014                 }
1015
1016         switch (ddFlags & DDFLAGS_SORTMASK)
1017                 {
1018         case DDFLAGS_SORTDEFAULT:
1019         default:
1020                 iwp->iwp_SortOrder = SortOrder_Default;
1021                 break;
1022         case DDFLAGS_SORTASC:
1023                 iwp->iwp_SortOrder = SortOrder_Ascending;
1024                 break;
1025         case DDFLAGS_SORTDESC:
1026                 iwp->iwp_SortOrder = SortOrder_Descending;
1027                 break;
1028                 }
1029
1030         tt = NULL;
1031         if (DoMethod(IconObj, IDTM_FindToolType, "SCALOS_PATTERNNO", &tt))
1032                 {
1033                 DoMethod(IconObj, IDTM_GetToolTypeValue, tt, (ULONG *) &lDummy);
1034                 iwp->iwp_PatternNumber = (UWORD) lDummy;
1035                 d1(KPrintF("%s/%s/%ld: iwp->iwp_PatternNumber=%lu\n", __FILE__, __FUNC__, __LINE__, iwp->iwp_PatternNumber));
1036                 }
1037         else
1038                 {
1039                 // determine default pattern number
1040                 if (IsViewByIcon(iwp->iwp_Viewmodes ))
1041                         iwp->iwp_PatternNumber  = PATTERNNR_IconWindowDefault;  // default icon window pattern no.
1042                 else
1043                         iwp->iwp_PatternNumber  = PATTERNNR_TextWindowDefault;  // default text window pattern no.
1044
1045                 }
1046
1047         tt = NULL;
1048         if (DoMethod(IconObj, IDTM_FindToolType, "SCALOS_CHECKOVERLAP", &tt))
1049                 {
1050                 DoMethod(IconObj, IDTM_GetToolTypeValue, tt, (ULONG *) &lDummy);
1051                 iwp->iwp_CheckOverlap = lDummy;
1052                 d1(KPrintF("%s/%s/%ld: iwp_CheckOverlap=%ld\n", __FILE__, __FUNC__, __LINE__, iwp->iwp_CheckOverlap));
1053                 }
1054
1055         tt = NULL;
1056         if (DoMethod(IconObj, IDTM_FindToolType, "SCALOS_THUMBNAILS", &tt))
1057                 {
1058                 d1(KPrintF("%s/%s/%ld: tt=<%s>\n", __FILE__, __FUNC__, __LINE__, tt));
1059                 while (*tt && '=' !=  *tt)
1060                         tt++;
1061
1062                 if ('=' ==  *tt)
1063                         {
1064                         ++tt;   // Skip "="
1065                         if (0 == Stricmp(tt, "NEVER"))
1066                                 iwp->iwp_ThumbnailView = THUMBNAILS_Never;
1067                         else if (0 == Stricmp(tt, "ALWAYS"))
1068                                 iwp->iwp_ThumbnailView = THUMBNAILS_Always;
1069                         else if (0 == Stricmp(tt, "ASDEFAULT"))
1070                                 iwp->iwp_ThumbnailView = THUMBNAILS_AsDefault;
1071                         }
1072                 d1(KPrintF("%s/%s/%ld: iwp->iwp_ThumbnailView=%lu\n", __FILE__, __FUNC__, __LINE__, iwp->iwp_ThumbnailView));
1073                 }
1074
1075         tt = NULL;
1076         if (DoMethod(IconObj, IDTM_FindToolType, "SCALOS_THUMBNAIL_LIFETIME", &tt))
1077                 {
1078                 DoMethod(IconObj, IDTM_GetToolTypeValue, tt, (ULONG *) &lDummy);
1079                 iwp->iwp_ThumbnailsLifetimeDays = lDummy;
1080                 }
1081
1082         iwp->iwp_NoStatusBar = FALSE;
1083         tt = NULL;
1084         if (DoMethod(IconObj, IDTM_FindToolType, "SCALOS_NOSTATUSBAR", &tt))
1085                 {
1086                 iwp->iwp_NoStatusBar = TRUE;
1087                 }
1088
1089         iwp->iwp_NoControlBar = FALSE;
1090         tt = NULL;
1091         if (DoMethod(IconObj, IDTM_FindToolType, "SCALOS_NOCONTROLBAR", &tt))
1092                 {
1093                 iwp->iwp_NoControlBar = TRUE;
1094                 }
1095
1096         iwp->iwp_BrowserMode = FALSE;
1097         tt = NULL;
1098         if (DoMethod(IconObj, IDTM_FindToolType, "SCALOS_BROWSERMODE", &tt))
1099                 {
1100                 iwp->iwp_BrowserMode = TRUE;
1101                 }
1102
1103         GetAttr(IDTA_WinCurrentX, IconObj, (ULONG *) &lDummy);
1104         iwp->iwp_XOffset = (WORD) lDummy;
1105
1106         GetAttr(IDTA_WinCurrentY, IconObj, (ULONG *) &lDummy);
1107         iwp->iwp_YOffset = (WORD) lDummy;
1108
1109         tt = NULL;
1110         if (DoMethod(IconObj, IDTM_FindToolType, "SCALOS_ACTIVETRANSPARENCY", &tt))
1111                 {
1112                 DoMethod(IconObj, IDTM_GetToolTypeValue, tt, (ULONG *) &lDummy);
1113                 iwp->iwp_OpacityActive = (UWORD) lDummy;
1114                 d1(KPrintF("%s/%s/%ld: iwp->iwp_OpacityActive=%lu\n", __FILE__, __FUNC__, __LINE__, iwp->iwp_OpacityActive));
1115                 }
1116
1117         tt = NULL;
1118         if (DoMethod(IconObj, IDTM_FindToolType, "SCALOS_INACTIVETRANSPARENCY", &tt))
1119                 {
1120                 DoMethod(IconObj, IDTM_GetToolTypeValue, tt, (ULONG *) &lDummy);
1121                 iwp->iwp_OpacityInactive = (UWORD) lDummy;
1122                 d1(KPrintF("%s/%s/%ld: iwp->iwp_OpacityInactive=%lu\n", __FILE__, __FUNC__, __LINE__, iwp->iwp_OpacityInactive));
1123                 }
1124
1125         tt = NULL;
1126         if (DoMethod(IconObj, IDTM_FindToolType, "SCALOS_ICONSCALEFACTOR", &tt))
1127                 {
1128                 DoMethod(IconObj, IDTM_GetToolTypeValue, tt, (ULONG *) &lDummy);
1129                 iwp->iwp_IconScaleFactor = lDummy;
1130
1131                 if (iwp->iwp_IconScaleFactor < IDTA_ScalePercentage_MIN)
1132                         iwp->iwp_IconScaleFactor = IDTA_ScalePercentage_MIN;
1133                 else if (iwp->iwp_IconScaleFactor > IDTA_ScalePercentage_MAX)
1134                         iwp->iwp_IconScaleFactor = IDTA_ScalePercentage_MAX;
1135
1136                 d1(KPrintF("%s/%s/%ld: iwp_IconScaleFactor=%lu\n", __FILE__, __FUNC__, __LINE__, iwp->iwp_IconScaleFactor));
1137                 }
1138
1139         tt = NULL;
1140         if (DoMethod(IconObj, IDTM_FindToolType, "SCALOS_ICONSIZECONSTRAINTS", &tt))
1141                 {
1142                 LONG IconSizeMin, IconSizeMax;
1143                 long long1, long2;
1144
1145                 d1(KPrintF("%s/%s/%ld: tt=<%s>\n", __FILE__, __FUNC__, __LINE__, tt));
1146                 while (*tt && '=' !=  *tt)
1147                         tt++;
1148
1149                 if (2 == sscanf(tt, "=%ld,%ld", &long1, &long2))
1150                         {
1151                         IconSizeMin = long1;
1152                         IconSizeMax = long2;
1153                         if ((IconSizeMax > 128) || (IconSizeMax < 0))
1154                                 IconSizeMax = SHRT_MAX;
1155                         if ((IconSizeMin < 0) || (IconSizeMin >= IconSizeMax))
1156                                 IconSizeMin = 0;
1157
1158                         iwp->iwp_IconSizeConstraints.MinX = iwp->iwp_IconSizeConstraints.MinY = IconSizeMin;
1159                         iwp->iwp_IconSizeConstraints.MaxX = iwp->iwp_IconSizeConstraints.MaxY = IconSizeMax;
1160                         }
1161                 d1(KPrintF("%s/%s/%ld: IconSizeMin=%ld  IconSizeMax=%ld\n", __FILE__, __FUNC__, __LINE__, IconSizeMin, IconSizeMax));
1162                 }
1163 }
1164
1165 // ----------------------------------------------------------
1166
1167