workbench/libs/muimaster/dragndrop.c

   1 /*
   2     Copyright © 2002, 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                         ULONG 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 = (LONG)data;
 622                                                         break;
 623
 624                                 case    GUI_TopOffset:
 625                                                         bmn->bmn_Top = (LONG)data;
 626                                                         break;
 627
 628                                 case    GUI_Width:
 629                                                         bmn->bmn_Width = (LONG)data;
 630                                                         break;
 631
 632                                 case    GUI_Height:
 633                                                         bmn->bmn_Height = (LONG)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
 784 //              BltBitMapRastPort(temp_bmap,0,0,
 785 //                                                              rp, 100+bmn->bmn_Left,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
 793 //              BltBitMapRastPort(temp_bmap,0,0,
 794 //                                                              rp, 180+bmn->bmn_Left,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 //              BltBitMapRastPort(temp_bmap,0,0,
 823 //                                                              rp, 240+bmn->bmn_Left,20+bmn->bmn_Top,width,height,0xc0);
 824
 825
 826                                 // temporäre (fertige) BitMap darstellen
 827                                 SafeBltBitMapRastPort(temp_bmap,0,0,
 828                                                                 rp,x,y,width,height,0xc0);
 829
 830 //              BltBitMapRastPort(bmn->bmn_SaveBitMap,0,0,
 831 //                                                              rp, 40+bmn->bmn_Left,20+bmn->bmn_Top,bmn->bmn_Width,bmn->bmn_Height,0xc0);
 832
 833                         }       else
 834                         {
 835                                 if( bmn->bmn_SaveWidth > 0 && bmn->bmn_SaveHeight > 0 )
 836                                         RestoreBackground(bmn,rp);
 837
 838                                 BltBackgroundBitMap(bmn, x, y, width, height,FALSE);
 839
 840 /*                              BltBitMapRastPort( bmn->bmn_SaveBitMap,0,0,
 841                                                                         rp, bmn->bmn_SaveX, bmn->bmn_SaveY, bmn->bmn_SaveWidth, bmn->bmn_SaveHeight, 0xc0 );
 842
 843                                 SafeBltBitMap(rp->BitMap, x,y,
 844                                                                 bmn->bmn_SaveBitMap, 0,0, width, height, 0xc0, -1, NULL);
 845 */
 846                                 BltBitMapNode(bmn, 0,0,rp,x,y,width,height);
 847                         }
 848                         DeinitRastPort(&temp_rp);
 849                 }
 850         }
 851
 852         bmn->bmn_Drawed = TRUE;
 853         bmn->bmn_SaveX = x;
 854         bmn->bmn_SaveY = y;
 855         bmn->bmn_SaveWidth = width;
 856         bmn->bmn_SaveHeight = height;
 857 //      bmn->bmn_SaveOffX = offx;
 858 //      bmn->bmn_SaveOffY = offy;
 859 }
 860 //-------------------------------------
 861 VOID UndrawBitMapNode(struct BitMapNode *bmn )
 862 {
 863         struct RastPort *rp = &bmn->bmn_DnD->dnd_Screen->RastPort;
 864
 865         if( !bmn->bmn_SaveBitMap ) return;
 866
 867         if( bmn->bmn_SaveWidth > 0 && bmn->bmn_SaveHeight > 0 )
 868         {
 869                 SafeBltBitMapRastPort( bmn->bmn_SaveBitMap,0,0,
 870                                                                         rp, bmn->bmn_SaveX, bmn->bmn_SaveY, bmn->bmn_SaveWidth, bmn->bmn_SaveHeight, 0xc0 );
 871         }
 872         bmn->bmn_SaveWidth = 0;
 873         bmn->bmn_SaveHeight = 0;
 874 }
 875 //-------------------------------------
 876
 877 //-------------------------------------
 878 struct DragNDrop *CreateDragNDropA( struct TagItem *tlist )
 879 {
 880         struct DragNDrop *dnd = (struct DragNDrop*)AllocMem( sizeof(struct DragNDrop), MEMF_CLEAR );
 881         if( dnd )
 882         {
 883                 NewList( (struct List*)&dnd->dnd_List);
 884
 885 /*              if(dnd->dnd_LayerInfo = NewLayerInfo()))
 886                 {
 887                         dnd->dnd_Screen = NULL
 888                         dnd->dnd_TempBitMap = NULL;
 889
 890
 891                         struct RastPort *rp = &dnd->dnd_RastPort;
 892                         InitRastPort(rp);
 893
 894                         rp->BitMap =
 895
 896                         if(dnd->dnd_Layer = CreateBehindLayer(dnd->dnd_LayerInfo,
 897
 898                         DeinitRastPort(rp);
 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 Screen *scr;
 926         struct RastPort *rp;
 927         struct BitMapNode *node;
 928         BOOL reverse;
 929         LONG diffx = x - lastx;
 930         LONG diffy = y - lasty;
 931
 932         if(!dnd || !dnd->dnd_Screen) return;
 933
 934         scr = dnd->dnd_Screen;
 935         rp = &scr->RastPort;
 936
 937         reverse = FALSE;
 938
 939         if(abs(diffy) < abs(diffx))//y==lasty)
 940         {
 941                 if(diffx>0) reverse = TRUE;
 942                 List_Sort_Mode_3(&dnd->dnd_List);
 943         }       else
 944         {
 945                 if(diffy>0) reverse = TRUE;
 946                 List_Sort_Mode_1(&dnd->dnd_List);
 947         }
 948
 949
 950 /*      if(first) reverse = FALSE;
 951         else
 952         {
 953                 if( x<lastx) reverse = FALSE;
 954                 else
 955                 {
 956                         if(x==lastx && y < lasty) reverse=FALSE;
 957                         else reverse = TRUE;
 958                 }
 959
 960                 if(x>lastx && y < lasty)
 961                 {
 962                         List_Sort_Mode_2(&dnd->dnd_List);
 963                         reverse=FALSE;
 964                 }       else
 965                 {
 966                         if(x<lastx && y > lasty)
 967                         {
 968                                 List_Sort_Mode_2(&dnd->dnd_List);
 969                                 reverse=TRUE;
 970                         }
 971                 }
 972
 973
 974 //              cout << x << "  " << lastx << "  " << y << "  " << lasty << " " << reverse << endl;
 975         }*/
 976
 977         node = List_First(&dnd->dnd_List);
 978         while(node)
 979         {
 980                 node->bmn_Drawed = FALSE;
 981                 node = Node_Next(node);
 982         }
 983
 984         if(!reverse)
 985         {
 986                 node = List_First(&dnd->dnd_List);
 987                 while(node)
 988                 {
 989                         DrawBitMapNode( node, x + node->bmn_Left, y + node->bmn_Top);
 990                         node = Node_Next(node);
 991                 }
 992         }       else
 993         {
 994                 node = (struct BitMapNode *)List_Last(&dnd->dnd_List);
 995                 while(node)
 996                 {
 997                         DrawBitMapNode(node, x + node->bmn_Left, y + node->bmn_Top);
 998                         node = (struct BitMapNode *)Node_Prev(node);
 999                 }
1000         }
1001         first = FALSE;
1002         lastx = x;
1003         lasty = y;
1004 }
1005 //-------------------------------------
1006 VOID UndrawDragNDrop(struct DragNDrop *dnd)
1007 {
1008         struct BitMapNode *node;
1009         node = (struct BitMapNode *)List_Last(&dnd->dnd_List);
1010         while(node)
1011         {
1012                 UndrawBitMapNode(node);
1013                 node =  (struct BitMapNode *)Node_Prev(node);
1014         }
1015 }
1016 //-------------------------------------
1017 BOOL PrepareDragNDrop(struct DragNDrop *dnd,struct Screen *scr)
1018 {
1019         struct BitMapNode *bmn;
1020         struct RastPort *rp;
1021         LONG depth;
1022         LONG maxwidth=0,maxheight=0;
1023         BOOL ok=TRUE;
1024
1025         if(!dnd || !scr) return FALSE;
1026         dnd->dnd_Screen = scr;
1027
1028         rp = &scr->RastPort;
1029         depth = GetBitMapAttr( rp->BitMap, BMA_DEPTH );
1030
1031         bmn = List_First(&dnd->dnd_List);
1032         while(bmn)
1033         {
1034                 bmn->bmn_SaveWidth = bmn->bmn_SaveHeight = 0;
1035                 if( bmn->bmn_Width > maxwidth ) maxwidth=bmn->bmn_Width;
1036                 if( bmn->bmn_Height > maxheight ) maxheight=bmn->bmn_Height;
1037
1038                 if( !(bmn->bmn_SaveBitMap = AllocBitMap( bmn->bmn_Width, bmn->bmn_Height, depth, BMF_MINPLANES, rp->BitMap )))
1039                 {
1040                         ok = FALSE;
1041                         break;
1042                 }
1043                 bmn = Node_Next(bmn);
1044         }
1045
1046         if(ok && maxwidth && maxheight)
1047         {
1048                 dnd->dnd_TempBitMap = /*NULL;// */ AllocBitMap(maxwidth,maxheight,depth,BMF_MINPLANES,rp->BitMap);
1049                 return TRUE;
1050         }
1051
1052         bmn = List_First(&dnd->dnd_List);
1053         while(bmn)
1054         {
1055                 if(bmn->bmn_SaveBitMap)
1056                 {
1057                         FreeBitMap(bmn->bmn_SaveBitMap);
1058                         bmn->bmn_SaveBitMap = NULL;
1059                 }
1060                 bmn = Node_Next(bmn);
1061         }
1062
1063         return FALSE;
1064 }
1065 //-------------------------------------
1066 VOID FinishDragNDrop(struct DragNDrop *dnd)
1067 {
1068         struct BitMapNode *bmn;
1069         if(dnd->dnd_TempBitMap) FreeBitMap(dnd->dnd_TempBitMap);
1070
1071         bmn = List_First(&dnd->dnd_List);
1072         while(bmn)
1073         {
1074                 if(bmn->bmn_SaveBitMap)
1075                 {
1076                         FreeBitMap(bmn->bmn_SaveBitMap);
1077                         bmn->bmn_SaveBitMap = NULL;
1078                 }
1079                 bmn = Node_Next(bmn);
1080         }
1081
1082 }
1083 //-------------------------------------
1084
1085 /**********************************************************************
1086  Varargs function of CreateBitMapNode(). Note that we need a dummy
1087  because we need at least one parameter
1088 **********************************************************************/
1089 struct BitMapNode *VARARGS68K CreateBitMapNode(void *dummy, ...)
1090 {
1091 #ifndef __amigaos4__
1092     return CreateBitMapNodeA( (struct TagItem*)(((ULONG*)&dummy)+1));
1093 #else
1094     va_list argptr;
1095     struct TagItem *tagList;
1096     struct BitMapNode *res;
1097
1098     va_startlinear(argptr, dummy);
1099     tagList = va_getlinearva(argptr,struct TagItem *);
1100     res = CreateBitMapNodeA(tagList);
1101     va_end(argptr);
1102     return res;
1103 #endif
1104 }
1105
1106 /******************************************************************************/
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123 #if 0
1124
1125 struct Library *TimerBase;
1126 struct TimerStruct
1127 {
1128         struct MsgPort *msgport;
1129         struct timerequest *iorequest;
1130         struct Library *timerbase;
1131         ULONG sent;
1132 };
1133
1134 //-------------------------------------
1135 ASM VOID TIMER_DeleteTimer( register __a0 APTR t )
1136 {
1137         if( t )
1138         {
1139                 struct TimerStruct *timer = (struct TimerStruct*)t;
1140                 if( timer )
1141                 {
1142                         if( timer->timerbase )
1143                         {
1144                                 if( timer->sent )
1145                                 {
1146 //                                      printf("Test1\n");
1147                                         AbortIO((struct IORequest*)timer->iorequest);
1148 //                                      printf("Test2\n");
1149                                         WaitIO((struct IORequest*)timer->iorequest);
1150                                 }
1151
1152                                 CloseDevice((struct IORequest*)timer->iorequest);
1153                         }
1154                         if( timer->iorequest ) DeleteIORequest(timer->iorequest);
1155                         if( timer->msgport ) DeleteMsgPort(timer->msgport);
1156                         FreeVec(timer);
1157                 }
1158         }
1159 }
1160 //-------------------------------------
1161 ASM APTR TIMER_CreateTimer()
1162 {
1163         struct TimerStruct *timer = (struct TimerStruct *)AllocVec( sizeof(struct TimerStruct),0x10000);
1164         if( timer )
1165         {
1166                 if(( timer->msgport = CreateMsgPort()))
1167                 {
1168                         if(( timer->iorequest = (struct timerequest*)CreateIORequest( timer->msgport, sizeof(struct timerequest))))
1169                         {
1170                                 if( !OpenDevice( TIMERNAME, UNIT_VBLANK, (struct IORequest*)timer->iorequest, NULL ))
1171                                 {
1172 #ifdef __MAXON__
1173                                         /*TimerBase = */timer->timerbase = (struct Library*)timer->iorequest->tr_node.io_Device;
1174 #else
1175                                         timer->timerbase = (struct Library*)timer->iorequest->tr_node.io_Device;
1176 #endif
1177                                         return timer;
1178                                 }
1179                         }
1180                 }
1181                 TIMER_DeleteTimer(timer);
1182         }
1183         return NULL;
1184 }
1185 //-------------------------------------
1186 ASM struct MsgPort *TIMER_GetMsgPort( register __a0 APTR t )
1187 {
1188         if( !t ) return NULL;
1189         return ((struct TimerStruct *)t)->msgport;
1190 }
1191 //-------------------------------------
1192 ASM ULONG TIMER_GetSigMask( register __a0 APTR t )
1193 {
1194         if( !t ) return NULL;
1195         return (1UL << (((struct TimerStruct *)t)->msgport->mp_SigBit));
1196 }
1197 //-------------------------------------
1198 ASM APTR TIMER_StartTimer( register __a0 APTR t, register __d0 ULONG secs, register __d1 ULONG mics )
1199 {
1200         struct TimerStruct *timer;
1201         struct timerequest *req;
1202
1203         if( !t ) return NULL;
1204
1205         timer = (struct TimerStruct*)t;
1206         if( timer->sent ) return NULL;
1207
1208         req = timer->iorequest;
1209         req->tr_node.io_Command = TR_ADDREQUEST;
1210         req->tr_time.tv_secs = secs;
1211         req->tr_time.tv_micro = mics;
1212         timer->sent = TRUE;
1213         SendIO((struct IORequest*)req );
1214         return (APTR)1L;
1215 }
1216 //-------------------------------------
1217 ASM VOID TIMER_StopTimer( register __a0 APTR t )
1218 {
1219         struct TimerStruct *timer;
1220         if( !t ) return;
1221
1222         timer = (struct TimerStruct*)t;
1223         if( timer->sent )
1224         {
1225                 AbortIO((struct IORequest*)timer->iorequest);
1226                 WaitIO((struct IORequest*)timer->iorequest);
1227                 timer->sent = 0;
1228         }
1229 }
1230 //-------------------------------------
1231
1232 //-------------------------------------
1233 struct BitMap *CreateBitmapFromIcon(struct Screen *scr, struct DiskObject *dobj, LONG *width, LONG *height)
1234 {
1235         struct Rectangle rect;
1236         static struct TagItem rect_tags[] =
1237         {
1238                 ICONDRAWA_Borderless, TRUE,
1239                 TAG_DONE,0
1240         };
1241
1242         static struct TagItem draw_tags[] =
1243         {
1244                 ICONDRAWA_Borderless,TRUE,
1245                 ICONDRAWA_EraseBackground,TRUE,
1246                 TAG_DONE,0
1247         };
1248
1249         if(!dobj) return NULL;
1250
1251         if(GetIconRectangleA(NULL,dobj,NULL,&rect,rect_tags))
1252         {
1253                 BOOL standard;
1254                 struct BitMap *bmap;
1255                 if(GetBitMapAttr(scr->RastPort.BitMap,BMA_FLAGS) & BMF_STANDARD) standard = TRUE;
1256                 else standard = FALSE;
1257
1258                 *width = rect.MaxX - rect.MinX + 1;
1259                 *height = rect.MaxY - rect.MinY + 1;
1260
1261 //              cout << rect.MinY << " " << rect.MaxY << endl;
1262
1263                 bmap = AllocBitMap(*width,*height,8,/*NULL,NULL);// */ BMF_MINPLANES, standard?NULL:scr->RastPort.BitMap);
1264                 if(bmap)
1265                 {
1266                         struct RastPort rp;
1267                         InitRastPort(&rp);
1268                         rp.BitMap = bmap;
1269                         SetRast(&rp,1);
1270                         DrawIconStateA(&rp,dobj,NULL,0,0,IDS_SELECTED,draw_tags);
1271                         DeinitRastPort(&rp);
1272
1273                         return bmap;
1274                 }
1275         }
1276
1277         return NULL;
1278 }
1279 //-------------------------------------
1280
1281 struct Window *wnd;
1282 struct DragNDrop *drag;
1283
1284 //-------------------------------------
1285 VOID loop()
1286 {
1287         BOOL ready = FALSE;
1288         static LONG lmx,lmy;
1289
1290         WaitPort( wnd->UserPort );
1291         while( ready == FALSE )
1292         {
1293                 struct IntuiMessage *imsg;
1294                 while((imsg = (struct IntuiMessage*)GetMsg( wnd->UserPort )))
1295                 {
1296                         ULONG cl = imsg->Class;
1297                         UWORD code = imsg->Code;
1298 //                      LONG mx = imsg->MouseX;
1299 //                      LONG my = imsg->MouseY;
1300
1301                         ReplyMsg((struct Message *)imsg);
1302
1303                         switch( cl )
1304                         {
1305                                 case    IDCMP_CLOSEWINDOW:
1306                                                         ready = TRUE;
1307                                                         break;
1308
1309                                 case    IDCMP_VANILLAKEY:
1310                                                         {
1311                                                                 DrawDragNDrop(drag,wnd->WScreen->MouseX,wnd->WScreen->MouseY);
1312                                                                 lmx = wnd->WScreen->MouseX;
1313                                                                 lmy = wnd->WScreen->MouseY;
1314                                                         }
1315                                                         break;
1316
1317                                 case    IDCMP_MOUSEBUTTONS:
1318                                                         if(code == SELECTDOWN)
1319                                                         {
1320                                                                 DrawDragNDrop(drag,wnd->WScreen->MouseX,wnd->WScreen->MouseY);
1321                                                                 lmx = wnd->WScreen->MouseX;
1322                                                                 lmy = wnd->WScreen->MouseY;
1323                                                         }
1324                                                         break;
1325
1326                                 case    IDCMP_MOUSEMOVE:
1327 //                                                      cout << wnd->WScreen->MouseX - lmx << "  " << wnd->WScreen->MouseY - lmy << endl;
1328 //                                                      WaitBOVP(&wnd->WScreen->ViewPort);
1329                                                         DrawDragNDrop(drag,wnd->WScreen->MouseX,wnd->WScreen->MouseY);
1330                                                         break;
1331                         }
1332                 }
1333         }
1334 }
1335 //-------------------------------------
1336
1337 UBYTE fullmask[8192];
1338
1339 void main()
1340 {
1341   int i;
1342   for (i=0;i<8192;i++) fullmask[i] = 0xff;
1343
1344         wnd = OpenWindowTags( NULL,
1345                                                                                                         WA_InnerWidth, 400,
1346                                                                                                         WA_InnerHeight, 200,
1347                                                                                                         WA_IDCMP, IDCMP_CLOSEWINDOW|IDCMP_MOUSEMOVE|IDCMP_INTUITICKS|IDCMP_MOUSEBUTTONS|IDCMP_VANILLAKEY,
1348                                                                                                         WA_DragBar, TRUE,
1349                                                                                                         WA_DepthGadget, TRUE,
1350                                                                                                         WA_CloseGadget, TRUE,
1351                                                                                                         WA_ReportMouse, TRUE,
1352                                                                                                         WA_Activate, TRUE,
1353                                                                                                         WA_GimmeZeroZero, TRUE,
1354                                                                                                         WA_MouseQueue, 2,
1355                                                                                                         TAG_DONE );
1356         if( wnd )
1357         {
1358                 BOOL ready = FALSE;
1359                 struct DiskObject *obj1 = GetIconTags("SYS:Prefs",
1360                                         ICONGETA_GenerateImageMasks,TRUE,
1361                                         TAG_DONE);
1362                 struct DiskObject *obj2 = GetIconTags("SYS:Picasso96",
1363                                         ICONGETA_GenerateImageMasks,TRUE,
1364                                         TAG_DONE);
1365                 struct DiskObject *obj3 = GetIconTags("SYS:Tools",
1366                                         ICONGETA_GenerateImageMasks,TRUE,
1367                                         TAG_DONE);
1368                 LONG width,height;
1369                 struct BitMap *bmap1 = CreateBitmapFromIcon(wnd->WScreen, obj1,&width,&height);
1370                 struct BitMap *bmap2 = CreateBitmapFromIcon(wnd->WScreen, obj2,&width,&height);
1371                 struct BitMap *bmap3 = CreateBitmapFromIcon(wnd->WScreen, obj3,&width,&height);
1372                 if(bmap1&&bmap2&&bmap3)
1373                 {
1374                         APTR mask1,mask2,mask3;
1375                         IconControl(obj1,ICONCTRLA_GetImageMask1,&mask1,TAG_DONE);
1376                         IconControl(obj2,ICONCTRLA_GetImageMask1,&mask2,TAG_DONE);
1377                         IconControl(obj3,ICONCTRLA_GetImageMask1,&mask3,TAG_DONE);
1378                         if((drag = CreateDragNDropA(NULL)))
1379                         {
1380                                 struct BitMapNode *bmn1 = CreateBitMapNode(
1381                                                         GUI_BitMap, bmap1,
1382                                                         GUI_Mask, mask1,
1383                                                         GUI_Width, width,
1384                                                         GUI_Height, height,
1385                                                         GUI_TopOffset, -25,
1386                                                         GUI_LeftOffset, -35,
1387                                                         TAG_DONE);
1388
1389                                 struct BitMapNode *bmn2 = CreateBitMapNode(
1390                                                         GUI_BitMap, bmap2,
1391                                                         GUI_Mask, mask2,
1392                                                         GUI_Width, width,
1393                                                         GUI_Height, height,
1394                                                         GUI_LeftOffset, 0,
1395                                                         TAG_DONE);
1396
1397                                 struct BitMapNode *bmn3 = CreateBitMapNode(
1398                                                         GUI_BitMap, bmap3,
1399                                                         GUI_Mask, mask3,
1400                                                         GUI_Width, width,
1401                                                         GUI_Height, height,
1402                                                         GUI_LeftOffset, 99,
1403                                                         GUI_TopOffset, -10,
1404                                                         TAG_DONE);
1405
1406                                 struct BitMapNode *bmn4 = CreateBitMapNode(
1407                                                         GUI_BitMap, bmap1,
1408                                                         GUI_Mask, mask1,
1409                                                         GUI_Width, width,
1410                                                         GUI_Height, height,
1411                                                         GUI_TopOffset, 60,
1412                                                         TAG_DONE);
1413
1414                                 struct BitMapNode *bmn5 = CreateBitMapNode(
1415                                                         GUI_BitMap, bmap2,
1416                                                         GUI_Mask, mask2,
1417                                                         GUI_Width, width,
1418                                                         GUI_Height, height,
1419                                                         GUI_LeftOffset, 50,
1420                                                         GUI_TopOffset, 60,
1421                                                         TAG_DONE);
1422
1423                                 struct BitMapNode *bmn6 = CreateBitMapNode(
1424                                                         GUI_BitMap, bmap3,
1425                                                         GUI_Mask, mask3,
1426                                                         GUI_Width, width,
1427                                                         GUI_Height, height,
1428                                                         GUI_LeftOffset, 100,
1429                                                         GUI_TopOffset, 70,
1430                                                         TAG_DONE);
1431
1432                                 if(bmn1 && bmn2 && bmn3 && bmn4 && bmn5 && bmn6)
1433                                 {
1434                                         AttachBitMapNode(drag,bmn1);
1435                                         AttachBitMapNode(drag,bmn2);
1436                                         AttachBitMapNode(drag,bmn3);
1437                                         AttachBitMapNode(drag,bmn4);
1438                                         AttachBitMapNode(drag,bmn5);
1439                                         AttachBitMapNode(drag,bmn6);
1440                                         PrepareDragNDrop(drag,wnd->WScreen);
1441                                         loop();
1442                                         FinishDragNDrop(drag);
1443                                         DetachBitMapNode(bmn6);
1444                                         DetachBitMapNode(bmn5);
1445                                         DetachBitMapNode(bmn4);
1446                                         DetachBitMapNode(bmn3);
1447                                         DetachBitMapNode(bmn2);
1448                                         DetachBitMapNode(bmn1);
1449                                 }
1450                                 if(bmn6) DeleteBitMapNode(bmn6);
1451                                 if(bmn5) DeleteBitMapNode(bmn5);
1452                                 if(bmn4) DeleteBitMapNode(bmn4);
1453                                 if(bmn3) DeleteBitMapNode(bmn3);
1454                                 if(bmn2) DeleteBitMapNode(bmn2);
1455                                 if(bmn1) DeleteBitMapNode(bmn1);
1456                                 DeleteDragNDrop(drag);
1457                         }
1458                 }
1459
1460                 if(bmap3) FreeBitMap(bmap3);
1461                 if(bmap2) FreeBitMap(bmap2);
1462                 if(bmap1) FreeBitMap(bmap1);
1463
1464                 if(obj3) FreeDiskObject(obj3);
1465                 if(obj2) FreeDiskObject(obj2);
1466                 if(obj1) FreeDiskObject(obj1);
1467                 CloseWindow( wnd );
1468         }
1469 }
1470
1471 //-------------------------------------
1472
1473 #endif