workbench/libs/muimaster/dragndrop.c

   1 /*
   2     Copyright © 2002-2011, The AROS Development Team.
   3     All rights reserved.
   4
   5     $Id$
   6 */
   7
   8 #include <stdio.h>
   9 #include <stdlib.h>
  10 #include <math.h>
  11
  12 #include <exec/devices.h>
  13 #include <exec/memory.h>
  14 #include <workbench/icon.h>
  15
  16 #include <clib/alib_protos.h>
  17
  18 #include <proto/graphics.h>
  19 #include <proto/exec.h>
  20 #include <proto/intuition.h>
  21 #include <proto/icon.h>
  22 #include <proto/wb.h>
  23 #include <proto/timer.h>
  24 #include <proto/utility.h>
  25
  26 #include "dragndrop.h"
  27 #include "muimaster_intern.h"
  28 #include "support.h"
  29
  30 /* #define MYDEBUG 1 */
  31 #include "debug.h"
  32
  33 extern struct Library *MUIMasterBase;
  34
  35 #ifdef __MAXON__
  36
  37 ULONG IconControl( struct DiskObject *icon, ... )
  38 {
  39     return IconControlA(icon,(struct TagItem*)((((ULONG*)&icon)+1)));
  40 }
  41
  42 struct DiskObject *GetIconTags( CONST_STRPTR name, ... )
  43 {
  44     return GetIconTagList(name,(struct TagItem*)(((ULONG*)&name)+1));
  45 }
  46
  47
  48 #define ASM
  49
  50 #else
  51
  52 #ifdef __SASC
  53 #define ASM __asm
  54 #else
  55 #define ASM
  56 #endif
  57
  58 #endif
  59
  60 //-------------------------------------
  61 // List Funcs
  62 //-------------------------------------
  63 static struct MinNode *Node_Prev(APTR node)
  64 {
  65     if(node == NULL) return NULL;
  66     if(((struct MinNode*)node)->mln_Pred == NULL) return NULL;
  67     if(((struct MinNode*)node)->mln_Pred->mln_Pred == NULL)
  68         return NULL;
  69     return ((struct MinNode*)node)->mln_Pred;
  70 }
  71 //-------------------------------------
  72
  73 //-------------------------------------
  74 static struct MinNode *List_Last(APTR list)
  75 {
  76     if( !((struct MinList*)list)->mlh_TailPred) return NULL;
  77
  78     if(((struct MinList*)list)->mlh_TailPred->mln_Pred == NULL) return NULL;
  79     return ((struct MinList*)list)->mlh_TailPred;
  80 }
  81 //-------------------------------------
  82 #if 0
  83 static ULONG List_Length(APTR list)
  84 {
  85     struct MinNode *node = List_First(list);
  86     ULONG len=0;
  87     while(node)
  88     {
  89         len++;
  90         node = Node_Next(node);
  91     }
  92     return len;
  93 }
  94 //-------------------------------------
  95 static struct MinNode *List_Find(APTR list, ULONG num)
  96 {
  97     struct MinNode *node = List_First(list);
  98     while(num--)
  99     {
 100         if(!(node = Node_Next(node))) break;
 101     }
 102     return node;
 103 }
 104 #endif
 105 //-------------------------------------
 106
 107 struct DragNDrop
 108 {
 109     struct MinList dnd_List;
 110     struct Screen *dnd_Screen;
 111     struct BitMap *dnd_TempBitMap;
 112
 113 /*
 114     struct RastPort dnd_RastPort;
 115     struct Layer_Info *dnd_LayerInfo;
 116     struct Layer *dnd_Layer;
 117 */
 118 };
 119
 120 struct BitMapNode
 121 {
 122     struct MinNode bmn_Node;
 123     struct BitMap *bmn_BitMap;
 124     APTR bmn_Mask;
 125
 126     LONG bmn_Left;
 127     LONG bmn_Top;
 128     LONG bmn_Width;
 129     LONG bmn_Height;
 130
 131     LONG bmn_SaveX;
 132     LONG bmn_SaveY;
 133     LONG bmn_SaveWidth;
 134     LONG bmn_SaveHeight;
 135     LONG bmn_SaveOffX;
 136     LONG bmn_SaveOffY;
 137     LONG bmn_Drawed;
 138     struct BitMap *bmn_SaveBitMap;
 139
 140     struct DragNDrop *bmn_DnD;
 141 };
 142
 143 #define bmn_Succ bmn_Node.mln_Succ
 144 #define bmn_Pred bmn_Node.mln_Pred
 145
 146 /* Tags for GUI_CreateBitMapNodeA() */
 147 #define GUI_BitMap                (TAG_USER+1)    /* struct BitMap * */
 148 #define GUI_Mask                    (TAG_USER+2)    /* APTR */
 149 #define GUI_LeftOffset        (TAG_USER+3)    /* LONG */
 150 #define GUI_TopOffset        (TAG_USER+4)    /* LONG */
 151 #define GUI_Width                (TAG_USER+5)    /* LONG */
 152 #define GUI_Height                (TAG_USER+6)    /* LONG */
 153
 154 //-------------------------------------
 155 STATIC VOID List_Sort_Mode_1( struct MinList *list )
 156 {
 157     BOOL notfinished=TRUE;
 158
 159     /* Sort list (quick & dirty bubble sort) */
 160     while( notfinished )
 161     {
 162         struct BitMapNode *first;
 163
 164         /* Reset not finished flag */
 165         notfinished = FALSE;
 166
 167         /* Get first node */
 168         if(( first = List_First(list)))
 169         {
 170             struct BitMapNode *second;
 171
 172             /* One bubble sort round */
 173             while(( second = Node_Next(first)))
 174             {
 175                 BOOL sort;
 176                 if(first->bmn_Top > second->bmn_Top) sort=TRUE;
 177                 else if(first->bmn_Top == second->bmn_Top && first->bmn_Left > second->bmn_Left) sort = TRUE;
 178                 else sort=FALSE;
 179
 180                 if( sort )
 181                 {
 182                     Remove((struct Node*)first);
 183                     Insert((struct List*)list,(struct Node*)first,(struct Node*)second);
 184                     notfinished=TRUE;
 185                 }    else first=second;
 186             }
 187         }
 188     }
 189 }
 190 //-------------------------------------
 191 #if 0
 192 STATIC VOID List_Sort_Mode_2( struct MinList *list )
 193 {
 194     BOOL notfinished=TRUE;
 195
 196     /* Sort list (quick & dirty bubble sort) */
 197     while( notfinished )
 198     {
 199         struct BitMapNode *first;
 200
 201         /* Reset not finished flag */
 202         notfinished = FALSE;
 203
 204         /* Get first node */
 205         if(( first = List_First(list)))
 206         {
 207             struct BitMapNode *second;
 208
 209             /* One bubble sort round */
 210             while(( second = Node_Next(first)))
 211             {
 212                 BOOL sort;
 213                 if(first->bmn_Top > second->bmn_Top) sort=TRUE;
 214                 else if(first->bmn_Top == second->bmn_Top && first->bmn_Left < second->bmn_Left) sort = TRUE;
 215                 else sort=FALSE;
 216
 217                 if( sort )
 218                 {
 219                     Remove((struct Node*)first);
 220                     Insert((struct List*)list,(struct Node*)first,(struct Node*)second);
 221                     notfinished=TRUE;
 222                 }    else first=second;
 223             }
 224         }
 225     }
 226 }
 227 #endif
 228 //-------------------------------------
 229 STATIC VOID List_Sort_Mode_3( struct MinList *list )
 230 {
 231     BOOL notfinished=TRUE;
 232
 233     /* Sort list (quick & dirty bubble sort) */
 234     while( notfinished )
 235     {
 236         struct BitMapNode *first;
 237
 238         /* Reset not finished flag */
 239         notfinished = FALSE;
 240
 241         /* Get first node */
 242         if(( first = List_First(list)))
 243         {
 244             struct BitMapNode *second;
 245
 246             /* One bubble sort round */
 247             while(( second = Node_Next(first)))
 248             {
 249                 BOOL sort;
 250                 if(first->bmn_Left > second->bmn_Left) sort=TRUE;
 251                 else if(first->bmn_Left == second->bmn_Left && first->bmn_Top > second->bmn_Top) sort = TRUE;
 252                 else sort=FALSE;
 253
 254                 if( sort )
 255                 {
 256                     Remove((struct Node*)first);
 257                     Insert((struct List*)list,(struct Node*)first,(struct Node*)second);
 258                     notfinished=TRUE;
 259                 }    else first=second;
 260             }
 261         }
 262     }
 263 }
 264 //-------------------------------------
 265 STATIC BOOL AndRectangle( struct Rectangle *a, struct Rectangle *b, struct Rectangle *c)
 266 {
 267     c->MinX = MAX(a->MinX,b->MinX);
 268     c->MinY = MAX(a->MinY,b->MinY);
 269     c->MaxX = MIN(a->MaxX,b->MaxX);
 270     c->MaxY = MIN(a->MaxY,b->MaxY);
 271
 272     if((c->MinX > c->MaxX) || (c->MinY > c->MaxY))  return FALSE;
 273
 274     return TRUE;
 275 }
 276 //-------------------------------------
 277
 278 //-------------------------------------
 279 STATIC VOID SafeBltBitMapRastPort( struct BitMap *srcBitMap, long xSrc, long ySrc,
 280     struct RastPort *destRP, long xDest, long yDest, long xSize,
 281     long ySize, unsigned long minterm )
 282 {
 283     struct BitMap *destBitMap = destRP->BitMap;
 284     LONG srcMaxWidth, srcMaxHeight;
 285     LONG destMaxWidth, destMaxHeight;
 286
 287     srcMaxWidth = GetBitMapAttr(srcBitMap, BMA_WIDTH);
 288     srcMaxHeight = GetBitMapAttr(srcBitMap, BMA_HEIGHT);
 289     destMaxWidth = GetBitMapAttr(destBitMap, BMA_WIDTH);
 290     destMaxHeight = GetBitMapAttr(destBitMap, BMA_HEIGHT);
 291
 292     if(xSrc<0)
 293     {
 294         xDest -= xSrc;
 295         xSize += xSrc;
 296         xSrc=0;
 297     }
 298
 299     if(ySrc<0)
 300     {
 301         yDest -= ySrc;
 302         ySize += ySrc;
 303         ySrc=0;
 304     }
 305
 306     if(xDest<0)
 307     {
 308         xSrc -= xDest;
 309         xSize += xDest;
 310         xDest = 0;
 311     }
 312
 313     if(yDest<0)
 314     {
 315         ySrc -= yDest;
 316         ySize += yDest;
 317         yDest = 0;
 318     }
 319
 320     if( xSize + xSrc > srcMaxWidth ) xSize = srcMaxWidth-xSrc;
 321     if( ySize + ySrc > srcMaxHeight ) ySize = srcMaxHeight-ySrc;
 322     if( xSize + xDest > destMaxWidth ) xSize = destMaxWidth-xDest;
 323     if( ySize + yDest > destMaxHeight ) ySize = destMaxHeight-yDest;
 324
 325     if(xSize > 0 && ySize > 0)
 326     {
 327         BltBitMapRastPort(srcBitMap,xSrc,ySrc,destRP,xDest,yDest,xSize,ySize,minterm);
 328     }
 329 }
 330 //-------------------------------------
 331 STATIC LONG SafeBltBitMap( struct BitMap *srcBitMap, long xSrc, long ySrc,
 332     struct BitMap *destBitMap, long xDest, long yDest, long xSize,
 333     long ySize, unsigned long minterm, unsigned long mask,
 334     PLANEPTR tempA )
 335 {
 336     LONG srcMaxWidth, srcMaxHeight;
 337     LONG destMaxWidth, destMaxHeight;
 338
 339     srcMaxWidth = GetBitMapAttr(srcBitMap, BMA_WIDTH);
 340     srcMaxHeight = GetBitMapAttr(srcBitMap, BMA_HEIGHT);
 341     destMaxWidth = GetBitMapAttr(destBitMap, BMA_WIDTH);
 342     destMaxHeight = GetBitMapAttr(destBitMap, BMA_HEIGHT);
 343
 344     if(xSrc<0)
 345     {
 346         xDest -= xSrc;
 347         xSize += xSrc;
 348         xSrc=0;
 349     }
 350
 351     if(ySrc<0)
 352     {
 353         yDest -= ySrc;
 354         ySize += ySrc;
 355         ySrc=0;
 356     }
 357
 358     if(xDest<0)
 359     {
 360         xSrc -= xDest;
 361         xSize += xDest;
 362         xDest = 0;
 363     }
 364
 365     if(yDest<0)
 366     {
 367         ySrc -= yDest;
 368         ySize += yDest;
 369         yDest = 0;
 370     }
 371
 372     if( xSize + xSrc > srcMaxWidth ) xSize = srcMaxWidth-xSrc;
 373     if( ySize + ySrc > srcMaxHeight ) ySize = srcMaxHeight-ySrc;
 374     if( xSize + xDest > destMaxWidth ) xSize = destMaxWidth-xDest;
 375     if( ySize + yDest > destMaxHeight ) ySize = destMaxHeight-yDest;
 376
 377     if(xSize > 0 && ySize > 0)
 378     {
 379         return BltBitMap( srcBitMap, xSrc, ySrc, destBitMap, xDest, yDest, xSize, ySize, minterm, mask, tempA );
 380     }
 381     return 0;
 382 }
 383
 384 //-------------------------------------
 385 STATIC VOID BltBackgroundBitMap( struct BitMapNode *dest_bmn, long xSrc, long ySrc, long xSize, long ySize, ULONG use_temp)
 386 {
 387     struct BitMap *srcBitMap,*destBitMap;
 388     struct DragNDrop *dnd = dest_bmn->bmn_DnD;
 389     LONG maxWidth, maxHeight;
 390     LONG xDest = 0, yDest = 0;
 391
 392     struct Rectangle rect;
 393     rect.MinX = xSrc;
 394     rect.MinY = ySrc;
 395     rect.MaxX = xSrc + xSize - 1;
 396     rect.MaxY = ySrc + ySize - 1;
 397
 398     srcBitMap = dnd->dnd_Screen->RastPort.BitMap;
 399
 400     if(use_temp) destBitMap = dnd->dnd_TempBitMap;
 401     else destBitMap = dest_bmn->bmn_SaveBitMap;
 402
 403     maxWidth = GetBitMapAttr(srcBitMap, BMA_WIDTH);
 404     maxHeight = GetBitMapAttr(srcBitMap, BMA_HEIGHT);
 405
 406     if(xSrc<0)
 407     {
 408         xDest -= xSrc;
 409         xSize += xSrc;
 410         xSrc=0;
 411     }
 412
 413     if(ySrc<0)
 414     {
 415         yDest -= ySrc;
 416         ySize += ySrc;
 417         ySrc=0;
 418     }
 419
 420     if( xSize + xSrc > maxWidth ) xSize = maxWidth-xSrc;
 421     if( ySize + ySrc > maxHeight ) ySize = maxHeight-ySrc;
 422
 423     if(xSize > 0 && ySize > 0)
 424     {
 425         struct BitMapNode *bmn = List_First(&dnd->dnd_List);
 426
 427         SafeBltBitMap(srcBitMap,xSrc,ySrc,destBitMap,xDest,yDest,xSize,ySize,0xc0, -1, NULL);
 428
 429
 430 //        BltBitMapRastPort(destBitMap,0,0,
 431 //                        &dnd->dnd_Screen->RastPort, 2*dest_bmn->bmn_Left+150, dest_bmn->bmn_Top+200, xSize, ySize,0xc0);
 432
 433         while(bmn)
 434         {
 435             if(bmn != dest_bmn)
 436             {
 437                 struct Rectangle bmn_rect,result_rect;
 438                 bmn_rect.MinX = bmn->bmn_SaveX;
 439                 bmn_rect.MinY = bmn->bmn_SaveY;
 440                 bmn_rect.MaxX = bmn_rect.MinX + bmn->bmn_SaveWidth - 1;
 441                 bmn_rect.MaxY = bmn_rect.MinY + bmn->bmn_SaveHeight - 1;
 442
 443                 if(AndRectangle(&rect,&bmn_rect,&result_rect))
 444                 {
 445                     LONG bmn_x = result_rect.MinX - bmn_rect.MinX;
 446                     LONG bmn_y = result_rect.MinY - bmn_rect.MinY;
 447                     LONG bmn_width = result_rect.MaxX - result_rect.MinX + 1;
 448                     LONG bmn_height = result_rect.MaxY - result_rect.MinY + 1;
 449                     LONG xDest = result_rect.MinX - rect.MinX;
 450                     LONG yDest = result_rect.MinY - rect.MinY;
 451
 452                     SafeBltBitMap(bmn->bmn_SaveBitMap, bmn_x, bmn_y,
 453                                                 destBitMap, xDest, yDest, bmn_width, bmn_height,0xc0,-1,NULL);
 454
 455 //        BltBitMapRastPort(destBitMap,0,0,
 456 //                        &dnd->dnd_Screen->RastPort, 100,300, xSize, ySize,0xc0);
 457
 458                 }
 459             }
 460             bmn = Node_Next(bmn);
 461         }
 462
 463 //        BltBitMapRastPort(destBitMap,0,0,
 464 //                        &dnd->dnd_Screen->RastPort, 2*dest_bmn->bmn_Left+150, dest_bmn->bmn_Top+200, xSize, ySize,0xc0);
 465
 466     }
 467 }
 468 //-------------------------------------
 469 STATIC VOID BltBitMapNode(struct BitMapNode *src_bmn, LONG offx, LONG offy, struct RastPort *rp, LONG x, LONG y, LONG width, LONG height)
 470 {
 471     struct BitMap *destBitMap = rp->BitMap;
 472     LONG destMaxWidth = GetBitMapAttr(destBitMap, BMA_WIDTH);
 473     LONG destMaxHeight = GetBitMapAttr(destBitMap, BMA_HEIGHT);
 474
 475     if(x<0)
 476     {
 477         offx -= x;
 478         width += x;
 479         x = 0;
 480     }
 481
 482     if(y<0)
 483     {
 484         offy -= y;
 485         height += y;
 486         y = 0;
 487     }
 488
 489     if( width + x > destMaxWidth ) width = destMaxWidth - x;
 490     if( height + y > destMaxHeight ) height = destMaxHeight - y;
 491
 492     if(width > 0 && height > 0)
 493     {
 494         if(src_bmn->bmn_Mask)
 495         {
 496             BltMaskBitMapRastPort( src_bmn->bmn_BitMap, offx, offy,
 497                                     rp, x, y, width, height, 0xe2, (PLANEPTR)src_bmn->bmn_Mask);
 498         }    else
 499         {
 500             BltBitMapRastPort( src_bmn->bmn_BitMap, offx, offy,
 501                                     rp, x, y, width, height, 0xc0 );
 502         }
 503     }
 504 }
 505 //-------------------------------------
 506 STATIC VOID BltNearBitMaps(struct BitMapNode *src_bmn, struct RastPort *rp,  LONG x, LONG y, LONG width, LONG height)
 507 {
 508     struct DragNDrop *dnd = src_bmn->bmn_DnD;
 509     struct BitMapNode *bmn = List_First(&dnd->dnd_List);
 510     struct Rectangle rect;
 511
 512     rect.MinX = x;
 513     rect.MinY = y;
 514     rect.MaxX = x + width - 1;
 515     rect.MaxY = y + height - 1;
 516
 517     while(bmn)
 518     {
 519         if(bmn != src_bmn && bmn->bmn_Drawed)
 520         {
 521             struct Rectangle bmn_rect,result_rect;
 522             bmn_rect.MinX = bmn->bmn_SaveX;
 523             bmn_rect.MinY = bmn->bmn_SaveY;
 524             bmn_rect.MaxX = bmn_rect.MinX + bmn->bmn_SaveWidth - 1;
 525             bmn_rect.MaxY = bmn_rect.MinY + bmn->bmn_SaveHeight - 1;
 526
 527             if(AndRectangle(&rect,&bmn_rect,&result_rect))
 528             {
 529                 LONG bmn_x = result_rect.MinX - bmn_rect.MinX;
 530                 LONG bmn_y = result_rect.MinY - bmn_rect.MinY;
 531                 LONG bmn_width = result_rect.MaxX - result_rect.MinX + 1;
 532                 LONG bmn_height = result_rect.MaxY - result_rect.MinY + 1;
 533                 LONG xDest = result_rect.MinX - rect.MinX;
 534                 LONG yDest = result_rect.MinY - rect.MinY;
 535
 536                 BltBitMapNode(bmn, bmn_x, bmn_y,
 537                                         rp, xDest, yDest, bmn_width, bmn_height);
 538
 539             }
 540         }
 541         bmn = Node_Next(bmn);
 542     }
 543 }
 544 //-------------------------------------
 545 STATIC VOID RestoreBackground( struct BitMapNode *src_bmn, struct RastPort *rp)
 546 {
 547     LONG save_x = src_bmn->bmn_SaveX;
 548     LONG save_y = src_bmn->bmn_SaveY;
 549     LONG save_width = src_bmn->bmn_SaveWidth;
 550     LONG save_height = src_bmn->bmn_SaveHeight;
 551
 552     struct DragNDrop *dnd = src_bmn->bmn_DnD;
 553     struct BitMapNode *bmn = List_First(&dnd->dnd_List);
 554     struct Rectangle last_rect;
 555
 556     last_rect.MinX = save_x;
 557     last_rect.MinY = save_y;
 558     last_rect.MaxX = save_x + save_width - 1;
 559     last_rect.MaxY = save_y + save_height - 1;
 560
 561     SafeBltBitMapRastPort( src_bmn->bmn_SaveBitMap,0,0,
 562                             rp, save_x, save_y, save_width, save_height, 0xc0 );
 563
 564
 565     while(bmn)
 566     {
 567         if(bmn != src_bmn && bmn->bmn_Drawed)
 568         {
 569             struct Rectangle bmn_rect,result_rect;
 570             bmn_rect.MinX = bmn->bmn_SaveX;
 571             bmn_rect.MinY = bmn->bmn_SaveY;
 572             bmn_rect.MaxX = bmn_rect.MinX + bmn->bmn_SaveWidth - 1;
 573             bmn_rect.MaxY = bmn_rect.MinY + bmn->bmn_SaveHeight - 1;
 574
 575             if(AndRectangle(&last_rect,&bmn_rect,&result_rect))
 576             {
 577                 LONG bmn_x = result_rect.MinX - bmn_rect.MinX;
 578                 LONG bmn_y = result_rect.MinY - bmn_rect.MinY;
 579                 LONG bmn_width = result_rect.MaxX - result_rect.MinX + 1;
 580                 LONG bmn_height = result_rect.MaxY - result_rect.MinY + 1;
 581 /*                  LONG xDest = result_rect.MinX - last_rect.MinX; */
 582 /*                  LONG yDest = result_rect.MinY - last_rect.MinY; */
 583
 584                 BltBitMapNode(bmn, bmn_x, bmn_y,
 585                                         rp, result_rect.MinX, result_rect.MinY, bmn_width, bmn_height);
 586
 587 //                SafeBltBitMapRastPort(bmn->bmn_SaveBitMap, bmn_x, bmn_y,
 588 //                                            rp, xDest, yDest, bmn_width, bmn_height,0xc0);
 589
 590             }
 591         }
 592         bmn = Node_Next(bmn);
 593     }
 594 }
 595 //-------------------------------------
 596 struct BitMapNode *CreateBitMapNodeA( struct TagItem *tagList )
 597 {
 598     struct BitMapNode *bmn = (struct BitMapNode*)AllocMem( sizeof(struct BitMapNode), MEMF_CLEAR );
 599     if( bmn )
 600     {
 601 /*          BOOL alloc=FALSE; */
 602         struct TagItem *tl=tagList;
 603         struct TagItem *tag;
 604
 605         while(( tag = NextTagItem((const struct TagItem **) &tl )))
 606         {
 607             ULONG id = tag->ti_Tag;
 608             IPTR data = tag->ti_Data;
 609
 610             switch( id )
 611             {
 612                 case    GUI_BitMap:
 613                             bmn->bmn_BitMap = (struct BitMap *)data;
 614                             break;
 615
 616                 case    GUI_Mask:
 617                             bmn->bmn_Mask = (APTR)data;
 618                             break;
 619
 620                 case    GUI_LeftOffset:
 621                             bmn->bmn_Left = data;
 622                             break;
 623
 624                 case    GUI_TopOffset:
 625                             bmn->bmn_Top = data;
 626                             break;
 627
 628                 case    GUI_Width:
 629                             bmn->bmn_Width = data;
 630                             break;
 631
 632                 case    GUI_Height:
 633                             bmn->bmn_Height = data;
 634                             break;
 635
 636             }
 637         }
 638
 639         if( !bmn->bmn_BitMap )
 640         {
 641             FreeMem(bmn, sizeof(struct BitMapNode));
 642             bmn = NULL;
 643         }
 644     }
 645     return bmn;
 646 }
 647 //-------------------------------------
 648 VOID DeleteBitMapNode(struct BitMapNode *bmn )
 649 {
 650     if( bmn->bmn_SaveBitMap ) FreeBitMap(bmn->bmn_SaveBitMap);
 651     FreeMem( bmn, sizeof(struct BitMapNode));
 652 }
 653 //-------------------------------------
 654 struct BitMap *GetBitMap( struct BitMapNode *bmn )
 655 {
 656     if( bmn ) return bmn->bmn_BitMap;
 657     return NULL;
 658 }
 659 //-------------------------------------
 660 VOID AttachBitMapNode( struct DragNDrop *dnd, struct BitMapNode *bmn )
 661 {
 662     AddTail( (struct List*)&dnd->dnd_List, (struct Node*)&bmn->bmn_Node );
 663     bmn->bmn_DnD = dnd;
 664 }
 665 //-------------------------------------
 666 VOID DetachBitMapNode( struct BitMapNode *bmn )
 667 {
 668     if( bmn->bmn_Succ && bmn->bmn_Pred )
 669     {
 670         Remove((struct Node *)&bmn->bmn_Node );
 671         bmn->bmn_Succ = bmn->bmn_Pred = NULL;
 672     }
 673     bmn->bmn_DnD = NULL;
 674 }
 675 //-------------------------------------
 676 VOID DrawBitMapNode( struct BitMapNode *bmn, LONG x, LONG y )
 677 {
 678     LONG width = bmn->bmn_Width;
 679     LONG height = bmn->bmn_Height;
 680     LONG save_x = bmn->bmn_SaveX;
 681     LONG save_y = bmn->bmn_SaveY;
 682     LONG save_width = bmn->bmn_SaveWidth;
 683     LONG save_height = bmn->bmn_SaveHeight;
 684     struct RastPort *rp;
 685     struct BitMap *temp_bmap;
 686     BOOL draw=TRUE;//FALSE;
 687
 688     if(!bmn || !bmn->bmn_DnD || !bmn->bmn_DnD->dnd_Screen) return;
 689     rp = &bmn->bmn_DnD->dnd_Screen->RastPort;
 690     temp_bmap = bmn->bmn_DnD->dnd_TempBitMap;
 691
 692     if( !bmn->bmn_SaveBitMap ) return;
 693
 694 /*    if( bmn->bmn_SaveWidth > 0 && bmn->bmn_SaveHeight > 0 )
 695     {
 696         if(!temp_bmap)
 697         {
 698             RestoreBackground(bmn,rp);
 699         }
 700     }*/
 701
 702     {
 703         LONG maxWidth, maxHeight/*  , offx=0, offy=0, save_offx=0, save_offy=0 */;
 704         LONG real_width = width, real_height = height;
 705         LONG real_save_width = save_width, real_save_height = save_height;
 706
 707         maxWidth = GetBitMapAttr(rp->BitMap, BMA_WIDTH);
 708         maxHeight = GetBitMapAttr(rp->BitMap, BMA_HEIGHT);
 709
 710         if( x < 0 ) real_width += x;
 711         if( y < 0 ) real_height += y;
 712         if( save_x < 0 ) real_save_width += save_x;
 713         if( save_y < 0 ) real_save_height += save_y;
 714
 715         if( real_width + x > maxWidth ) real_width = maxWidth-x;
 716         if( real_height + y > maxHeight ) real_height = maxHeight-y;
 717         if( real_save_width + x > maxWidth ) real_save_width = maxWidth-x;
 718         if( real_save_height + y > maxHeight ) real_save_height = maxHeight-y;
 719
 720         if((real_width>0 && real_height > 0)||(real_save_width>0&&real_save_height>0))
 721             draw = TRUE;
 722     }
 723
 724     if( draw )
 725     {
 726         if(!temp_bmap)
 727         {
 728 //            SafeBltBitMap(rp->BitMap, x,y,
 729 //                                bmn->bmn_SaveBitMap, 0,0, width, height, 0xc0, -1, NULL);
 730
 731 //            bmn->bmn_SaveWidth = 0;
 732 //            bmn->bmn_SaveHeight = 0;
 733
 734 //            BltBackgroundBitMap(bmn->bmn_DnD, x, y,
 735 //                                    bmn->bmn_SaveBitMap, 0,0, width, height);
 736
 737             if( bmn->bmn_SaveWidth > 0 && bmn->bmn_SaveHeight > 0 )
 738                 RestoreBackground(bmn,rp);
 739
 740             BltBackgroundBitMap(bmn, x, y, width, height,FALSE);
 741
 742 //            BltBitMapRastPort(bmn->bmn_SaveBitMap,0,0,
 743 //                                rp, 20+bmn->bmn_Left*2,20+bmn->bmn_Top,width,height,0xc0);
 744
 745
 746             BltBitMapNode(bmn, 0,0, rp,x,y,width,height);
 747         }    else
 748         {
 749             struct RastPort temp_rp;
 750             struct Rectangle save_rect,rect,result_rect;
 751             InitRastPort(&temp_rp);
 752             temp_rp.BitMap = temp_bmap;
 753
 754             save_rect.MinX = save_x;
 755             save_rect.MinY = save_y;
 756             save_rect.MaxX = save_x + save_width - 1;
 757             save_rect.MaxY = save_y + save_height - 1;
 758
 759             rect.MinX = x;
 760             rect.MinY = y;
 761             rect.MaxX = x + width-1;
 762             rect.MaxY = y + height-1;
 763
 764             if(AndRectangle(&rect,&save_rect,&result_rect))
 765             {
 766                 LONG result_width = result_rect.MaxX - result_rect.MinX + 1;
 767                 LONG result_height = result_rect.MaxY - result_rect.MinY + 1;
 768                 LONG result_x = result_rect.MinX - save_rect.MinX;
 769                 LONG result_y = result_rect.MinY - save_rect.MinY;
 770 //                cout << rect.MinX << "  " << rect.MaxX << "  " << rect.MinY << "  " << rect.MaxY << endl;
 771 //                cout << save_rect.MinX << "  " << save_rect.MaxX << "  " << save_rect.MinY << "  " << save_rect.MaxY << endl;
 772 //                cout << result_rect.MinX << "  " << result_rect.MaxX << "  " << result_rect.MinY << "  " << result_rect.MaxY << endl;
 773 //                cout << "soffx:" << save_offx << " offx:" << offx << " rx:" << result_x << "  " << result_y << "  " << "  w: " << width << "  " << result_width << "  " << result_height << endl;
 774
 775 //                SetRast(&temp_rp,0);
 776
 777                 // Neuen Hintergrund in temporäre Bitmap
 778 //                SafeBltBitMapRastPort( rp->BitMap, x, y,
 779 //                                        &temp_rp, 0, 0, width, height,0xc0);
 780
 781                 BltBackgroundBitMap(bmn, x, y, width, height, TRUE);
 782
 783                 /* Debug code */
 784 //                BltBitMapRastPort(temp_bmap,0,0,rp,100+bmn->bmn_Left,
 785 //                        20+bmn->bmn_Top,bmn->bmn_Width,bmn->bmn_Height,0xc0);
 786
 787                 // Teile des alten Hintergrundes, die neu verdeckt werden in temporäre Bitmap
 788                 BltBitMapRastPort( bmn->bmn_SaveBitMap, result_x, result_y,
 789                                         &temp_rp, (result_x?0:(save_width-result_width)),result_y?0:(save_height-result_height),
 790                                         result_width,result_height,0xc0);
 791
 792                 /* Debug code */
 793 //                BltBitMapRastPort(temp_bmap,0,0,rp,180+bmn->bmn_Left,
 794 //                        20+bmn->bmn_Top,bmn->bmn_Width,bmn->bmn_Height,0xc0);
 795
 796
 797                 // Teile des alten Hintergrundes, die nicht mehr verdeckt werden auf Screen
 798                 if((save_width - result_width)>0)
 799                 {
 800                     SafeBltBitMapRastPort( bmn->bmn_SaveBitMap, (result_x?0:(result_width)),0,
 801                                         rp,save_x+(result_x?0:(result_width)),save_y,
 802                                         save_width-result_width,save_height,0xc0);
 803                 }
 804
 805                 if((save_height - result_height)>0)
 806                 {
 807                     SafeBltBitMapRastPort( bmn->bmn_SaveBitMap, 0,result_y?0:(result_height),
 808                                         rp,save_x,save_y+(result_y?0:(result_height)),
 809                                         save_width,save_height-result_height,0xc0);
 810                 }
 811
 812                 // temporäre BitMap ist neuer Hintergrund
 813                 BltBitMap(temp_bmap,0,0,
 814                                 bmn->bmn_SaveBitMap, 0,0,width,height,0xc0,-1,NULL);
 815
 816                 // darzustellende BitMap in temporäre BitMap
 817                 BltBitMapNode(bmn, 0,0,&temp_rp,0,0,width,height);
 818
 819                 // Angenzende BitMaps in temporäre BitMap
 820                 BltNearBitMaps(bmn, &temp_rp,x,y,width,height);
 821
 822                 /* Debug code */
 823 //                BltBitMapRastPort(temp_bmap,0,0,rp,240+bmn->bmn_Left,
 824 //                        20+bmn->bmn_Top,width,height,0xc0);
 825
 826
 827                 // temporäre (fertige) BitMap darstellen
 828                 SafeBltBitMapRastPort(temp_bmap,0,0,
 829                                 rp,x,y,width,height,0xc0);
 830
 831                 /* Debug code */
 832 //                BltBitMapRastPort(bmn->bmn_SaveBitMap,0,0,rp,40+bmn->bmn_Left,
 833 //                        20+bmn->bmn_Top,bmn->bmn_Width,bmn->bmn_Height,0xc0);
 834
 835             }    else
 836             {
 837                 if( bmn->bmn_SaveWidth > 0 && bmn->bmn_SaveHeight > 0 )
 838                     RestoreBackground(bmn,rp);
 839
 840                 BltBackgroundBitMap(bmn, x, y, width, height,FALSE);
 841
 842 /*                BltBitMapRastPort( bmn->bmn_SaveBitMap,0,0,
 843                                     rp, bmn->bmn_SaveX, bmn->bmn_SaveY, bmn->bmn_SaveWidth, bmn->bmn_SaveHeight, 0xc0 );
 844
 845                 SafeBltBitMap(rp->BitMap, x,y,
 846                                 bmn->bmn_SaveBitMap, 0,0, width, height, 0xc0, -1, NULL);
 847 */
 848                 BltBitMapNode(bmn, 0,0,rp,x,y,width,height);
 849             }
 850         }
 851     }
 852
 853     bmn->bmn_Drawed = TRUE;
 854     bmn->bmn_SaveX = x;
 855     bmn->bmn_SaveY = y;
 856     bmn->bmn_SaveWidth = width;
 857     bmn->bmn_SaveHeight = height;
 858 //    bmn->bmn_SaveOffX = offx;
 859 //    bmn->bmn_SaveOffY = offy;
 860 }
 861 //-------------------------------------
 862 VOID UndrawBitMapNode(struct BitMapNode *bmn )
 863 {
 864     struct RastPort *rp = &bmn->bmn_DnD->dnd_Screen->RastPort;
 865
 866     if( !bmn->bmn_SaveBitMap ) return;
 867
 868     if( bmn->bmn_SaveWidth > 0 && bmn->bmn_SaveHeight > 0 )
 869     {
 870         SafeBltBitMapRastPort( bmn->bmn_SaveBitMap,0,0,
 871                                     rp, bmn->bmn_SaveX, bmn->bmn_SaveY, bmn->bmn_SaveWidth, bmn->bmn_SaveHeight, 0xc0 );
 872     }
 873     bmn->bmn_SaveWidth = 0;
 874     bmn->bmn_SaveHeight = 0;
 875 }
 876 //-------------------------------------
 877
 878 //-------------------------------------
 879 struct DragNDrop *CreateDragNDropA( struct TagItem *tlist )
 880 {
 881     struct DragNDrop *dnd = (struct DragNDrop*)AllocMem( sizeof(struct DragNDrop), MEMF_CLEAR );
 882     if( dnd )
 883     {
 884         NewList( (struct List*)&dnd->dnd_List);
 885
 886 /*        if(dnd->dnd_LayerInfo = NewLayerInfo()))
 887         {
 888             dnd->dnd_Screen = NULL
 889             dnd->dnd_TempBitMap = NULL;
 890
 891
 892             struct RastPort *rp = &dnd->dnd_RastPort;
 893             InitRastPort(rp);
 894
 895             rp->BitMap =
 896
 897             if(dnd->dnd_Layer = CreateBehindLayer(dnd->dnd_LayerInfo,
 898
 899             return dnd;
 900         }
 901         FreeMem( dnd, sizeof(struct DragNDrop ));*/
 902     }
 903     return dnd;
 904 //    return NULL;
 905 }
 906 //-------------------------------------
 907 VOID DeleteDragNDrop( struct DragNDrop *dnd )
 908 {
 909     struct BitMapNode *node;
 910
 911   FinishDragNDrop(dnd);
 912
 913     while ((node = (struct BitMapNode *)RemTail((struct List*)&dnd->dnd_List)))
 914         DeleteBitMapNode(node);
 915
 916     FreeMem( dnd, sizeof(struct DragNDrop ));
 917 }
 918 //-------------------------------------
 919 VOID DrawDragNDrop(struct DragNDrop *dnd, LONG x, LONG y)
 920 {
 921     static LONG lastx;
 922     static LONG lasty;
 923 //    static LONG first=TRUE;
 924
 925     struct BitMapNode *node;
 926     BOOL reverse;
 927     LONG diffx = x - lastx;
 928     LONG diffy = y - lasty;
 929
 930     if(!dnd || !dnd->dnd_Screen) return;
 931
 932     reverse = FALSE;
 933
 934     if(abs(diffy) < abs(diffx))//y==lasty)
 935     {
 936         if(diffx>0) reverse = TRUE;
 937         List_Sort_Mode_3(&dnd->dnd_List);
 938     }    else
 939     {
 940         if(diffy>0) reverse = TRUE;
 941         List_Sort_Mode_1(&dnd->dnd_List);
 942     }
 943
 944
 945 /*    if(first) reverse = FALSE;
 946     else
 947     {
 948         if( x<lastx) reverse = FALSE;
 949         else
 950         {
 951             if(x==lastx && y < lasty) reverse=FALSE;
 952             else reverse = TRUE;
 953         }
 954
 955         if(x>lastx && y < lasty)
 956         {
 957             List_Sort_Mode_2(&dnd->dnd_List);
 958             reverse=FALSE;
 959         }    else
 960         {
 961             if(x<lastx && y > lasty)
 962             {
 963                 List_Sort_Mode_2(&dnd->dnd_List);
 964                 reverse=TRUE;
 965             }
 966         }
 967
 968
 969 //        cout << x << "  " << lastx << "  " << y << "  " << lasty << " " << reverse << endl;
 970     }*/
 971
 972     node = List_First(&dnd->dnd_List);
 973     while(node)
 974     {
 975         node->bmn_Drawed = FALSE;
 976         node = Node_Next(node);
 977     }
 978
 979     if(!reverse)
 980     {
 981         node = List_First(&dnd->dnd_List);
 982         while(node)
 983         {
 984             DrawBitMapNode( node, x + node->bmn_Left, y + node->bmn_Top);
 985             node = Node_Next(node);
 986         }
 987     }    else
 988     {
 989         node = (struct BitMapNode *)List_Last(&dnd->dnd_List);
 990         while(node)
 991         {
 992             DrawBitMapNode(node, x + node->bmn_Left, y + node->bmn_Top);
 993             node = (struct BitMapNode *)Node_Prev(node);
 994         }
 995     }
 996 //    first = FALSE;
 997     lastx = x;
 998     lasty = y;
 999 }
1000 //-------------------------------------
1001 VOID UndrawDragNDrop(struct DragNDrop *dnd)
1002 {
1003     struct BitMapNode *node;
1004     node = (struct BitMapNode *)List_Last(&dnd->dnd_List);
1005     while(node)
1006     {
1007         UndrawBitMapNode(node);
1008         node =  (struct BitMapNode *)Node_Prev(node);
1009     }
1010 }
1011 //-------------------------------------
1012 BOOL PrepareDragNDrop(struct DragNDrop *dnd,struct Screen *scr)
1013 {
1014     struct BitMapNode *bmn;
1015     struct RastPort *rp;
1016     LONG depth;
1017     LONG maxwidth=0,maxheight=0;
1018     BOOL ok=TRUE;
1019
1020     if(!dnd || !scr) return FALSE;
1021     dnd->dnd_Screen = scr;
1022
1023     rp = &scr->RastPort;
1024     depth = GetBitMapAttr( rp->BitMap, BMA_DEPTH );
1025
1026     bmn = List_First(&dnd->dnd_List);
1027     while(bmn)
1028     {
1029         bmn->bmn_SaveWidth = bmn->bmn_SaveHeight = 0;
1030         if( bmn->bmn_Width > maxwidth ) maxwidth=bmn->bmn_Width;
1031         if( bmn->bmn_Height > maxheight ) maxheight=bmn->bmn_Height;
1032
1033         if( !(bmn->bmn_SaveBitMap = AllocBitMap( bmn->bmn_Width, bmn->bmn_Height, depth, BMF_MINPLANES, rp->BitMap )))
1034         {
1035             ok = FALSE;
1036             break;
1037         }
1038         bmn = Node_Next(bmn);
1039     }
1040
1041     if(ok && maxwidth && maxheight)
1042     {
1043         dnd->dnd_TempBitMap = /*NULL;// */ AllocBitMap(maxwidth,maxheight,depth,BMF_MINPLANES,rp->BitMap);
1044         return TRUE;
1045     }
1046
1047     bmn = List_First(&dnd->dnd_List);
1048     while(bmn)
1049     {
1050         if(bmn->bmn_SaveBitMap)
1051         {
1052             FreeBitMap(bmn->bmn_SaveBitMap);
1053             bmn->bmn_SaveBitMap = NULL;
1054         }
1055         bmn = Node_Next(bmn);
1056     }
1057
1058     return FALSE;
1059 }
1060 //-------------------------------------
1061 VOID FinishDragNDrop(struct DragNDrop *dnd)
1062 {
1063     struct BitMapNode *bmn;
1064     if(dnd->dnd_TempBitMap) FreeBitMap(dnd->dnd_TempBitMap);
1065
1066     bmn = List_First(&dnd->dnd_List);
1067     while(bmn)
1068     {
1069         if(bmn->bmn_SaveBitMap)
1070         {
1071             FreeBitMap(bmn->bmn_SaveBitMap);
1072             bmn->bmn_SaveBitMap = NULL;
1073         }
1074         bmn = Node_Next(bmn);
1075     }
1076
1077 }
1078 //-------------------------------------
1079
1080 /**********************************************************************
1081  Varargs function of CreateBitMapNode(). Note that we need a dummy
1082  because we need at least one parameter
1083 **********************************************************************/
1084 struct BitMapNode *VARARGS68K CreateBitMapNode(void *dummy, ...)
1085 {
1086 #ifndef __amigaos4__
1087     return CreateBitMapNodeA( (struct TagItem*)(((ULONG*)&dummy)+1));
1088 #else
1089     va_list argptr;
1090     struct TagItem *tagList;
1091     struct BitMapNode *res;
1092
1093     va_startlinear(argptr, dummy);
1094     tagList = va_getlinearva(argptr,struct TagItem *);
1095     res = CreateBitMapNodeA(tagList);
1096     va_end(argptr);
1097     return res;
1098 #endif
1099 }
1100
1101 /******************************************************************************/
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118 #if 0
1119
1120 struct Library *TimerBase;
1121 struct TimerStruct
1122 {
1123     struct MsgPort *msgport;
1124     struct timerequest *iorequest;
1125     struct Library *timerbase;
1126     ULONG sent;
1127 };
1128
1129 //-------------------------------------
1130 ASM VOID TIMER_DeleteTimer( register __a0 APTR t )
1131 {
1132     if( t )
1133     {
1134         struct TimerStruct *timer = (struct TimerStruct*)t;
1135         if( timer )
1136         {
1137             if( timer->timerbase )
1138             {
1139                 if( timer->sent )
1140                 {
1141 //                    printf("Test1\n");
1142                     AbortIO((struct IORequest*)timer->iorequest);
1143 //                    printf("Test2\n");
1144                     WaitIO((struct IORequest*)timer->iorequest);
1145                 }
1146
1147                 CloseDevice((struct IORequest*)timer->iorequest);
1148             }
1149             if( timer->iorequest ) DeleteIORequest(timer->iorequest);
1150             if( timer->msgport ) DeleteMsgPort(timer->msgport);
1151             FreeVec(timer);
1152         }
1153     }
1154 }
1155 //-------------------------------------
1156 ASM APTR TIMER_CreateTimer()
1157 {
1158     struct TimerStruct *timer = (struct TimerStruct *)AllocVec( sizeof(struct TimerStruct),0x10000);
1159     if( timer )
1160     {
1161         if(( timer->msgport = CreateMsgPort()))
1162         {
1163             if(( timer->iorequest = (struct timerequest*)CreateIORequest( timer->msgport, sizeof(struct timerequest))))
1164             {
1165                 if( !OpenDevice( TIMERNAME, UNIT_VBLANK, (struct IORequest*)timer->iorequest, NULL ))
1166                 {
1167 #ifdef __MAXON__
1168                     /*TimerBase = */timer->timerbase = (struct Library*)timer->iorequest->tr_node.io_Device;
1169 #else
1170                     timer->timerbase = (struct Library*)timer->iorequest->tr_node.io_Device;
1171 #endif
1172                     return timer;
1173                 }
1174             }
1175         }
1176         TIMER_DeleteTimer(timer);
1177     }
1178     return NULL;
1179 }
1180 //-------------------------------------
1181 ASM struct MsgPort *TIMER_GetMsgPort( register __a0 APTR t )
1182 {
1183     if( !t ) return NULL;
1184     return ((struct TimerStruct *)t)->msgport;
1185 }
1186 //-------------------------------------
1187 ASM ULONG TIMER_GetSigMask( register __a0 APTR t )
1188 {
1189     if( !t ) return NULL;
1190     return (1UL << (((struct TimerStruct *)t)->msgport->mp_SigBit));
1191 }
1192 //-------------------------------------
1193 ASM APTR TIMER_StartTimer( register __a0 APTR t, register __d0 ULONG secs, register __d1 ULONG mics )
1194 {
1195     struct TimerStruct *timer;
1196     struct timerequest *req;
1197
1198     if( !t ) return NULL;
1199
1200     timer = (struct TimerStruct*)t;
1201     if( timer->sent ) return NULL;
1202
1203     req = timer->iorequest;
1204     req->tr_node.io_Command = TR_ADDREQUEST;
1205     req->tr_time.tv_secs = secs;
1206     req->tr_time.tv_micro = mics;
1207     timer->sent = TRUE;
1208     SendIO((struct IORequest*)req );
1209     return (APTR)1L;
1210 }
1211 //-------------------------------------
1212 ASM VOID TIMER_StopTimer( register __a0 APTR t )
1213 {
1214     struct TimerStruct *timer;
1215     if( !t ) return;
1216
1217     timer = (struct TimerStruct*)t;
1218     if( timer->sent )
1219     {
1220         AbortIO((struct IORequest*)timer->iorequest);
1221         WaitIO((struct IORequest*)timer->iorequest);
1222         timer->sent = 0;
1223     }
1224 }
1225 //-------------------------------------
1226
1227 //-------------------------------------
1228 struct BitMap *CreateBitmapFromIcon(struct Screen *scr, struct DiskObject *dobj, LONG *width, LONG *height)
1229 {
1230     struct Rectangle rect;
1231     static struct TagItem rect_tags[] =
1232     {
1233         ICONDRAWA_Borderless, TRUE,
1234         TAG_DONE,0
1235     };
1236
1237     static struct TagItem draw_tags[] =
1238     {
1239         ICONDRAWA_Borderless,TRUE,
1240         ICONDRAWA_EraseBackground,TRUE,
1241         TAG_DONE,0
1242     };
1243
1244     if(!dobj) return NULL;
1245
1246     if(GetIconRectangleA(NULL,dobj,NULL,&rect,rect_tags))
1247     {
1248         BOOL standard;
1249         struct BitMap *bmap;
1250         if(GetBitMapAttr(scr->RastPort.BitMap,BMA_FLAGS) & BMF_STANDARD) standard = TRUE;
1251         else standard = FALSE;
1252
1253         *width = rect.MaxX - rect.MinX + 1;
1254         *height = rect.MaxY - rect.MinY + 1;
1255
1256 //        cout << rect.MinY << " " << rect.MaxY << endl;
1257
1258         bmap = AllocBitMap(*width,*height,8,/*NULL,NULL);// */ BMF_MINPLANES, standard?NULL:scr->RastPort.BitMap);
1259         if(bmap)
1260         {
1261             struct RastPort rp;
1262             InitRastPort(&rp);
1263             rp.BitMap = bmap;
1264             SetRast(&rp,1);
1265             DrawIconStateA(&rp,dobj,NULL,0,0,IDS_SELECTED,draw_tags);
1266
1267                         return bmap;
1268         }
1269     }
1270
1271     return NULL;
1272 }
1273 //-------------------------------------
1274
1275 struct Window *wnd;
1276 struct DragNDrop *drag;
1277
1278 //-------------------------------------
1279 VOID loop()
1280 {
1281     BOOL ready = FALSE;
1282     static LONG lmx,lmy;
1283
1284     WaitPort( wnd->UserPort );
1285     while( ready == FALSE )
1286     {
1287         struct IntuiMessage *imsg;
1288         while((imsg = (struct IntuiMessage*)GetMsg( wnd->UserPort )))
1289         {
1290             ULONG cl = imsg->Class;
1291             UWORD code = imsg->Code;
1292 //            LONG mx = imsg->MouseX;
1293 //            LONG my = imsg->MouseY;
1294
1295             ReplyMsg((struct Message *)imsg);
1296
1297             switch( cl )
1298             {
1299                 case    IDCMP_CLOSEWINDOW:
1300                             ready = TRUE;
1301                             break;
1302
1303                 case    IDCMP_VANILLAKEY:
1304                             {
1305                                 DrawDragNDrop(drag,wnd->WScreen->MouseX,wnd->WScreen->MouseY);
1306                                 lmx = wnd->WScreen->MouseX;
1307                                 lmy = wnd->WScreen->MouseY;
1308                             }
1309                             break;
1310
1311                 case    IDCMP_MOUSEBUTTONS:
1312                             if(code == SELECTDOWN)
1313                             {
1314                                 DrawDragNDrop(drag,wnd->WScreen->MouseX,wnd->WScreen->MouseY);
1315                                 lmx = wnd->WScreen->MouseX;
1316                                 lmy = wnd->WScreen->MouseY;
1317                             }
1318                             break;
1319
1320                 case    IDCMP_MOUSEMOVE:
1321 //                            cout << wnd->WScreen->MouseX - lmx << "  " << wnd->WScreen->MouseY - lmy << endl;
1322 //                            WaitBOVP(&wnd->WScreen->ViewPort);
1323                             DrawDragNDrop(drag,wnd->WScreen->MouseX,wnd->WScreen->MouseY);
1324                             break;
1325             }
1326         }
1327     }
1328 }
1329 //-------------------------------------
1330
1331 UBYTE fullmask[8192];
1332
1333 void main()
1334 {
1335   int i;
1336   for (i=0;i<8192;i++) fullmask[i] = 0xff;
1337
1338     wnd = OpenWindowTags( NULL,
1339                                                     WA_InnerWidth, 400,
1340                                                     WA_InnerHeight, 200,
1341                                                     WA_IDCMP, IDCMP_CLOSEWINDOW|IDCMP_MOUSEMOVE|IDCMP_INTUITICKS|IDCMP_MOUSEBUTTONS|IDCMP_VANILLAKEY,
1342                                                     WA_DragBar, TRUE,
1343                                                     WA_DepthGadget, TRUE,
1344                                                     WA_CloseGadget, TRUE,
1345                                                     WA_ReportMouse, TRUE,
1346                                                     WA_Activate, TRUE,
1347                                                     WA_GimmeZeroZero, TRUE,
1348                                                     WA_MouseQueue, 2,
1349                                                     TAG_DONE );
1350     if( wnd )
1351     {
1352         BOOL ready = FALSE;
1353         struct DiskObject *obj1 = GetIconTags("SYS:Prefs",
1354                     ICONGETA_GenerateImageMasks,TRUE,
1355                     TAG_DONE);
1356         struct DiskObject *obj2 = GetIconTags("SYS:Picasso96",
1357                     ICONGETA_GenerateImageMasks,TRUE,
1358                     TAG_DONE);
1359         struct DiskObject *obj3 = GetIconTags("SYS:Tools",
1360                     ICONGETA_GenerateImageMasks,TRUE,
1361                     TAG_DONE);
1362         LONG width,height;
1363         struct BitMap *bmap1 = CreateBitmapFromIcon(wnd->WScreen, obj1,&width,&height);
1364         struct BitMap *bmap2 = CreateBitmapFromIcon(wnd->WScreen, obj2,&width,&height);
1365         struct BitMap *bmap3 = CreateBitmapFromIcon(wnd->WScreen, obj3,&width,&height);
1366         if(bmap1&&bmap2&&bmap3)
1367         {
1368             APTR mask1,mask2,mask3;
1369             IconControl(obj1,ICONCTRLA_GetImageMask1,&mask1,TAG_DONE);
1370             IconControl(obj2,ICONCTRLA_GetImageMask1,&mask2,TAG_DONE);
1371             IconControl(obj3,ICONCTRLA_GetImageMask1,&mask3,TAG_DONE);
1372             if((drag = CreateDragNDropA(NULL)))
1373             {
1374                 struct BitMapNode *bmn1 = CreateBitMapNode(
1375                             GUI_BitMap, bmap1,
1376                             GUI_Mask, mask1,
1377                             GUI_Width, width,
1378                             GUI_Height, height,
1379                             GUI_TopOffset, -25,
1380                             GUI_LeftOffset, -35,
1381                             TAG_DONE);
1382
1383                 struct BitMapNode *bmn2 = CreateBitMapNode(
1384                             GUI_BitMap, bmap2,
1385                             GUI_Mask, mask2,
1386                             GUI_Width, width,
1387                             GUI_Height, height,
1388                             GUI_LeftOffset, 0,
1389                             TAG_DONE);
1390
1391                 struct BitMapNode *bmn3 = CreateBitMapNode(
1392                             GUI_BitMap, bmap3,
1393                             GUI_Mask, mask3,
1394                             GUI_Width, width,
1395                             GUI_Height, height,
1396                             GUI_LeftOffset, 99,
1397                             GUI_TopOffset, -10,
1398                             TAG_DONE);
1399
1400                 struct BitMapNode *bmn4 = CreateBitMapNode(
1401                             GUI_BitMap, bmap1,
1402                             GUI_Mask, mask1,
1403                             GUI_Width, width,
1404                             GUI_Height, height,
1405                             GUI_TopOffset, 60,
1406                             TAG_DONE);
1407
1408                 struct BitMapNode *bmn5 = CreateBitMapNode(
1409                             GUI_BitMap, bmap2,
1410                             GUI_Mask, mask2,
1411                             GUI_Width, width,
1412                             GUI_Height, height,
1413                             GUI_LeftOffset, 50,
1414                             GUI_TopOffset, 60,
1415                             TAG_DONE);
1416
1417                 struct BitMapNode *bmn6 = CreateBitMapNode(
1418                             GUI_BitMap, bmap3,
1419                             GUI_Mask, mask3,
1420                             GUI_Width, width,
1421                             GUI_Height, height,
1422                             GUI_LeftOffset, 100,
1423                             GUI_TopOffset, 70,
1424                             TAG_DONE);
1425
1426                 if(bmn1 && bmn2 && bmn3 && bmn4 && bmn5 && bmn6)
1427                 {
1428                     AttachBitMapNode(drag,bmn1);
1429                     AttachBitMapNode(drag,bmn2);
1430                     AttachBitMapNode(drag,bmn3);
1431                     AttachBitMapNode(drag,bmn4);
1432                     AttachBitMapNode(drag,bmn5);
1433                     AttachBitMapNode(drag,bmn6);
1434                     PrepareDragNDrop(drag,wnd->WScreen);
1435                     loop();
1436                     FinishDragNDrop(drag);
1437                     DetachBitMapNode(bmn6);
1438                     DetachBitMapNode(bmn5);
1439                     DetachBitMapNode(bmn4);
1440                     DetachBitMapNode(bmn3);
1441                     DetachBitMapNode(bmn2);
1442                     DetachBitMapNode(bmn1);
1443                 }
1444                 if(bmn6) DeleteBitMapNode(bmn6);
1445                 if(bmn5) DeleteBitMapNode(bmn5);
1446                 if(bmn4) DeleteBitMapNode(bmn4);
1447                 if(bmn3) DeleteBitMapNode(bmn3);
1448                 if(bmn2) DeleteBitMapNode(bmn2);
1449                 if(bmn1) DeleteBitMapNode(bmn1);
1450                 DeleteDragNDrop(drag);
1451             }
1452         }
1453
1454         if(bmap3) FreeBitMap(bmap3);
1455         if(bmap2) FreeBitMap(bmap2);
1456         if(bmap1) FreeBitMap(bmap1);
1457
1458         if(obj3) FreeDiskObject(obj3);
1459         if(obj2) FreeDiskObject(obj2);
1460         if(obj1) FreeDiskObject(obj1);
1461         CloseWindow( wnd );
1462     }
1463 }
1464
1465 //-------------------------------------
1466
1467 #endif