scalos/main/Class.c

   1 // Class.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 <intuition/newmouse.h>
  14 #include <workbench/workbench.h>
  15 #include <workbench/startup.h>
  16 #include <cybergraphx/cybergraphics.h>
  17 #include <dos/dostags.h>
  18 #include <dos/datetime.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/cybergraphics.h>
  28 #include <proto/utility.h>
  29 #include <proto/locale.h>
  30 #include <proto/iconobject.h>
  31 #include <proto/rexxsyslib.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/scalos.h>
  40 #include <scalos/GadgetBar.h>
  41
  42 #include <stdlib.h>
  43 #include <stdio.h>
  44 #include <string.h>
  45
  46 #include <DefIcons.h>
  47
  48 #include "scalos_structures.h"
  49 #include "functions.h"
  50 #include "Variables.h"
  51
  52 //----------------------------------------------------------------------------
  53
  54 // local data structures
  55
  56 struct ScaMakeWbArg
  57         {
  58         struct ScaIconNode *mwa_IconNode;
  59         struct WBArg *mwa_Buffer;
  60         };
  61
  62 struct FormatDateHookData
  63         {
  64         STRPTR fdhd_Buffer;             // buffer to write characters to
  65         size_t fdhd_Length;             // length of buffer
  66         };
  67
  68 //----------------------------------------------------------------------------
  69
  70 // local functions
  71
  72 static BOOL IsSameWindowIcon(struct internalScaWindowTask *iwtSrc,
  73         struct internalScaWindowTask *iwtDest, struct ScaIconNode *inDest);
  74 static SAVEDS(void) FormatDateHookFunc(struct Hook *theHook, struct Locale *locale, char ch);
  75 static BOOL isParentOf(BPTR srcDirLock, struct DragNode *dragList, BPTR dirLock, CONST_STRPTR objName);
  76 static BPTR LockIcon(BPTR dirLock, struct ScaIconNode *in);
  77 static void NotifyAppIconSelected(struct ScaWindowStruct *ws, Object *IconObj, BOOL Selected);
  78
  79 //----------------------------------------------------------------------------
  80
  81 // public data items :
  82
  83 //----------------------------------------------------------------------------
  84
  85 // iwt is Destination window
  86 // returns BOOL :
  87 //      TRUE    yes, we may drop here
  88 //      FALSE   no, no drop allowed
  89 ULONG ClassDragQuery(struct DragEnter *drge, struct internalScaWindowTask *iwt)
  90 {
  91         ULONG Result = TRUE;
  92         struct internalScaWindowTask *iwtSrc = (struct internalScaWindowTask *) drge->drage_Window->ws_WindowTask;
  93         struct DragNode *dn;
  94         BOOL SrcIsAppIcon = FALSE;
  95         BOOL SrcIsGarbage = FALSE;
  96         BOOL SrcIsKick = FALSE;
  97         BOOL SrcIsNoDrag = FALSE;
  98         BOOL SrcIsDiskOrDrawer = FALSE;
  99
 100         // Check for source icons which may not be dropped on any other icon
 101         for (dn = iwtSrc->iwt_DragNodeList; dn; dn = (struct DragNode *) dn->drgn_Node.mln_Succ)
 102                 {
 103                 IPTR SrcIconType;
 104                 STRPTR tt;
 105
 106                 GetAttr(IDTA_Type, dn->drgn_icon, &SrcIconType);
 107
 108                 tt = NULL;
 109                 if (DoMethod(dn->drgn_icon, IDTM_FindToolType, "SCALOS_NODRAG", &tt))
 110                         SrcIsNoDrag = TRUE;
 111
 112                 switch (SrcIconType)
 113                         {
 114                 case WBAPPICON:
 115                         SrcIsAppIcon = TRUE;
 116                         break;
 117                 case WBGARBAGE:
 118                         SrcIsGarbage = TRUE;
 119                         break;
 120                 case WBKICK:
 121                         SrcIsKick = TRUE;
 122                         break;
 123                 case WBDISK:
 124                 case WBDRAWER:
 125                 case WBDEVICE:
 126                 case WB_TEXTICON_DRAWER:
 127                         SrcIsDiskOrDrawer = TRUE;
 128                         break;
 129                         }
 130                 }
 131
 132         if (drge->drage_Window && iwt->iwt_WindowTask.mt_WindowStruct->ws_Lock)
 133                 {
 134                 // Device icons may not be copied into window on same volume
 135
 136                 d1(kprintf("%s/%s/%ld: \n", __FILE__, __FUNC__, __LINE__));
 137
 138                 for (dn = iwtSrc->iwt_DragNodeList; dn; dn = (struct DragNode *) dn->drgn_Node.mln_Succ)
 139                         {
 140                         d1(kprintf("%s/%s/%ld: icon=%08lx <%s>  Type=%ld  DeviceIcon=%08lx\n", \
 141                                 __FILE__, __FUNC__, __LINE__, drge->drage_Icon, drge->drage_Icon->in_Name, dn->drgn_iconnode->in_DeviceIcon));
 142
 143                         if (dn->drgn_iconnode->in_DeviceIcon)
 144                                 {
 145                                 BPTR devLock = (BPTR)NULL;
 146
 147                                 if (dn->drgn_iconnode->in_DeviceIcon->di_Volume)
 148                                         devLock = Lock(dn->drgn_iconnode->in_DeviceIcon->di_Volume, ACCESS_READ);
 149
 150                                 if ((BPTR)NULL == devLock && dn->drgn_iconnode->in_DeviceIcon->di_Device)
 151                                         devLock = Lock(dn->drgn_iconnode->in_DeviceIcon->di_Device, ACCESS_READ);
 152
 153                                 if (devLock)
 154                                         {
 155                                         LONG sameLockVal = ScaSameLock(iwt->iwt_WindowTask.mt_WindowStruct->ws_Lock, devLock);
 156
 157                                         debugLock_d1(devLock);
 158                                         debugLock_d1(iwt->iwt_WindowTask.mt_WindowStruct->ws_Lock);
 159                                         d1(kprintf("%s/%s/%ld: ScaSameLock()=%ld\n", __FILE__, __FUNC__, __LINE__, sameLockVal));
 160
 161                                         UnLock(devLock);
 162
 163                                         if (LOCK_SAME == sameLockVal)
 164                                                 return FALSE;
 165                                         if (LOCK_SAME_VOLUME == sameLockVal)
 166                                                 return FALSE;
 167                                         }
 168                                 }
 169                         }
 170
 171                 }
 172
 173         if (drge->drage_Icon)
 174                 {
 175                 BOOL SameWindow;
 176
 177                 // Kick, Garbage, AppIcons may not be dropped on other icons
 178                 if (SrcIsKick || SrcIsGarbage || SrcIsAppIcon)
 179                         return FALSE;
 180
 181                 if (drge->drage_Icon->in_Icon)
 182                         {
 183                         // query icon if we may drop here
 184                         IPTR DestIconType;
 185
 186                         GetAttr(IDTA_Type, drge->drage_Icon->in_Icon, &DestIconType);
 187
 188                         d1(KPrintF("%s/%s/%ld: icon=%08lx <%s>  Type=%ld\n", __FILE__, __FUNC__, __LINE__, drge->drage_Icon, drge->drage_Icon->in_Name, DestIconType));
 189
 190                         switch (DestIconType)
 191                                 {
 192                         case WBAPPICON:
 193                         case WBGARBAGE:
 194                                 Result = TRUE;
 195                                 break;
 196                         case WBTOOL:
 197                                 Result = CurrentPrefs.pref_DragStartFlag ? TRUE : FALSE;
 198                                 break;
 199                         case WBKICK:
 200                         case WBPROJECT:
 201                         case WB_TEXTICON_TOOL:
 202                                 Result = FALSE;
 203                                 break;
 204                         case WBDISK:
 205                         case WBDRAWER:
 206                         case WBDEVICE:
 207                         case WB_TEXTICON_DRAWER:
 208                                 SameWindow = IsSameWindowIcon(iwtSrc, iwt, drge->drage_Icon);
 209
 210                                 d1(KPrintF("%s/%s/%ld: SameWindow=%ld  SrcIsNoDrag=%ld\n", __FILE__, __FUNC__, __LINE__, SameWindow, SrcIsNoDrag));
 211                                 if (SameWindow && SrcIsNoDrag)
 212                                         {
 213                                         Result = FALSE;
 214                                         break;
 215                                         }
 216
 217                                 if (drge->drage_Icon->in_DeviceIcon)
 218                                         {
 219                                         if (!ClassCheckInfoData(drge->drage_Icon->in_DeviceIcon->di_Info))
 220                                                 Result = FALSE;
 221                                         }
 222                                 else
 223                                         {
 224                                         Result = !(drge->drage_Icon->in_Flags & INF_VolumeWriteProtected);
 225                                         }
 226
 227                                 if (SrcIsDiskOrDrawer && Result)
 228                                         {
 229                                         BPTR DestLock;
 230
 231                                         if (drge->drage_Icon->in_Lock)
 232                                                 DestLock = drge->drage_Icon->in_Lock;
 233                                         else
 234                                                 DestLock = iwt->iwt_WindowTask.mt_WindowStruct->ws_Lock;
 235
 236                                         d1(KPrintF("%s/%s/%ld: Result=%ld\n", __FILE__, __FUNC__, __LINE__, Result));
 237                                         Result = !isParentOf(iwtSrc->iwt_WindowTask.mt_WindowStruct->ws_Lock, iwtSrc->iwt_DragNodeList,
 238                                                 DestLock, GetIconName(drge->drage_Icon));
 239                                         d1(KPrintF("%s/%s/%ld: Result=%ld\n", __FILE__, __FUNC__, __LINE__, Result));
 240                                         }
 241                                 break;
 242                         default:
 243                                 Result = TRUE;
 244                                 break;
 245                                 }
 246                         }
 247
 248                 }
 249         else
 250                 {
 251                 // query window if we may drop here
 252
 253                 // AppIcons may not be dropped into different windows
 254                 if (SrcIsAppIcon && iwt != iwtSrc)
 255                         return FALSE;
 256
 257                 if (iwt == iwtSrc)
 258                         {
 259                         // drop in same window
 260                         if (SrcIsNoDrag)
 261                                 return FALSE;   // SCALOS_NODRAG icons must not be dropped in same window
 262
 263                         return TRUE;    // always may drop in same window (no move/copy)
 264                         }
 265
 266                 if ((BPTR)NULL == iwt->iwt_WindowTask.mt_WindowStruct->ws_Lock && SrcIsNoDrag)
 267                         return FALSE;           // SCALOS_NODRAG icons must not be dropped in desktop window
 268
 269                 if (SrcIsDiskOrDrawer)
 270                         {
 271                         if (isParentOf(iwtSrc->iwt_WindowTask.mt_WindowStruct->ws_Lock, iwtSrc->iwt_DragNodeList,
 272                                         iwt->iwt_WindowTask.mt_WindowStruct->ws_Lock, NULL))
 273                                 {
 274                                 return FALSE;
 275                                 }
 276                         }
 277
 278                 Result = ClassIsDiskWritable(iwt->iwt_WindowTask.mt_WindowStruct->ws_Lock);
 279                 }
 280
 281         return Result;
 282 }
 283
 284
 285 // return TRUE if Disk is writable
 286 ULONG ClassCheckInfoData(const struct InfoData *info)
 287 {
 288         ULONG Result = TRUE;
 289
 290         d1(kprintf("%s/%s/%ld: DiskType=%ld  DiskState=%ld\n", __FILE__, __FUNC__, __LINE__, info->id_DiskType, info->id_DiskState));
 291
 292         switch (info->id_DiskType)
 293                 {
 294         case ID_NO_DISK_PRESENT:
 295         case ID_UNREADABLE_DISK:
 296         case ID_NOT_REALLY_DOS:
 297                 Result = FALSE;
 298                 break;
 299                 }
 300
 301         if (ID_WRITE_PROTECTED == info->id_DiskState)
 302                 Result = FALSE;
 303
 304         return Result;
 305 }
 306
 307
 308 // Note: it is VERY IMPORTANT that for every call to ClassDragEnter() (icon or window) you execute
 309 // a corresponding ClassDragLeave() (icon or window) call !!!
 310 ULONG ClassDragEnter(struct DragEnter *drge, struct internalScaWindowTask *iwtDest)
 311 {
 312         struct internalScaWindowTask *iwtSrc = (struct internalScaWindowTask *) drge->drage_Window->ws_WindowTask;
 313         struct DragHandle *dh = iwtSrc->iwt_myDragHandle;
 314         ULONG WasLocked;
 315
 316         // iwtDest : Window dragged into
 317         // iwtSrc : Window dragged from (where dragging started)
 318
 319         d1(kprintf("%s/%s/%ld: Started. \n", __FILE__, __FUNC__, __LINE__));
 320
 321         d1(kprintf("%s/%s/%ld: iwtDest=%08lx  icon=%08lx\n", __FILE__, __FUNC__, __LINE__, iwtDest, drge->drage_Icon));
 322
 323         if (dh)
 324                 ClassHideDragBobs(iwtDest, dh);
 325
 326         WasLocked = SCA_UnlockDrag(dh);
 327
 328         if (drge->drage_Icon)
 329                 {
 330                 // Pointer entered Icon area
 331                 // and left window area
 332
 333                 d1(kprintf("%s/%s/%ld: \n", __FILE__, __FUNC__, __LINE__));
 334
 335                 if (iwtSrc->iwt_DragMayDrop)
 336                         {
 337                         IPTR IconType;
 338
 339                         d1(kprintf("%s/%s/%ld: icon=%08lx <%s>  Type=%ld\n", __FILE__, __FUNC__, __LINE__, drge->drage_Icon, drge->drage_Icon->in_Name));
 340
 341                         ClassSelectIcon(iwtDest->iwt_WindowTask.mt_WindowStruct, drge->drage_Icon, TRUE);
 342
 343                         d1(kprintf("%s/%s/%ld: \n", __FILE__, __FUNC__, __LINE__));
 344
 345                         GetAttr(IDTA_Type, drge->drage_Icon->in_Icon, &IconType);
 346                         switch (IconType)
 347                                 {
 348                         case WBDRAWER:
 349                         case WBDISK:
 350                         case WBGARBAGE:
 351                         case WB_TEXTICON_DRAWER:
 352                                 DoMethod(iwtSrc->iwt_WindowTask.mt_MainObject,
 353                                         SCCM_IconWin_StartPopOpenTimer,
 354                                         iwtDest,
 355                                         dh, drge->drage_Icon);
 356                                 break;
 357                         default:
 358                                 break;
 359                                 }
 360
 361                         d1(kprintf("%s/%s/%ld: \n", __FILE__, __FUNC__, __LINE__));
 362
 363                         DisplayIconDropMark(iwtDest, drge->drage_Icon);
 364                         }
 365
 366                 d1(kprintf("%s/%s/%ld: \n", __FILE__, __FUNC__, __LINE__));
 367                 }
 368         else
 369                 {
 370
 371                 d1(kprintf("%s/%s/%ld: DisplayWindowDropMark(%s) \n", __FILE__, __FUNC__, __LINE__,  iwtDest->iwt_WinTitle));
 372
 373                 DisplayWindowDropMark(iwtDest);
 374
 375                 DoMethod(iwtDest->iwt_WindowTask.mt_WindowObject, SCCM_Window_LockUpdate, TRUE);
 376                 }
 377
 378         d1(kprintf("%s/%s/%ld: \n", __FILE__, __FUNC__, __LINE__));
 379
 380         ReLockDrag(dh, iwtSrc, WasLocked);
 381
 382         d1(kprintf("%s/%s/%ld: Finished. \n", __FILE__, __FUNC__, __LINE__));
 383
 384         return 0;
 385 }
 386
 387
 388 // Note: it is VERY IMPORTANT that for every call to ClassDragEnter() (icon or window) you execute
 389 // a corresponding ClassDragLeave() (icon or window) call !!!
 390 ULONG ClassDragLeave(struct DragEnter *drge, struct internalScaWindowTask *iwtDest)
 391 {
 392         struct internalScaWindowTask *iwtSrc = (struct internalScaWindowTask *) drge->drage_Window->ws_WindowTask;
 393         struct DragHandle *dh = iwtSrc->iwt_myDragHandle;
 394         ULONG WasLocked;
 395
 396         // iwtDest : Window dragged into
 397         // iwtSrc : Window dragged from (where dragging started)
 398
 399         d1(kprintf("%s/%s/%ld: Started. \n", __FILE__, __FUNC__, __LINE__));
 400         d1(kprintf("%s/%s/%ld: iwtDest=%08lx  title=<%s> icon=%08lx\n", __FILE__, __FUNC__, __LINE__, iwtDest, iwtDest->iwt_WinTitle, drge->drage_Icon));
 401
 402         if (dh)
 403                 ClassHideDragBobs(iwtDest, dh);
 404
 405         d1(kprintf("%s/%s/%ld: \n", __FILE__, __FUNC__, __LINE__));
 406
 407         WasLocked = SCA_UnlockDrag(dh);
 408
 409         d1(kprintf("%s/%s/%ld: \n", __FILE__, __FUNC__, __LINE__));
 410
 411         DoMethod(iwtSrc->iwt_WindowTask.mt_MainObject, SCCM_IconWin_StopPopOpenTimer, dh);
 412
 413         if (drge->drage_Icon)
 414                 {
 415                 // pointer left icon area
 416                 // and is back in window area
 417                 struct Gadget *gg = (struct Gadget *) drge->drage_Icon->in_Icon;
 418
 419                 if (gg->Flags & GFLG_SELECTED)
 420                         {
 421                         // remove icon drop mark
 422                         d1(kprintf("%s/%s/%ld: icon=%08lx <%s>  Type=%ld\n", __FILE__, __FUNC__, __LINE__, drge->drage_Icon, drge->drage_Icon->in_Name));
 423
 424                         EraseIconDropMark(iwtDest, drge->drage_Icon);
 425                         ClassSelectIcon(iwtDest->iwt_WindowTask.mt_WindowStruct, drge->drage_Icon, FALSE);
 426                         }
 427                 }
 428         else
 429                 {
 430                 // Pointer left window area
 431                 d1(kprintf("%s/%s/%ld: CALL EraseWindowDropMark(%s)\n", __FILE__, __FUNC__, __LINE__ , iwtDest->iwt_WinTitle));
 432
 433                 iwtDest->iwt_DragScrollX = iwtDest->iwt_DragScrollY = 0;
 434
 435                 EraseWindowDropMark(iwtDest);
 436
 437                 DoMethod(iwtDest->iwt_WindowTask.mt_WindowObject, SCCM_Window_UnlockUpdate);
 438                 }
 439
 440         d1(kprintf("%s/%s/%ld: \n", __FILE__, __FUNC__, __LINE__));
 441
 442         ReLockDrag(dh, iwtSrc, WasLocked);
 443
 444         d1(kprintf("%s/%s/%ld: Finished. \n", __FILE__, __FUNC__, __LINE__));
 445
 446         return 0;
 447 }
 448
 449
 450 void ClassHideDragBobs(struct internalScaWindowTask *iwt, struct DragHandle *dh)
 451 {
 452         SCA_DrawDrag(dh, iwt->iwt_WinScreen->Width + 400, 0, SCAF_Drag_Hide);
 453 }
 454
 455
 456 void ClassSelectIcon(struct ScaWindowStruct *swi, struct ScaIconNode *sIcon, BOOL Selected)
 457 {
 458         d1(kprintf("%s/%s/%ld: swi=%08lx  sIcon=%08lx  Selected=%ld\n", __FILE__, __FUNC__, __LINE__, swi, sIcon, Selected);)
 459
 460         ClassSelectIconObj(swi, sIcon->in_Icon, Selected);
 461 }
 462
 463
 464 void ClassSelectIconObj(struct ScaWindowStruct *swi, Object *IconObj, BOOL Selected)
 465 {
 466         struct ExtGadget *gg = (struct ExtGadget *) IconObj;
 467
 468         d1(KPrintF("%s/%s/%ld: swi=%08lx  IconObj=%08lx  Selected=%ld\n", __FILE__, __FUNC__, __LINE__, swi, IconObj, Selected);)
 469
 470         if ( (!Selected && (gg->Flags & GFLG_SELECTED)) || (Selected && !(gg->Flags & GFLG_SELECTED)))
 471                 {
 472                 struct Window *win = swi->ws_Window;
 473
 474                 SetAttrs(IconObj,
 475                         GA_Selected, Selected,
 476                         TAG_END);
 477
 478                 if (Selected)
 479                         {
 480                         if (NULL == gg->SelectRender)
 481                                 {
 482                                 DoMethod(swi->ws_WindowTask->mt_MainObject,
 483                                         SCCM_IconWin_LayoutIcon, IconObj,
 484                                         IOLAYOUTF_SelectedImage, 0);
 485                                 }
 486                         }
 487                 else
 488                         {
 489                         if (NULL == gg->GadgetRender)
 490                                 {
 491                                 DoMethod(swi->ws_WindowTask->mt_MainObject,
 492                                         SCCM_IconWin_LayoutIcon, IconObj,
 493                                         IOLAYOUTF_NormalImage);
 494                                 }
 495                         }
 496
 497                 if (win)
 498                         {
 499                         struct internalScaWindowTask *iwt = (struct internalScaWindowTask *) swi->ws_WindowTask;
 500
 501                         d1(KPrintF("%s/%s/%ld:\n", __FILE__, __FUNC__, __LINE__));
 502
 503                         DoMethod(swi->ws_WindowTask->mt_MainObject,
 504                                 SCCM_IconWin_DrawIcon, IconObj);
 505
 506                         if (iwt->iwt_DragFlags & DRAGFLAGF_WindowMarked)
 507                                 {
 508                                 // Restore the part of the Window drop mark
 509                                 // that has been destroyed by the icon redraw
 510                                 struct Region *iconRegion;
 511
 512                                 iconRegion = NewRegion();
 513                                 d1(kprintf("Restore the part of the Window drop mark\nthat has been destroyed by the icon redraw: \n"));
 514                                 d1(kprintf("%s/%s/%ld: iconRegion=%08lx\n", __FILE__, __FUNC__, __LINE__, iconRegion));
 515                                 if (iconRegion)
 516                                         {
 517                                         struct Rectangle IconRect;
 518
 519                                         IconRect.MinX = IconRect.MaxX = gg->BoundsLeftEdge - iwt->iwt_WindowTask.wt_XOffset + iwt->iwt_InnerLeft;
 520                                         IconRect.MinY = IconRect.MaxY = gg->BoundsTopEdge - iwt->iwt_WindowTask.wt_YOffset + iwt->iwt_InnerTop;
 521                                         IconRect.MaxX += gg->BoundsWidth - 1;
 522                                         IconRect.MaxY += gg->BoundsHeight - 1;
 523
 524                                         d1(kprintf("%s/%s/%ld: MinX=%ld  MinY=%ld  MaxX=%ld  MaxY=%ld\n", \
 525                                                 __FILE__, __FUNC__, __LINE__, IconRect.MinX, IconRect.MinY, IconRect.MaxX, IconRect.MaxY));
 526
 527                                         OrRectRegion(iconRegion, &IconRect);
 528
 529                                         d1(kprintf("%s/%s/%ld: CALL  DrawWindowDropMark(iwt, iconRegion)\n"));
 530                                         RedrawWindowDropMark(iwt, iconRegion);
 531
 532                                         DisposeRegion(iconRegion);
 533                                         }
 534                                 }
 535                         }
 536
 537                 NotifyAppIconSelected(swi, IconObj, Selected);
 538                 }
 539 }
 540
 541
 542 BOOL ClassIsDiskWritable(BPTR dLock)
 543 {
 544         struct InfoData *info = ScalosAllocInfoData();
 545         BOOL Result = TRUE;
 546
 547         if (info)
 548                 {
 549                 Info(dLock, info);
 550
 551                 if (!ClassCheckInfoData(info))
 552                         Result = FALSE;
 553
 554                 ScalosFreeInfoData(&info);
 555                 }
 556
 557         return Result;
 558 }
 559
 560
 561 ULONG ClassWinTimerMsg(struct internalScaWindowTask *iwt, struct Message *Msg, APTR p)
 562 {
 563         d1(KPrintF("%s/%s/%ld: START iwt=%08lx  <%s>  MoveGadId=%ld  ws_Flags=%04lx\n", __FILE__, __FUNC__, __LINE__, \
 564                 iwt, iwt->iwt_WinTitle, iwt->iwt_MoveGadId, iwt->iwt_WindowTask.mt_WindowStruct->ws_Flags));
 565
 566         if (iwt->iwt_LockFlag)
 567                 {
 568                 struct SM_Timer *smtm = (struct SM_Timer *) Msg;
 569                 ULONG Seconds, Micros;
 570
 571                 if (smtm->smtm_Time.tv_secs >= iwt->iwt_LockCount.tv_secs)
 572                         Seconds = smtm->smtm_Time.tv_secs - iwt->iwt_LockCount.tv_secs;
 573                 else
 574                         Seconds = 0;
 575
 576                 if (smtm->smtm_Time.tv_micro >= iwt->iwt_LockCount.tv_micro)
 577                         Micros = smtm->smtm_Time.tv_micro - iwt->iwt_LockCount.tv_micro;
 578                 else
 579                         Micros = 0;
 580
 581                 d1(kprintf("%s/%s/%ld: iwt_LockCount: Seconds=%lu  Micros=%lu\n", __FILE__, __FUNC__, __LINE__, \
 582                         iwt->iwt_LockCount.tv_secs, iwt->iwt_LockCount.tv_micro));
 583                 d1(kprintf("%s/%s/%ld: Seconds=%lu  Micros=%lu\n", __FILE__, __FUNC__, __LINE__, Seconds, Micros));
 584
 585                 if (Micros > 500000)
 586                         Seconds++;
 587
 588                 if (Seconds >= 2)
 589                         {
 590                         d1(kprintf("%s/%s/%ld: try to AbortFunctions() \n", __FILE__, __FUNC__, __LINE__));
 591
 592                         AbortFunctions(iwt);
 593
 594                         if (iwt->iwt_WindowTask.wt_Window)
 595                                 ModifyIDCMP(iwt->iwt_WindowTask.wt_Window, iwt->iwt_IDCMPFlags);
 596
 597                         if (!iwt->iwt_NeedsTimerFlag && !(iwt->iwt_WindowTask.mt_WindowStruct->ws_Flags & (WSV_FlagF_CheckUpdatePending | WSV_FlagF_Typing)))
 598                                 iwt->iwt_WindowTask.mt_WindowStruct->ws_Flags &= ~WSV_FlagF_NeedsTimerMsg;
 599                         }
 600                 }
 601
 602         if (!iwt->iwt_LockFlag)
 603                 {
 604                 DoMethod(iwt->iwt_WindowTask.mt_MainObject, SCCM_Ping);
 605                 d1(KPrintF("%s/%s/%ld:  DOMETHOD mt_MainObject [SCCM_Ping]\n", __FILE__, __FUNC__, __LINE__));
 606                 DoMethod(iwt->iwt_WindowTask.mt_WindowObject, SCCM_Ping);
 607                 d1(KPrintF("%s/%s/%ld:  DOMETHOD mt_WindowObject [SCCM_Ping]\n", __FILE__, __FUNC__, __LINE__));
 608                 }
 609
 610         d1(kprintf("%s/%s/%ld: Finished \n", __FILE__, __FUNC__, __LINE__));
 611
 612         return 0;
 613 }
 614
 615
 616 void ClassTimerToolTipMsg(struct internalScaWindowTask *iwt)
 617 {
 618         struct ScaIconNode *iconUnderPointer;
 619         struct internalScaWindowTask *iwtUnderPointer;
 620         struct internalScaWindowTask *iwtActiveWindow = NULL;
 621         struct Window *foreignWindow;
 622         struct ScaWindowStruct *ws;
 623         BOOL LockFlag = FALSE;
 624
 625         d1(kprintf("%s/%s/%ld: \n", __FILE__, __FUNC__, __LINE__));
 626
 627         SCA_LockWindowList(SCA_LockWindowList_Shared);
 628
 629         for (ws=winlist.wl_WindowStruct; ws; ws = (struct ScaWindowStruct *) ws->ws_Node.mln_Succ)
 630                 {
 631                 struct internalScaWindowTask *iwtx = (struct internalScaWindowTask *) ws->ws_WindowTask;
 632
 633                 if (iwtx->iwt_LockFlag)
 634                         LockFlag = TRUE;
 635
 636                 if (ws->ws_Window && ws->ws_Window->Flags & WFLG_WINDOWACTIVE)
 637                         {
 638                         iwtActiveWindow = (struct internalScaWindowTask *) ws->ws_WindowTask;
 639                         break;
 640                         }
 641                 }
 642
 643         SCA_UnLockWindowList();
 644
 645         d1(kprintf("%s/%s/%ld: iwtActiveWindow=%08lx \n", __FILE__, __FUNC__, __LINE__, iwtActiveWindow));
 646
 647         if (NULL == iwtActiveWindow)
 648                 {
 649                 // return if no Scalos window active
 650                 MainWindowTask->miwt_IconUnderPtrCount = 0;
 651                 MainWindowTask->miwt_LastIconUnderPtr = NULL;
 652                 MainWindowTask->miwt_LastGadgetUnderPtr = SGTT_GADGETID_unknown;
 653
 654                 return;
 655                 }
 656
 657         d1(kprintf("%s/%s/%ld: \n", __FILE__, __FUNC__, __LINE__));
 658
 659         if (!LockFlag)
 660                 {
 661                 enum sgttGadgetIDs gadgetUnderPointer = iInfos.xii_GlobalGadgetUnderPointer.ggd_GadgetID;
 662
 663                 QueryObjectUnderPointer(&iwtUnderPointer, &iconUnderPointer, NULL, &foreignWindow);
 664
 665                 d1(KPrintF("%s/%s/%ld: iconUnderPointer=%08lx\n", __FILE__, __FUNC__, __LINE__, iconUnderPointer));
 666                 d1(KPrintF("%s/%s/%ld: gadgetUnderPointer=%ld\n", __FILE__, __FUNC__, __LINE__, gadgetUnderPointer));
 667
 668                 if (iwtUnderPointer != iInfos.xii_GlobalGadgetUnderPointer.ggd_iwt)
 669                         gadgetUnderPointer = SGTT_GADGETID_unknown;
 670
 671                 d1(KPrintF("%s/%s/%ld: gadgetUnderPointer=%ld\n", __FILE__, __FUNC__, __LINE__, gadgetUnderPointer));
 672
 673                 if ((SGTT_GADGETID_unknown == MainWindowTask->miwt_LastGadgetUnderPtr
 674                          || gadgetUnderPointer != MainWindowTask->miwt_LastGadgetUnderPtr)
 675                         &&
 676                         (NULL == iconUnderPointer ||
 677                                 iconUnderPointer != MainWindowTask->miwt_LastIconUnderPtr))
 678                         {
 679                         d1(KPrintF("%s/%s/%ld: \n", __FILE__, __FUNC__, __LINE__));
 680
 681                         MainWindowTask->miwt_IconUnderPtrCount = 0;
 682                         MainWindowTask->miwt_LastIconUnderPtr = iconUnderPointer;
 683                         MainWindowTask->miwt_LastGadgetUnderPtr = gadgetUnderPointer;
 684                         }
 685                 else
 686                         {
 687                         d1(KPrintF("%s/%s/%ld: iwt_IconUnderPtrCount=%ld\n", __FILE__, __FUNC__, __LINE__, MainWindowTask->miwt_IconUnderPtrCount));
 688
 689                         if (NULL == iwtUnderPointer || VGADGETID_IDLE != iwtActiveWindow->iwt_MoveGadId)
 690                                 {
 691                                 d1(KPrintF("%s/%s/%ld: \n", __FILE__, __FUNC__, __LINE__));
 692
 693                                 MainWindowTask->miwt_IconUnderPtrCount = 0;
 694                                 MainWindowTask->miwt_LastIconUnderPtr = NULL;
 695                                 MainWindowTask->miwt_LastGadgetUnderPtr = SGTT_GADGETID_unknown;
 696                                 }
 697                         else
 698                                 {
 699                                 if (++MainWindowTask->miwt_IconUnderPtrCount == CurrentPrefs.pref_ToolTipDelaySeconds)
 700                                         {
 701                                         d1(KPrintF("%s/%s/%ld: \n", __FILE__, __FUNC__, __LINE__));
 702
 703                                         if (iconUnderPointer)
 704                                                 {
 705                                                 d1(KPrintF("%s/%s/%ld: iconUnderPointer=%08lx  <%s>\n", \
 706                                                         __FILE__, __FUNC__, __LINE__, iconUnderPointer, iconUnderPointer->in_Name));
 707
 708                                                 DoMethod(iwtUnderPointer->iwt_WindowTask.mt_MainObject,
 709                                                         SCCM_IconWin_ShowIconToolTip, iconUnderPointer);
 710                                                 }
 711                                         else if (SGTT_GADGETID_unknown != gadgetUnderPointer)
 712                                                 {
 713                                                 d1(KPrintF("%s/%s/%ld: gadgetUnderPointer=%08lx\n", \
 714                                                         __FILE__, __FUNC__, __LINE__, gadgetUnderPointer));
 715
 716                                                 DoMethod(iwtUnderPointer->iwt_WindowTask.mt_MainObject,
 717                                                         SCCM_IconWin_ShowGadgetToolTip, gadgetUnderPointer);
 718                                                 }
 719                                         }
 720                                 }
 721                         }
 722
 723
 724                 if (iwtUnderPointer)
 725                         {
 726                         if (iconUnderPointer)
 727                                 ScalosUnLockIconList(iwtUnderPointer);
 728                         SCA_UnLockWindowList();
 729                         }
 730                 }
 731 }
 732
 733
 734 // Check if <inDest> is the disk/drawer icon for <inDest>
 735 static BOOL IsSameWindowIcon(struct internalScaWindowTask *iwtSrc,
 736         struct internalScaWindowTask *iwtDest, struct ScaIconNode *inDest)
 737 {
 738         BPTR iLock = (BPTR)NULL;
 739         BOOL SameWindow = FALSE;
 740
 741         d1(KPrintF("%s/%s/%ld: iwtSrc=%08lx  iwtDest=%08lx  inDest=%08lx\n", \
 742                 __FILE__, __FUNC__, __LINE__, iwtSrc, iwtDest, inDest));
 743
 744         if (inDest->in_DeviceIcon)
 745                 {
 746                 if (inDest->in_DeviceIcon->di_Volume)
 747                         iLock = Lock(inDest->in_DeviceIcon->di_Volume, ACCESS_READ);
 748                 }
 749         else
 750                 {
 751                 BPTR oldDir;
 752
 753                 if (inDest->in_Lock)
 754                         {
 755                         // backdrop icon on desktop
 756                         oldDir = CurrentDir(inDest->in_Lock);
 757                         }
 758                 else
 759                         {
 760                         oldDir = CurrentDir(iwtDest->iwt_WindowTask.mt_WindowStruct->ws_Lock);
 761                         }
 762
 763                 iLock = Lock(inDest->in_Name, ACCESS_READ);
 764
 765                 CurrentDir(oldDir);
 766                 }
 767
 768         if (iLock)
 769                 {
 770                 debugLock_d1(iLock);
 771                 debugLock_d1(iwtSrc->iwt_WindowTask.mt_WindowStruct->ws_Lock);
 772
 773                 SameWindow = LOCK_SAME == ScaSameLock(iwtSrc->iwt_WindowTask.mt_WindowStruct->ws_Lock, iLock);
 774                 UnLock(iLock);
 775                 }
 776
 777         return SameWindow;
 778 }
 779
 780
 781 // find corresponding (parent) icon for given Scalos window
 782 Object *ClassGetWindowIconObject(struct internalScaWindowTask *iwt, Object **allocIconObj)
 783 {
 784         struct ScaWindowStruct *ws = iwt->iwt_WindowTask.mt_WindowStruct;
 785         Object *IconObj = NULL;
 786         LONG DirEntryType;
 787         BPTR parentLock;
 788         BPTR oldDir = NOT_A_LOCK;
 789         CONST_STRPTR iconName;
 790
 791         do      {
 792                 if (ws->ws_Flags & WSV_FlagF_RootWindow)
 793                         {
 794                         parentLock = DupLock(ws->ws_Lock);
 795
 796                         iconName = "disk";
 797                         DirEntryType = ST_ROOT;
 798
 799                         // first look in main window's device icon list
 800                         if (parentLock)
 801                                 {
 802                                 struct internalScaWindowTask *iwtMain = (struct internalScaWindowTask *) iInfos.xii_iinfos.ii_MainWindowStruct->ws_WindowTask;
 803                                 struct ScaDeviceIcon *sdi;
 804                                 struct FileLock *fLock = BADDR(parentLock);
 805
 806                                 for (sdi=iwtMain->iwt_DevIconList; sdi; sdi = (struct ScaDeviceIcon *) sdi->di_Node.mln_Succ)
 807                                         {
 808                                         if (sdi->di_Handler == fLock->fl_Task)
 809                                                 {
 810                                                 d1(kprintf("%s/%s/%ld: sdi=%08lx  Icon=%08lx\n", __FILE__, __FUNC__, __LINE__, sdi, sdi->di_Icon));
 811                                                 IconObj = sdi->di_Icon;
 812                                                 }
 813                                         }
 814                                 }
 815                         }
 816                 else
 817                         {
 818                         parentLock = ParentDir(ws->ws_Lock);
 819
 820                         iconName = ws->ws_Name;
 821                         DirEntryType = ST_USERDIR;
 822                         }
 823
 824                 if ((BPTR)NULL == parentLock)
 825                         break;
 826
 827                 oldDir = CurrentDir(parentLock);
 828
 829                 if (NULL == IconObj)
 830                         IconObj = *allocIconObj = NewIconObject(iconName, NULL);
 831
 832                 d1(kprintf("%s/%s/%ld: iconName=<%s>  IconObj=%08lx\n", __FILE__, __FUNC__, __LINE__, iconName, IconObj));
 833                 if (NULL == IconObj)
 834                         {
 835                         ULONG Protection = 0L;
 836                         STRPTR IconPath;
 837
 838                         do      {
 839                                 IconPath = AllocPathBuffer();
 840                                 if (NULL == IconPath)
 841                                         break;
 842
 843                                 if (!NameFromLock(parentLock, IconPath, Max_PathLen-1))
 844                                         break;
 845
 846                                 if (!AddPart(IconPath, iconName, Max_PathLen-1))
 847                                         break;
 848
 849                                 IconObj = *allocIconObj = (Object *) DoMethod(iwt->iwt_WindowTask.mt_MainObject, SCCM_IconWin_GetDefIcon,
 850                                         IconPath, DirEntryType, Protection, ICONTYPE_NONE);
 851                                 } while (0);
 852
 853                         if (IconPath)
 854                                 FreePathBuffer(IconPath);
 855                         }
 856                 } while (0);
 857
 858         if (IS_VALID_LOCK(oldDir))
 859                 CurrentDir(oldDir);
 860         if (parentLock)
 861                 UnLock(parentLock);
 862
 863         return IconObj;
 864 }
 865
 866
 867 void ClassFormatDate(struct DateTime *dt, ULONG DateMaxLen, ULONG TimeMaxLen)
 868 {
 869         if (ScalosLocale)
 870                 {
 871                 struct FormatDateHookData fd;
 872                 struct Hook fmtHook;
 873
 874                 d1(kprintf("%s/%s/%ld: DateBuff=%08lx Len=%ld  TimeBuff=%08lx Len=%ld\n", \
 875                         __FILE__, __FUNC__, __LINE__, dt->dat_StrDate, DateMaxLen, dt->dat_StrTime, DateMaxLen));
 876
 877                 SETHOOKFUNC(fmtHook, FormatDateHookFunc);
 878                 fmtHook.h_Data = &fd;
 879
 880                 fd.fdhd_Buffer = dt->dat_StrDate;
 881                 fd.fdhd_Length = DateMaxLen;
 882
 883                 FormatDate(ScalosLocale, ScalosLocale->loc_ShortDateFormat,
 884                         &dt->dat_Stamp, &fmtHook);
 885
 886                 fd.fdhd_Buffer = dt->dat_StrTime;
 887                 fd.fdhd_Length = TimeMaxLen;
 888
 889                 FormatDate(ScalosLocale, ScalosLocale->loc_ShortTimeFormat,
 890                         &dt->dat_Stamp, &fmtHook);
 891                 }
 892         else
 893                 {
 894                 DateToStr(dt);          // no size checking possible here :(
 895                 }
 896 }
 897
 898
 899 static SAVEDS(void) FormatDateHookFunc(struct Hook *theHook, struct Locale *locale, char ch)
 900 {
 901         struct FormatDateHookData *fd = (struct FormatDateHookData *) theHook->h_Data;
 902
 903         (void) locale;
 904
 905         if (fd->fdhd_Length >= 1)
 906                 {
 907                 *(fd->fdhd_Buffer)++ = ch;
 908                 fd->fdhd_Length--;
 909                 }
 910 }
 911
 912
 913 // forbid drag-copying or -moving icon into own sibling window or on sibling icon
 914 // to avoid errors or endless recursion
 915 static BOOL isParentOf(BPTR srcDirLock, struct DragNode *dragList, BPTR dirLock, CONST_STRPTR objName)
 916 {
 917         BPTR destLock;
 918         BOOL isParent = FALSE;
 919         BPTR oldDir;
 920
 921         d1(kprintf("%s/%s/%ld: objName=%08lx  <%s>\n", __FILE__, __FUNC__, __LINE__, objName, objName ? objName : ""));
 922
 923         if (objName)
 924                 {
 925                 BPTR oldDir = CurrentDir(dirLock);
 926
 927                 destLock = Lock((STRPTR) objName, ACCESS_READ);
 928
 929                 CurrentDir(oldDir);
 930                 }
 931         else
 932                 destLock = DupLock(dirLock);
 933
 934         debugLock_d1(destLock);
 935
 936         if ((BPTR)NULL == destLock)
 937                 return FALSE;
 938
 939         oldDir = CurrentDir(srcDirLock);
 940
 941         while (dragList && !isParent)
 942                 {
 943                 BPTR srcLock;
 944
 945                 srcLock = LockIcon(srcDirLock, dragList->drgn_iconnode);
 946
 947                 debugLock_d1(srcLock);
 948                 if (srcLock)
 949                         {
 950                         BPTR prevLock = (BPTR)NULL;
 951                         BPTR parentLock;
 952
 953                         switch (ScaSameLock(srcLock, destLock))
 954                                 {
 955                         case LOCK_SAME:
 956                                 return isParent = TRUE;
 957
 958                         case LOCK_SAME_VOLUME:
 959                                 parentLock = destLock;
 960                                 do      {
 961                                         parentLock = ParentDir(parentLock);
 962                                         if (prevLock)
 963                                                 UnLock(prevLock);
 964
 965                                         debugLock_d1(parentLock);
 966
 967                                         if (LOCK_SAME == ScaSameLock(srcLock, parentLock))
 968                                                 isParent = TRUE;
 969
 970                                         d1(kprintf("%s/%s/%ld: isParent=%ld\n", __FILE__, __FUNC__, __LINE__, isParent));
 971
 972                                         prevLock = parentLock;
 973                                         } while (parentLock && !isParent);
 974
 975                                 if (prevLock)
 976                                         UnLock(prevLock);
 977                                 break;
 978
 979                         default:
 980                                 break;
 981                                 }
 982                         UnLock(srcLock);
 983                         }
 984                 dragList = (struct DragNode *) dragList->drgn_Node.mln_Succ;
 985                 }
 986
 987         CurrentDir(oldDir);
 988         UnLock(destLock);
 989
 990         d1(kprintf("%s/%s/%ld: isParent=%ld\n", __FILE__, __FUNC__, __LINE__, isParent));
 991
 992         return isParent;
 993 }
 994
 995
 996 static BPTR LockIcon(BPTR dirLock, struct ScaIconNode *in)
 997 {
 998         BPTR lock;
 999         BPTR oldDir;
1000
1001         if (in->in_Lock)
1002                 oldDir = CurrentDir(in->in_Lock);
1003         else
1004                 {
1005                 if (in->in_DeviceIcon)
1006                         return DiskInfoLock(in);
1007                 else
1008                         oldDir = CurrentDir(dirLock);
1009                 }
1010
1011         lock = Lock((STRPTR) GetIconName(in), ACCESS_READ);
1012
1013         if (IS_VALID_LOCK(oldDir))
1014                 CurrentDir(oldDir);
1015
1016         return lock;
1017 }
1018
1019
1020 ULONG ClassCountSelectedIcons(struct internalScaWindowTask *iwt)
1021 {
1022         struct ScaIconNode *in;
1023         ULONG Count = 0;
1024
1025         ScalosLockIconListShared(iwt);
1026
1027         for (in=iwt->iwt_WindowTask.wt_IconList; in; in = (struct ScaIconNode *) in->in_Node.mln_Succ)
1028                 {
1029                 struct Gadget *gg = (struct Gadget *) in->in_Icon;
1030
1031                 if (gg->Flags & GFLG_SELECTED)
1032                         Count++;
1033                 }
1034
1035         ScalosUnLockIconList(iwt);
1036
1037         return Count;
1038 }
1039
1040
1041 static void NotifyAppIconSelected(struct ScaWindowStruct *ws, Object *IconObj, BOOL Selected)
1042 {
1043         struct internalScaWindowTask *iwt = (struct internalScaWindowTask *) ws->ws_WindowTask;
1044         IPTR IconType;
1045         struct AppObject *appo;
1046
1047         if (ws != iInfos.xii_iinfos.ii_MainWindowStruct)
1048                 return;
1049
1050         GetAttr(IDTA_Type, IconObj, &IconType);
1051         if (WBAPPICON != IconType)
1052                 return;
1053
1054         ScalosObtainSemaphoreShared(iwt->iwt_AppListSemaphore);
1055
1056         for (appo=iwt->iwt_AppList; appo; appo = (struct AppObject *) appo->appo_Node.mln_Succ)
1057                 {
1058                 if (APPTYPE_AppIcon == appo->appo_type &&
1059                         appo->appo_object.appoo_IconObject == IconObj &&
1060                         appo->appo_TagList &&
1061                         GetTagData(WBAPPICONA_NotifySelectState, FALSE, appo->appo_TagList))
1062                         {
1063                         SendAppMessage(appo,
1064                                 Selected ? AMCLASSICON_Selected : AMCLASSICON_Unselected,
1065                                 0, 0);
1066                         break;
1067                         }
1068                 }
1069
1070         ScalosReleaseSemaphore(iwt->iwt_AppListSemaphore);
1071 }
1072
1073
1074 void ClassDragFinish_IconWin(struct ScalosArg **arglist)
1075 {
1076         struct ScalosArg *scarg, *argNext;
1077
1078         for (scarg=*arglist; scarg; scarg=argNext)
1079                 {
1080                 argNext = (struct ScalosArg *) scarg->scarg_Node.mln_Succ;
1081
1082                 if (scarg->scarg_lock)
1083                         UnLock(scarg->scarg_lock);
1084                 if (scarg->scarg_name)
1085                         FreeCopyString(scarg->scarg_name);
1086                 if (scarg->scarg_ext)
1087                         FreeCopyString(scarg->scarg_ext);
1088
1089                 SCA_FreeNode((struct ScalosNodeList *) arglist, &scarg->scarg_Node);
1090                 }
1091 }
1092
1093
1094 void ClassDragBegin_DeviceWin(struct ScalosArg **ArgList, struct DragNode **dnList)
1095 {
1096         ClassDragBegin_IconWin(ArgList, dnList);
1097 }
1098
1099
1100 void ClassDragBegin_IconWin(struct ScalosArg **ArgList, struct DragNode **dnList)
1101 {
1102         struct DragNode *dn;
1103         CONST_STRPTR Extension = NULL;
1104         Object *tempIconObj;
1105
1106         for (dn=*dnList; dn; dn = (struct DragNode *) dn->drgn_Node.mln_Succ)
1107                 {
1108                 struct ScalosArg *scarg = (struct ScalosArg *) SCA_AllocStdNode((struct ScalosNodeList *) ArgList, NTYP_ScalosArg);
1109
1110                 if (scarg)
1111                         {
1112                         IPTR IconType = 0;
1113
1114                         scarg->scarg_xpos = dn->drgn_x;
1115                         scarg->scarg_ypos = dn->drgn_y;
1116
1117                         scarg->scarg_DeltaX = dn->drgn_DeltaX;
1118                         scarg->scarg_DeltaY = dn->drgn_DeltaY;
1119
1120                         GetAttr(IDTA_Type, dn->drgn_icon, &IconType);
1121
1122                         switch (IconType)
1123                                 {
1124                         case WBDISK:
1125                         case WBKICK:
1126                                 //.disk
1127                                 scarg->scarg_icontype = WBDISK;
1128
1129                                 scarg->scarg_lock = DiskInfoLock(dn->drgn_iconnode);
1130                                 if ((BPTR)NULL == scarg->scarg_lock)
1131                                         {
1132                                         if (NULL == dn->drgn_iconnode->in_DeviceIcon->di_Volume)
1133                                                 {
1134                                                 SCA_FreeNode((struct ScalosNodeList *) ArgList, &dn->drgn_Node);
1135                                                 break;
1136                                                 }
1137
1138                                         scarg->scarg_name = AllocCopyString(dn->drgn_iconnode->in_DeviceIcon->di_Device);
1139                                         }
1140                                 else
1141                                         {
1142                                         scarg->scarg_name = AllocCopyString(dn->drgn_iconnode->in_Name);
1143
1144                                         GetAttr(IDTA_Extention, dn->drgn_icon, (APTR) &Extension);
1145                                         if (Extension)
1146                                                 scarg->scarg_ext = AllocCopyString(Extension);
1147                                         }
1148                                 d1(kprintf("%s/%s/%ld: scarg_name=<%s>\n", __FILE__, __FUNC__, __LINE__, scarg->scarg_name));
1149                                 break;
1150
1151                         case WBDRAWER:
1152                         case WBGARBAGE:
1153                         case WBDEVICE:
1154                                 //.drawer
1155                                 scarg->scarg_icontype = WBDRAWER;
1156                                 if (dn->drgn_iconnode->in_Lock)
1157                                         scarg->scarg_lock = DupLock(dn->drgn_iconnode->in_Lock);
1158                                 else
1159                                         scarg->scarg_lock = Lock("", ACCESS_READ);
1160
1161                                 if ((BPTR)NULL == scarg->scarg_lock)
1162                                         {
1163                                         SCA_FreeNode((struct ScalosNodeList *) ArgList, &dn->drgn_Node);
1164                                         break;
1165                                         }
1166
1167                                 scarg->scarg_name = AllocCopyString(GetIconName(dn->drgn_iconnode));
1168
1169                                 GetAttr(IDTA_Extention, dn->drgn_icon, (APTR) &Extension);
1170                                 if (Extension)
1171                                         scarg->scarg_ext = AllocCopyString(Extension);
1172                                 break;
1173
1174                         case WBTOOL:
1175                         case WBPROJECT:
1176                                 //.tool
1177                                 scarg->scarg_icontype = WBTOOL;
1178                                 if (dn->drgn_iconnode->in_Lock)
1179                                         scarg->scarg_lock = DupLock(dn->drgn_iconnode->in_Lock);
1180                                 else
1181                                         scarg->scarg_lock = Lock("", ACCESS_READ);
1182
1183                                 if ((BPTR)NULL == scarg->scarg_lock)
1184                                         {
1185                                         SCA_FreeNode((struct ScalosNodeList *) ArgList, &dn->drgn_Node);
1186                                         break;
1187                                         }
1188
1189                                 scarg->scarg_name = AllocCopyString(GetIconName(dn->drgn_iconnode));
1190
1191                                 GetAttr(IDTA_Extention, dn->drgn_icon, (APTR) &Extension);
1192                                 if (Extension)
1193                                         scarg->scarg_ext = AllocCopyString(Extension);
1194                                 break;
1195
1196                         case WB_TEXTICON_TOOL:
1197                                 //.texttool
1198                                 scarg->scarg_icontype = WBTOOL;
1199                                 if (dn->drgn_iconnode->in_Lock)
1200                                         scarg->scarg_lock = DupLock(dn->drgn_iconnode->in_Lock);
1201                                 else
1202                                         scarg->scarg_lock = Lock("", ACCESS_READ);
1203
1204                                 scarg->scarg_name = AllocCopyString(GetIconName(dn->drgn_iconnode));
1205
1206                                 tempIconObj = NewIconObject(GetIconName(dn->drgn_iconnode), NULL);
1207
1208                                 if (tempIconObj)
1209                                         {
1210                                         GetAttr(IDTA_Extention, dn->drgn_icon, (APTR) &Extension);
1211                                         if (Extension)
1212                                                 scarg->scarg_ext = AllocCopyString(Extension);
1213
1214                                         DisposeIconObject(tempIconObj);
1215                                         }
1216                                 break;
1217
1218                         case WB_TEXTICON_DRAWER:
1219                                 //.textdrawer
1220                                 scarg->scarg_icontype = WBDRAWER;
1221                                 if (dn->drgn_iconnode->in_Lock)
1222                                         scarg->scarg_lock = DupLock(dn->drgn_iconnode->in_Lock);
1223                                 else
1224                                         scarg->scarg_lock = Lock("", ACCESS_READ);
1225
1226                                 scarg->scarg_name = AllocCopyString(GetIconName(dn->drgn_iconnode));
1227
1228                                 tempIconObj = NewIconObject(GetIconName(dn->drgn_iconnode), NULL);
1229
1230                                 if (tempIconObj)
1231                                         {
1232                                         GetAttr(IDTA_Extention, dn->drgn_icon, (APTR) &Extension);
1233                                         if (Extension)
1234                                                 scarg->scarg_ext = AllocCopyString(Extension);
1235
1236                                         DisposeIconObject(tempIconObj);
1237                                         }
1238                                 break;
1239
1240                         case WBAPPICON:
1241                                 SCA_FreeNode((struct ScalosNodeList *) ArgList, &dn->drgn_Node);
1242                                 break;
1243
1244                         default:
1245                                 SCA_FreeNode((struct ScalosNodeList *) ArgList, &dn->drgn_Node);
1246                                 break;
1247                                 }
1248                         }
1249                 }
1250 }
1251
1252
1253 void ClassSetDefaultIconFlags(struct ScaIconNode *in, BOOL IsDefIcon)
1254 {
1255         IPTR UserFlags;
1256
1257         GetAttr(IDTA_UserFlags, in->in_Icon, &UserFlags);
1258
1259         if (IsDefIcon)
1260                 {
1261                 d1(kprintf("%s/%s/%ld: in=<%s>  supportFlags=%08lx\n", \
1262                         __FILE__, __FUNC__, __LINE__, GetIconName(in), in->in_SupportFlags));
1263
1264                 UserFlags |= ICONOBJ_USERFLAGF_DefaultIcon;
1265                 in->in_Flags |= INF_DefaultIcon;
1266                 }
1267         else
1268                 {
1269                 UserFlags &= ~ICONOBJ_USERFLAGF_DefaultIcon;
1270                 in->in_Flags &= ~INF_DefaultIcon;
1271                 }
1272
1273         SetAttrs(in->in_Icon, IDTA_UserFlags, UserFlags, TAG_END);
1274 }
1275
1276