sifedit/EditArea.cpp

   1
   2 #include <wx/wx.h>
   3 #include "sifedit.h"
   4 #include "MainWindow.h"
   5 #include "EditArea.fdh"
   6
   7 #define SWAP(A, B)      { A ^= B; B ^= A; A ^= B; }
   8 static int zoomstops[] = { 2, 4, 8, 16, 32, -1 };
   9
  10 BEGIN_EVENT_TABLE(EditArea, wxPanel)
  11
  12         EVT_PAINT(EditArea::OnPaint)
  13         EVT_ERASE_BACKGROUND(EditArea::OnErase)
  14     EVT_TIMER(100, EditArea::OnTimer)
  15
  16         EVT_LEFT_DOWN(EditArea::OnMouseDown)
  17         EVT_LEFT_UP(EditArea::OnMouseUp)
  18         EVT_RIGHT_DOWN(EditArea::OnMouseDown)
  19         EVT_RIGHT_UP(EditArea::OnMouseUp)
  20         EVT_MOTION(EditArea::OnMouseMove)
  21         EVT_MOUSEWHEEL(EditArea::OnMouseWheel)
  22
  23 END_EVENT_TABLE()
  24
  25 /*
  26 void c------------------------------() {}
  27 */
  28
  29 EditArea::EditArea(wxWindow *parent, wxWindowID id, const wxPoint &pos, const wxSize &size)
  30         : wxPanel(parent, id, pos, size)
  31 {
  32         fTimer = new wxTimer(this, 100);
  33         fTimer->Start(125);
  34
  35         fBackground = NULL;
  36         fZoomedSprite = NULL;
  37
  38         fZoom = 16;
  39         fOffset = 1;
  40         fBlinkState = true;
  41
  42         fDrag.dragging = false;
  43         fShift.mode = SM_NO_SHIFT;
  44 }
  45
  46 EditArea::~EditArea()
  47 {
  48         delete fBackground;
  49         delete fZoomedSprite;
  50 }
  51
  52 /*
  53 void c------------------------------() {}
  54 */
  55
  56 bool EditArea::SetBackground(const char *filename)
  57 {
  58         delete fBackground;
  59         fBackground = new wxImage;
  60
  61         if (!fBackground->LoadFile(wxString(PrefixPath(filename), wxConvUTF8)))
  62         {
  63                 stat("SetBackground: failed to load file '%s'", filename);
  64                 return 1;
  65         }
  66
  67         return 0;
  68 }
  69
  70 void EditArea::SetZoom(int factor)
  71 {
  72         if (factor < 1) factor = 1;
  73         if (factor > 32) factor = 32    ;
  74
  75         if (fZoom != factor)
  76         {
  77                 fZoom = factor;
  78                 CreateZoomedSprite();
  79         }
  80 }
  81
  82 void EditArea::NextZoomStop(int dir)
  83 {
  84         int curstop;
  85         for(curstop=0;zoomstops[curstop] != -1;curstop++)
  86                 if (zoomstops[curstop] == fZoom) break;
  87
  88         curstop += (dir > 0) ? 1 : -1;
  89
  90         if (zoomstops[curstop] == -1) curstop--;
  91         if (curstop < 0) curstop = 0;
  92
  93         fZoom = zoomstops[curstop];
  94 }
  95
  96 void EditArea::NextOffsStop()
  97 {
  98         fOffset *= 2;
  99         if (fOffset > 16)
 100                 fOffset = 1;
 101
 102         RefreshNow();
 103 }
 104
 105 /*
 106 void c------------------------------() {}
 107 */
 108
 109 void EditArea::OnTimer(wxTimerEvent &event)
 110 {
 111         if (gd.curmode != EM_VIEW)
 112         {
 113                 fBlinkState ^= 1;
 114                 RefreshNow();
 115         }
 116         else fBlinkState = 1;
 117 }
 118
 119 void EditArea::OnPaint(wxPaintEvent &event)
 120 {
 121 wxPaintDC dc(this);
 122         Draw(&dc);
 123 }
 124
 125 void EditArea::Draw(wxDC *dc)
 126 {
 127         if (!fZoomedSprite || !fZoomedSpriteSettings.equ(GetZoomedSpriteSettings()))
 128         {
 129                 if (CreateZoomedSprite())
 130                         return;
 131         }
 132
 133         // create a backbuffer
 134         wxBitmap bbbmp(GetSize().GetWidth(), GetSize().GetHeight());
 135         wxMemoryDC bbdc(bbbmp);
 136
 137         // clear everything
 138         bbdc.SetBrush(*wxLIGHT_GREY_BRUSH);
 139         bbdc.SetPen(*wxTRANSPARENT_PEN);
 140         bbdc.DrawRectangle(0, 0, bbbmp.GetWidth(), bbbmp.GetHeight());
 141
 142         // draw sprite onto backbuffer
 143         bbdc.DrawBitmap(wxBitmap(*fZoomedSprite), fOffset*fZoom, fOffset*fZoom);
 144
 145         // draw overlays
 146         bbdc.SetPen(fBlinkState ? *wxRED_PEN : *wxBLACK_PEN);
 147         bbdc.SetBrush(*wxTRANSPARENT_BRUSH);
 148
 149         if (fShift.mode != SM_NO_SHIFT)
 150         {
 151         }
 152         else if (fDrag.dragging)
 153         {
 154                 DrawRect(&bbdc, &fDrag.draggedrect);
 155         }
 156         else if (gd.curmode == EM_VIEW)
 157         {
 158                 SIFSprite *sprite = CurSprite();
 159                 SIFDir *dir = CurDir();
 160
 161                 bbdc.SetPen(*wxCYAN_PEN);
 162                 DrawRect(&bbdc, &sprite->solidbox);
 163
 164                 bbdc.SetPen(*wxRED_PEN);
 165                 DrawRect(&bbdc, &sprite->bbox);
 166                 DrawPoints(&bbdc, &sprite->block_l.point[0], sprite->block_l.count);
 167                 DrawPoints(&bbdc, &sprite->block_r.point[0], sprite->block_r.count);
 168                 DrawPoints(&bbdc, &sprite->block_u.point[0], sprite->block_u.count);
 169                 DrawPoints(&bbdc, &sprite->block_d.point[0], sprite->block_d.count);
 170
 171                 bbdc.SetPen(*wxGREEN_PEN);
 172                 if (!dir->actionpoint.equ(0, 0)) DrawPoints(&bbdc, &dir->actionpoint, 1);
 173                 if (!dir->actionpoint2.equ(0, 0)) DrawPoints(&bbdc, &dir->actionpoint2, 1);
 174
 175                 bbdc.SetPen(*wxLIGHT_GREY_PEN);
 176                 if (!sprite->spawn_point.equ(0, 0)) DrawPoints(&bbdc, &sprite->spawn_point, 1);
 177
 178                 bbdc.SetPen(*wxCYAN_PEN);
 179                 if (!dir->drawpoint.equ(0, 0)) DrawPoints(&bbdc, &dir->drawpoint, 1);
 180         }
 181         else
 182         {
 183                 SIFRect *bbox = GetCurrentBBox();
 184                 if (bbox) DrawRect(&bbdc, bbox);
 185
 186                 int npoints;
 187                 SIFPoint *points = GetCurrentPointList(&npoints);
 188                 if (points)
 189                 {
 190                         if (gd.curmode == EM_ACTIONPT || gd.curmode == EM_ACTIONPT2)
 191                         {
 192                                 bbdc.SetPen(fBlinkState ? *wxGREEN_PEN : *wxBLACK_PEN);
 193                         }
 194
 195                         DrawPoints(&bbdc, points, npoints);
 196                 }
 197         }
 198
 199         // blit contents of the backbuffer to the screen
 200         dc->Blit(0, 0, bbdc.GetSize().GetWidth(), bbdc.GetSize().GetHeight(), &bbdc, 0, 0);
 201
 202         // draw coordinates when dragging
 203         if (fShift.mode)
 204         {
 205                 switch(fShift.mode)
 206                 {
 207                         case SM_SIZE:
 208                                 DrawGuideText(dc, stprintf("%d x %d", \
 209                                         CurSprite()->w, CurSprite()->h));
 210                         break;
 211
 212                         case SM_SHEET_OFFSET:
 213                                 DrawGuideText(dc, stprintf("[%d, %d]", \
 214                                         CurDir()->sheet_offset.x, CurDir()->sheet_offset.y));
 215                         break;
 216
 217                         case SM_OFFSET_ALL:
 218                                 DrawGuideText(dc, stprintf("+[%d, %d]", \
 219                                         fShift.totaldx, fShift.totaldy));
 220                         break;
 221                 }
 222         }
 223 }
 224
 225 // prevent horrific flicker under Windows--keep it from
 226 // trying to erase the background every time we paint.
 227 void EditArea::OnErase(wxEraseEvent &event)
 228 {
 229 }
 230
 231 void EditArea::DrawRect(wxDC *dc, SIFRect *rect)
 232 {
 233         int x = (fOffset * fZoom) + (rect->x1 * fZoom);
 234         int y = (fOffset * fZoom) + (rect->y1 * fZoom);
 235         int w = ((rect->x2 - rect->x1) + 1) * fZoom;
 236         int h = ((rect->y2 - rect->y1) + 1) * fZoom;
 237
 238         dc->DrawRectangle(x, y, w, h);
 239 }
 240
 241 void EditArea::DrawPoints(wxDC *dc, SIFPoint *point, int count)
 242 {
 243         for(int i=0;i<count;i++)
 244         {
 245                 int x = (fOffset * fZoom) + (point[i].x * fZoom);
 246                 int y = (fOffset * fZoom) + (point[i].y * fZoom);
 247
 248                 dc->DrawRectangle(x, y, fZoom, fZoom);
 249                 dc->DrawLine(x, y, x+(fZoom-1), y+(fZoom-1));
 250         }
 251 }
 252
 253 void EditArea::DrawGuideText(wxDC *dc, const char *str)
 254 {
 255 int x, y;
 256 wxCoord tew, teh;
 257
 258         dc->SetFont(wxFont(14, wxFONTFAMILY_MODERN, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL));
 259         dc->SetTextForeground(wxColour(0, 0, 0));
 260         dc->SetTextBackground(wxColour(255, 255, 255));
 261         dc->SetBackgroundMode(wxSOLID);
 262
 263         wxString wxstr(str, wxConvUTF8);
 264         dc->GetTextExtent(wxstr, &tew, &teh);
 265
 266         x = (fOffset * fZoom) + ((CurSprite()->w * fZoom) / 2) - (tew / 2);
 267         y = (fOffset * fZoom) + (CurSprite()->h * fZoom) + 8;
 268
 269         dc->DrawText(wxstr, x, y);
 270 }
 271
 272 /*
 273 void c------------------------------() {}
 274 */
 275
 276 // converts from e.g. mouse coords on the window to sprite coords on the (zoomed) sprite
 277 void EditArea::PixelToSpriteCoords(int x, int y, int *x_inout, int *y_inout)
 278 {
 279         x -= (fOffset * fZoom);
 280         y -= (fOffset * fZoom);
 281         if (x < 0) x -= fZoom;
 282         if (y < 0) y -= fZoom;
 283         x /= fZoom;
 284         y /= fZoom;
 285
 286         if (x_inout) *x_inout = x;
 287         if (y_inout) *y_inout = y;
 288 }
 289
 290 // converts from sprite coords to actual window coordinates relative to the editarea
 291 // returns the upper-left corner of the enlarged pixel.
 292 void EditArea::SpriteToPixelCoords(int x, int y, int *x_inout, int *y_inout)
 293 {
 294         x *= fZoom;
 295         y *= fZoom;
 296         x += (fOffset * fZoom);
 297         y += (fOffset * fZoom);
 298
 299         if (x_inout) *x_inout = x;
 300         if (y_inout) *y_inout = y;
 301 }
 302
 303 /*
 304 void c------------------------------() {}
 305 */
 306
 307 // returns a pointer the bbox which is currently being edited, based on the edit mode, or NULL.
 308 SIFRect *EditArea::GetCurrentBBox()
 309 {
 310         switch(gd.curmode)
 311         {
 312                 case EM_BBOX:     return &CurSprite()->bbox;
 313                 case EM_SOLIDBOX: return &CurSprite()->solidbox;
 314                 case EM_PFBOX:    return &CurDir()->pf_bbox;
 315         }
 316
 317         return NULL;
 318 }
 319
 320 // returns a pointer to the first point in the pointlist (or single point in some modes)
 321 // which is currently being edited, and the number of points, based on the edit mode, or NULL.
 322 SIFPoint *EditArea::GetCurrentPointList(int *count_out, SIFPointList **outerstruct)
 323 {
 324         int dummy1;
 325         SIFPointList *dummy2;
 326         if (!count_out) count_out = &dummy1;
 327         if (!outerstruct) outerstruct = &dummy2;
 328
 329         *outerstruct = NULL;
 330
 331         switch(gd.curmode)
 332         {
 333                 case EM_BLOCKL:
 334                         *outerstruct = &CurSprite()->block_l;
 335                         break;
 336
 337                 case EM_BLOCKR:
 338                         *outerstruct = &CurSprite()->block_r;
 339                         break;
 340
 341                 case EM_BLOCKU:
 342                         *outerstruct = &CurSprite()->block_u;
 343                         break;
 344
 345                 case EM_BLOCKD:
 346                         *outerstruct = &CurSprite()->block_d;
 347                         break;
 348
 349                 case EM_SPAWNPT: *count_out = 1; return &CurSprite()->spawn_point;
 350
 351                 case EM_ACTIONPT: *count_out = 1; return &CurDir()->actionpoint;
 352                 case EM_ACTIONPT2: *count_out = 1; return &CurDir()->actionpoint2;
 353                 case EM_DRAWPT: *count_out = 1; return &CurDir()->drawpoint;
 354         }
 355
 356         if (outerstruct && *outerstruct)
 357         {
 358                 *count_out = (*outerstruct)->count;
 359                 return &((*outerstruct)->point[0]);
 360         }
 361
 362         return NULL;
 363 }
 364
 365 /*
 366 void c------------------------------() {}
 367 */
 368
 369 void EditArea::OnMouseDown(wxMouseEvent &event)
 370 {
 371         fShift.buttondown = event.m_leftDown;
 372         if (fShift.mode) return;
 373
 374         int x, y;
 375         PixelToSpriteCoords(event.m_x, event.m_y, &x, &y);
 376
 377         int button = event.m_leftDown ? LEFT : RIGHT;
 378
 379         // begin drag if allowed
 380         SIFRect *bbox = GetCurrentBBox();
 381         if (bbox)
 382         {
 383                 HandleBeginDrag(event, button);
 384         }
 385         else    // else maybe they're trying to add/remove a point
 386         {
 387                 HandlePointEdit(x, y, button);
 388         }
 389 }
 390
 391
 392 void EditArea::OnMouseMove(wxMouseEvent &event)
 393 {
 394         if (fShift.mode)
 395         {
 396                 HandleShiftMode(event.m_x, event.m_y);
 397                 return;
 398         }
 399
 400         if (!fDrag.dragging)
 401         {
 402                 OfferAppropriateDragCursor(event.m_x, event.m_y);
 403                 return;
 404         }
 405
 406         SetCursorForDragMode(fDrag.mode);
 407         if (!fDrag.mouse_moved)
 408         {
 409                 if (event.m_x != fDrag.orig_px || event.m_y != fDrag.orig_py)
 410                 {
 411                         fDrag.mouse_moved = true;
 412                 }
 413         }
 414
 415         int x, y;
 416         PixelToSpriteCoords(event.m_x, event.m_y, &x, &y);
 417
 418         if (x == fDrag.lastx && y == fDrag.lasty)
 419                 return;
 420
 421         // update the displayed bbox as they drag
 422         if (fDrag.mode == DM_CREATE_NEW)
 423                 DragUpdateNewBBox(x, y);
 424         else
 425                 DragUpdateAdjustedBBox(x, y);
 426
 427         // update screen
 428         RefreshNow();
 429
 430         fDrag.lastx = x;
 431         fDrag.lasty = y;
 432 }
 433
 434
 435 void EditArea::OnMouseUp(wxMouseEvent &event)
 436 {
 437         fShift.buttondown = event.m_leftDown;
 438         if (fShift.mode) return;
 439
 440         if (fDrag.dragging)
 441         {
 442                 // apply the new bbox
 443                 if (fDrag.mouse_moved)
 444                 {
 445                         SIFRect *bbox = GetCurrentBBox();
 446                         if (bbox)
 447                         {
 448                                 *bbox = fDrag.draggedrect;
 449
 450                                 if (mainwin->fLinkBBoxCheckbox->GetValue() && \
 451                                         gd.curmode == EM_BBOX)
 452                                 {
 453                                         CurSprite()->solidbox = fDrag.draggedrect;
 454                                 }
 455                         }
 456                 }
 457
 458                 fDrag.dragging = false;
 459                 SetCursor(*wxSTANDARD_CURSOR);
 460         }
 461 }
 462
 463 void EditArea::OnMouseWheel(wxMouseEvent &event)
 464 {
 465         int amt = event.m_wheelRotation / event.m_wheelDelta;
 466         if (amt == 0) return;
 467
 468         NextZoomStop(amt);
 469         mainwin->UpdateDisplay();
 470 }
 471
 472 /*
 473 void c------------------------------() {}
 474 */
 475
 476 void EditArea::DragUpdateNewBBox(int x, int y)
 477 {
 478         SIFRect rect;
 479         rect.x1 = fDrag.anchor_x;
 480         rect.y1 = fDrag.anchor_y;
 481         rect.x2 = x;
 482         rect.y2 = y;
 483
 484         if (rect.x1 > rect.x2) SWAP(rect.x1, rect.x2);
 485         if (rect.y1 > rect.y2) SWAP(rect.y1, rect.y2);
 486
 487         fDrag.draggedrect = rect;
 488 }
 489
 490 void EditArea::DragUpdateAdjustedBBox(int x, int y)
 491 {
 492         // get distance from anchor
 493         int distx = (x - fDrag.anchor_x);
 494         int disty = (y - fDrag.anchor_y);
 495
 496         SIFRect rect = fDrag.origrect;
 497
 498         if (fDrag.mode & DM_ADJUST_X1) rect.x1 += distx;
 499         if (fDrag.mode & DM_ADJUST_X2) rect.x2 += distx;
 500         if (fDrag.mode & DM_ADJUST_Y1) rect.y1 += disty;
 501         if (fDrag.mode & DM_ADJUST_Y2) rect.y2 += disty;
 502
 503         fDrag.draggedrect = rect;
 504 }
 505
 506
 507 // returns which drag mode would be used if you pressed the left button
 508 // right now at (unzoomed) pixel position x, y.
 509 int EditArea::SelectDragMode(int px, int py)
 510 {
 511         SIFRect *bbox;
 512         int x1, y1, x2, y2;
 513
 514         if (!(bbox = GetCurrentBBox()))
 515                 return DM_CREATE_NEW;   // not in bbox-edit mode, so always use standard cursor
 516
 517         x1 = bbox->x1;
 518         y1 = bbox->y1;
 519         x2 = bbox->x2;
 520         y2 = bbox->y2;
 521
 522         // zoom the bbox's coords to get it's real, zoomed, coords on the screen
 523         SpriteToPixelCoords(x1, y1, &x1, &y1);
 524         SpriteToPixelCoords(x2, y2, &x2, &y2);
 525         x2 += (fZoom - 1);      // get lower-left corner
 526         y2 += (fZoom - 1);      // instead of upper-left
 527
 528         // find out whether we are closest to the left, right, top or bottom edge of the bbox.
 529         int xclosest = 9000;
 530         int yclosest = 9000;
 531         int xwinner = 0;
 532         int ywinner = 0;
 533         int nc;
 534
 535         if (py >= y1 && py <= y2)
 536         {
 537                 if ((nc = abs(px - x1)) < xclosest) { xclosest = nc; xwinner = DM_ADJUST_X1; }
 538                 if ((nc = abs(px - x2)) < xclosest) { xclosest = nc; xwinner = DM_ADJUST_X2; }
 539         }
 540
 541         if (px >= x1 && px <= x2)
 542         {
 543                 if ((nc = abs(py - y1)) < yclosest) { yclosest = nc; ywinner = DM_ADJUST_Y1; }
 544                 if ((nc = abs(py - y2)) < yclosest) { yclosest = nc; ywinner = DM_ADJUST_Y2; }
 545         }
 546
 547         // check if we're close enough to count
 548         #define CLOSE_DIST              5
 549
 550         int result = 0;                 // equivalent to DM_CREATE_NEW
 551         if (xclosest <= CLOSE_DIST)     result |= xwinner;
 552         if (yclosest <= CLOSE_DIST) result |= ywinner;
 553
 554         // offset whole bbox
 555         if (result == 0 && px >= x1 && px <= x2 && py >= y1 && py <= y2)
 556                 result = (DM_ADJUST_X1 | DM_ADJUST_X2 | DM_ADJUST_Y1 | DM_ADJUST_Y2);
 557
 558         return result;
 559 }
 560
 561 // called from OnMouseMove, if they are close to one of the sides of
 562 // the bbox it sets the mouse cursor to a sizing cursor to offer to drag that side.
 563 void EditArea::OfferAppropriateDragCursor(int px, int py)
 564 {
 565         int dm = DM_CREATE_NEW;
 566
 567         if (!fDrag.dragging)
 568                 dm = SelectDragMode(px, py);
 569
 570         SetCursorForDragMode(dm);
 571 }
 572
 573 // sets the cursor to that used when doing or offering the given drag mode
 574 void EditArea::SetCursorForDragMode(int mode)
 575 {
 576         switch(mode)
 577         {
 578                 case DM_ADJUST_X1:
 579                 case DM_ADJUST_X2: SetCursor(wxCursor(wxCURSOR_SIZEWE)); return;
 580
 581                 case DM_ADJUST_Y1:
 582                 case DM_ADJUST_Y2: SetCursor(wxCursor(wxCURSOR_SIZENS)); return;
 583
 584                 case DM_ADJUST_X1 | DM_ADJUST_Y1:
 585                 case DM_ADJUST_X2 | DM_ADJUST_Y2:
 586                         SetCursor(wxCursor(wxCURSOR_SIZENWSE));
 587                 return;
 588
 589                 case DM_ADJUST_X2 | DM_ADJUST_Y1:
 590                 case DM_ADJUST_X1 | DM_ADJUST_Y2:
 591                         SetCursor(wxCursor(wxCURSOR_SIZENESW));
 592                 return;
 593
 594                 case DM_ADJUST_X1 | DM_ADJUST_X2 | DM_ADJUST_Y1 | DM_ADJUST_Y2:
 595                 {
 596                         // don't OFFER it, only set it if we're doing it now via right mouse button
 597                         if (fDrag.dragging)
 598                         {
 599                                 SetCursor(wxCursor(wxCURSOR_SIZING));
 600                                 return;
 601                         }
 602                 }
 603                 break;
 604         }
 605
 606         SetCursor(*wxSTANDARD_CURSOR);
 607 }
 608
 609 /*
 610 void c------------------------------() {}
 611 */
 612
 613 void EditArea::HandleBeginDrag(wxMouseEvent &event, int button)
 614 {
 615 int x, y;
 616
 617         SIFRect *bbox = GetCurrentBBox();
 618         if (!bbox) return;
 619
 620         PixelToSpriteCoords(event.m_x, event.m_y, &x, &y);
 621
 622         fDrag.mode = SelectDragMode(event.m_x, event.m_y);
 623         if (fDrag.mode == (DM_ADJUST_X1 | DM_ADJUST_Y1 | DM_ADJUST_X2 | DM_ADJUST_Y2))
 624         {
 625                 if (button != RIGHT)
 626                         fDrag.mode = DM_CREATE_NEW;
 627         }
 628
 629         fDrag.origrect = *bbox;
 630         fDrag.anchor_x = x;
 631         fDrag.anchor_y = y;
 632         fDrag.dragging = true;
 633
 634         fDrag.orig_px = event.m_x;
 635         fDrag.orig_py = event.m_y;
 636         fDrag.mouse_moved = false;
 637
 638         fDrag.lastx = -1;
 639         fDrag.lasty = -1;
 640
 641         OnMouseMove(event);
 642 }
 643
 644 void EditArea::HandlePointEdit(int x, int y, int button)
 645 {
 646 SIFPointList *list;
 647 SIFPoint *point;
 648 int npoints;
 649
 650         stat("HandlePointEdit mouse click at %d,%d  btn %d", x, y, button);
 651
 652         point = GetCurrentPointList(&npoints, &list);
 653         if (!point) return;
 654
 655         if (list)
 656         {       // dealing with a list, such as blockl/r/u/d
 657
 658                 // delete any point currently at this position
 659                 // for RIGHT this is the action requested
 660                 // for LEFT it prevents adding more than one block point in the same spot
 661                 SIFPointList newlist;
 662                 newlist.count = 0;
 663                 for(int i=0;i<npoints;i++)
 664                 {
 665                         if (list->point[i].x != x || list->point[i].y != y)
 666                         {
 667                                 newlist.point[newlist.count].x = list->point[i].x;
 668                                 newlist.point[newlist.count].y = list->point[i].y;
 669                                 newlist.count++;
 670                         }
 671                 }
 672                 *list = newlist;
 673
 674                 if (button == LEFT)
 675                 {
 676                         if (list->count < SIF_MAX_BLOCK_POINTS)
 677                         {
 678                                 list->point[list->count].x = x;
 679                                 list->point[list->count].y = y;
 680                                 list->count++;
 681                         }
 682                         else blip();
 683                 }
 684         }
 685         else
 686         {       // dealing with a single point, such as spawn_point
 687                 if (button == RIGHT) return;
 688                 point->x = x;
 689                 point->y = y;
 690         }
 691
 692         RefreshNow();
 693         mainwin->UpdateTitle();
 694 }
 695
 696 /*
 697 void c------------------------------() {}
 698 */
 699
 700 void EditArea::UpdateCtrlShiftStates()
 701 {
 702         int oldShiftMode = fShift.mode;
 703         fShift.mode = SM_NO_SHIFT;
 704
 705         if (gd.ctrl)
 706         {
 707                 fShift.mode = (!gd.shift) ? SM_SHEET_OFFSET : SM_OFFSET_ALL;
 708         }
 709         else if (gd.shift)
 710         {
 711                 fShift.mode = SM_SIZE;
 712         }
 713
 714         UpdateShiftStatusText();
 715
 716         if (fShift.mode != oldShiftMode)
 717         {
 718                 if (fShift.mode)
 719                 {
 720                         fDrag.dragging = false;
 721                         fShift.havefirst = false;
 722                         fShift.buttondown = false;
 723                         fShift.totaldx = fShift.totaldy = 0;
 724
 725                         fShift.expand_bbox = CurSprite()->bbox.equ(0, 0, CurSprite()->w-1, CurSprite()->h-1);
 726                         fShift.expand_solidbox = CurSprite()->solidbox.equ(0, 0, CurSprite()->w-1, CurSprite()->h-1);
 727
 728                         SetCursor(wxCursor(wxCURSOR_SIZING));
 729                 }
 730                 else
 731                 {
 732                         SetCursor(*wxSTANDARD_CURSOR);
 733                 }
 734
 735                 RefreshNow();
 736         }
 737 }
 738
 739 void EditArea::HandleShiftMode(int px, int py)
 740 {
 741         SetCursor(wxCursor(wxCURSOR_SIZING));
 742
 743         if (!fShift.buttondown)
 744         {
 745                 fShift.havefirst = false;
 746                 return;
 747         }
 748
 749         if (!fShift.havefirst)
 750         {
 751                 fShift.lastpx = px;
 752                 fShift.lastpy = py;
 753                 fShift.totaldx = fShift.totaldy = 0;
 754                 fShift.havefirst = true;
 755                 stat("HandleShiftMode(%d, %d): Took first.", px, py);
 756                 return;
 757         }
 758
 759         const int SENSITIVITY = 2;
 760         int deltax = (px - fShift.lastpx) / SENSITIVITY;
 761         int deltay = (py - fShift.lastpy) / SENSITIVITY;
 762
 763         SpriteRecord *sprite = CurSprite();
 764         SIFDir *dir = CurDir();
 765
 766         if (deltax)
 767         {
 768                 switch(fShift.mode)
 769                 {
 770                         case SM_SIZE:
 771                         {
 772                                 sprite->w += deltax;
 773                                 if (sprite->w < 1) sprite->w = 1;
 774                                 if (sprite->w > 255) sprite->w = 255;
 775                         }
 776                         break;
 777
 778                         case SM_SHEET_OFFSET:
 779                         {
 780                                 dir->sheet_offset.x += deltax;
 781                                 if (dir->sheet_offset.x < 0) dir->sheet_offset.x = 0;
 782                         }
 783                         break;
 784
 785                         case SM_OFFSET_ALL:
 786                         {
 787                                 OffsetAllFrames(deltax, 0);
 788                         }
 789                         break;
 790                 }
 791
 792                 fShift.lastpx = px;
 793         }
 794
 795         if (deltay)
 796         {
 797                 switch(fShift.mode)
 798                 {
 799                         case SM_SIZE:
 800                         {
 801                                 sprite->h += deltay;
 802                                 if (sprite->h < 1) sprite->h = 1;
 803                                 if (sprite->h > 255) sprite->h = 255;
 804                         }
 805                         break;
 806
 807                         case SM_SHEET_OFFSET:
 808                         {
 809                                 dir->sheet_offset.y += deltay;
 810                                 if (dir->sheet_offset.y < 0) dir->sheet_offset.y = 0;
 811                         }
 812                         break;
 813
 814                         case SM_OFFSET_ALL:
 815                         {
 816                                 OffsetAllFrames(0, deltay);
 817                         }
 818                         break;
 819                 }
 820
 821                 fShift.lastpy = py;
 822         }
 823
 824         if (deltax || deltay)
 825         {
 826                 if (fShift.mode == SM_SIZE)
 827                 {
 828                         if (fShift.expand_bbox)
 829                                 CurSprite()->bbox.set(0, 0, CurSprite()->w-1, CurSprite()->h-1);
 830
 831                         if (fShift.expand_solidbox)
 832                                 CurSprite()->solidbox.set(0, 0, CurSprite()->w-1, CurSprite()->h-1);
 833                 }
 834
 835                 fShift.totaldx += deltax;
 836                 fShift.totaldy += deltay;
 837
 838                 mainwin->UpdateDisplay();
 839                 UpdateShiftStatusText();
 840         }
 841 }
 842
 843 void EditArea::UpdateShiftStatusText()
 844 {
 845 char *status = "Press CTRL=Sheet Offset, Shift=Size, CTRL+Shift=Offset All";
 846
 847         switch(fShift.mode)
 848         {
 849                 case SM_SHEET_OFFSET:
 850                         status = stprintf("Adjusting sheet offset: [%d, %d]",
 851                                                 CurDir()->sheet_offset.x, CurDir()->sheet_offset.y);
 852                 break;
 853
 854                 case SM_OFFSET_ALL:
 855                         status = "Adjusting sheet offset of ALL frames in current sprite...drag!";
 856                 break;
 857
 858                 case SM_SIZE:
 859                         status = stprintf("Sizing current sprite: %dx%d",
 860                                                 CurSprite()->w, CurSprite()->h);
 861                 break;
 862         }
 863
 864         mainwin->SetStatusText(wxString(status, wxConvUTF8));
 865 }
 866
 867
 868 void EditArea::OffsetAllFrames(int dx, int dy)
 869 {
 870         SpriteRecord *sprite = CurSprite();
 871         int nframes = CurFrameCount();
 872
 873         for(int i=0;i<nframes;i++)
 874         {
 875                 sprite->frame[i].dir[gd.curdir].sheet_offset.x += dx;
 876                 sprite->frame[i].dir[gd.curdir].sheet_offset.y += dy;
 877         }
 878 }
 879
 880 /*
 881 void c------------------------------() {}
 882 */
 883
 884 bool EditArea::CreateZoomedSprite()
 885 {
 886         delete fZoomedSprite;
 887         fZoomedSprite = NULL;
 888
 889         // cut out a wximage from the spritesheet containing just the sprite we are interested in
 890         wxImage *sprite = sheetmgr.GetSprite(gd.cursprite, gd.curframe, gd.curdir);
 891         if (!sprite)
 892         {
 893                 staterr("CreateZoomedSprite: failed to GetSprite()");
 894                 return 1;
 895         }
 896
 897         // add alpha to the sprite by setting all black pixels to transparent
 898         int alphasize = (sprite->GetWidth() * sprite->GetHeight());
 899         uint8_t *alpha = (uint8_t *)malloc(alphasize);
 900         uint8_t *data = sprite->GetData();
 901         int i, j;
 902         for(i=j=0;i<alphasize;i++)
 903         {
 904                 if (data[j] == 0 && data[j+1] == 0 && data[j+2] == 0)
 905                 {
 906                         alpha[i] = 0;
 907                 }
 908                 else
 909                 {
 910                         alpha[i] = 255;
 911                 }
 912
 913                 j += 3;
 914         }
 915
 916         sprite->SetAlpha(alpha);
 917
 918         // zoom the sprite to the desired size
 919         int zoomw = CurSprite()->w * fZoom;
 920         int zoomh = CurSprite()->h * fZoom;
 921         sprite->Rescale(zoomw, zoomh);
 922
 923         // create a temporary offscreen memory DC of the appropriate size
 924         wxBitmap membmp(zoomw, zoomh);
 925         wxMemoryDC memdc(membmp);
 926
 927         // blit the background and sprite into the memory DC
 928         FillBackground(&memdc);
 929         memdc.DrawBitmap(wxBitmap(*sprite), 0, 0);
 930
 931         // obtain the image from the bitmap associated with the memory DC
 932         fZoomedSprite = new wxImage(membmp.ConvertToImage());
 933
 934         fZoomedSpriteSettings = GetZoomedSpriteSettings();
 935         delete sprite;
 936         return 0;
 937 }
 938
 939 ZoomedSpriteSettings EditArea::GetZoomedSpriteSettings()
 940 {
 941 ZoomedSpriteSettings set;
 942
 943         set.zoom = fZoom;
 944         set.sheet_x = CurDir()->sheet_offset.x;
 945         set.sheet_y = CurDir()->sheet_offset.y;
 946         set.sheetno = CurSprite()->spritesheet;
 947         set.w = CurSprite()->w;
 948         set.h = CurSprite()->h;
 949
 950         return set;
 951 }
 952
 953 bool ZoomedSpriteSettings::equ(ZoomedSpriteSettings other)
 954 {
 955         if (sheet_x != other.sheet_x) return false;
 956         if (sheet_y != other.sheet_y) return false;
 957         if (w != other.w) return false;
 958         if (h != other.h) return false;
 959         if (sheetno != other.sheetno) return false;
 960         if (zoom != other.zoom) return false;
 961
 962         return true;
 963 }
 964
 965 /*
 966 void c------------------------------() {}
 967 */
 968
 969 void EditArea::FillBackground(wxDC *dc)
 970 {
 971         if (!fBackground) return;
 972         wxBitmap bg(*fBackground);
 973
 974         int w = dc->GetSize().GetWidth();
 975         int h = dc->GetSize().GetHeight();
 976
 977         for(int y=0;y<h;y+=bg.GetWidth())
 978         for(int x=0;x<w;x+=bg.GetHeight())
 979         {
 980                 dc->DrawBitmap(bg, x, y);
 981         }
 982 }
 983
 984 void EditArea::RefreshNow()
 985 {
 986         #ifdef WIN32
 987                 wxClientDC dc(this);
 988                 Draw(&dc);
 989         #else
 990                 Refresh();
 991                 //Update();
 992         #endif
 993 }
 994
 995
 996
 997
 998
 999