src/apps/icon-o-matic/CanvasView.cpp

   1 /*
   2  * Copyright 2006-2007, 2011, Stephan Aßmus <superstippi@gmx.de>
   3  * All rights reserved. Distributed under the terms of the MIT License.
   4  */
   5
   6
   7 #include "CanvasView.h"
   8
   9 #include <Bitmap.h>
  10 #include <Cursor.h>
  11 #include <Message.h>
  12 #include <Region.h>
  13 #include <Window.h>
  14
  15 #include <stdio.h>
  16
  17 #include "cursors.h"
  18 #include "ui_defines.h"
  19
  20 #include "CommandStack.h"
  21 #include "IconRenderer.h"
  22
  23
  24 using std::nothrow;
  25
  26
  27 CanvasView::CanvasView(BRect frame)
  28         :
  29         StateView(frame, "canvas view", B_FOLLOW_ALL,
  30                 B_WILL_DRAW | B_FRAME_EVENTS),
  31         fBitmap(new BBitmap(BRect(0, 0, 63, 63), 0, B_RGB32)),
  32         fBackground(new BBitmap(BRect(0, 0, 63, 63), 0, B_RGB32)),
  33         fIcon(NULL),
  34         fRenderer(new IconRenderer(fBitmap)),
  35         fDirtyIconArea(fBitmap->Bounds()),
  36
  37         fCanvasOrigin(0.0, 0.0),
  38         fZoomLevel(8.0),
  39
  40         fSpaceHeldDown(false),
  41         fInScrollTo(false),
  42         fScrollTracking(false),
  43         fScrollTrackingStart(0.0, 0.0),
  44
  45         fMouseFilterMode(SNAPPING_OFF)
  46 {
  47         _MakeBackground();
  48         fRenderer->SetBackground(fBackground);
  49 }
  50
  51
  52 CanvasView::~CanvasView()
  53 {
  54         SetIcon(NULL);
  55         delete fRenderer;
  56         delete fBitmap;
  57         delete fBackground;
  58 }
  59
  60
  61 // #pragma mark -
  62
  63
  64 void
  65 CanvasView::AttachedToWindow()
  66 {
  67         StateView::AttachedToWindow();
  68
  69         SetViewColor(B_TRANSPARENT_COLOR);
  70         SetLowColor(kStripesHigh);
  71         SetHighColor(kStripesLow);
  72
  73         // init data rect for scrolling and center bitmap in the view
  74         BRect dataRect = _LayoutCanvas();
  75         SetDataRect(dataRect);
  76         BRect bounds(Bounds());
  77         BPoint dataRectCenter((dataRect.left + dataRect.right) / 2,
  78                 (dataRect.top + dataRect.bottom) / 2);
  79         BPoint boundsCenter((bounds.left + bounds.right) / 2,
  80                 (bounds.top + bounds.bottom) / 2);
  81         BPoint offset = ScrollOffset();
  82         offset.x = roundf(offset.x + dataRectCenter.x - boundsCenter.x);
  83         offset.y = roundf(offset.y + dataRectCenter.y - boundsCenter.y);
  84         SetScrollOffset(offset);
  85 }
  86
  87
  88 void
  89 CanvasView::FrameResized(float width, float height)
  90 {
  91         // keep canvas centered
  92         BPoint oldCanvasOrigin = fCanvasOrigin;
  93         SetDataRect(_LayoutCanvas());
  94         if (oldCanvasOrigin != fCanvasOrigin)
  95                 Invalidate();
  96 }
  97
  98
  99 void
 100 CanvasView::Draw(BRect updateRect)
 101 {
 102         _DrawInto(this, updateRect);
 103 }
 104
 105
 106 // #pragma mark -
 107
 108
 109 void
 110 CanvasView::MouseDown(BPoint where)
 111 {
 112         if (!IsFocus())
 113                 MakeFocus(true);
 114
 115         int32 buttons;
 116         if (Window()->CurrentMessage()->FindInt32("buttons", &buttons) < B_OK)
 117                 buttons = 0;
 118
 119         // handle clicks of the third mouse button ourselves (panning),
 120         // otherwise have StateView handle it (normal clicks)
 121         if (fSpaceHeldDown || (buttons & B_TERTIARY_MOUSE_BUTTON) != 0) {
 122                 // switch into scrolling mode and update cursor
 123                 fScrollTracking = true;
 124                 where.x = roundf(where.x);
 125                 where.y = roundf(where.y);
 126                 fScrollOffsetStart = ScrollOffset();
 127                 fScrollTrackingStart = where - fScrollOffsetStart;
 128                 _UpdateToolCursor();
 129                 SetMouseEventMask(B_POINTER_EVENTS,
 130                         B_LOCK_WINDOW_FOCUS | B_SUSPEND_VIEW_FOCUS);
 131         } else {
 132                 StateView::MouseDown(where);
 133         }
 134 }
 135
 136
 137 void
 138 CanvasView::MouseUp(BPoint where)
 139 {
 140         if (fScrollTracking) {
 141                 // stop scroll tracking and update cursor
 142                 fScrollTracking = false;
 143                 _UpdateToolCursor();
 144                 // update StateView mouse position
 145                 uint32 transit = Bounds().Contains(where) ?
 146                         B_INSIDE_VIEW : B_OUTSIDE_VIEW;
 147                 StateView::MouseMoved(where, transit, NULL);
 148         } else {
 149                 StateView::MouseUp(where);
 150         }
 151 }
 152
 153
 154 void
 155 CanvasView::MouseMoved(BPoint where, uint32 transit, const BMessage* dragMessage)
 156 {
 157         if (fScrollTracking) {
 158                 uint32 buttons;
 159                 GetMouse(&where, &buttons, false);
 160                 if (!buttons) {
 161                         MouseUp(where);
 162                         return;
 163                 }
 164                 where.x = roundf(where.x);
 165                 where.y = roundf(where.y);
 166                 where -= ScrollOffset();
 167                 BPoint offset = where - fScrollTrackingStart;
 168                 SetScrollOffset(fScrollOffsetStart - offset);
 169         } else {
 170                 // normal mouse movement handled by StateView
 171                 if (!fSpaceHeldDown)
 172                         StateView::MouseMoved(where, transit, dragMessage);
 173         }
 174 }
 175
 176
 177 void
 178 CanvasView::FilterMouse(BPoint* where) const
 179 {
 180         switch (fMouseFilterMode) {
 181
 182                 case SNAPPING_64:
 183                         ConvertToCanvas(where);
 184                         where->x = floorf(where->x + 0.5);
 185                         where->y = floorf(where->y + 0.5);
 186                         ConvertFromCanvas(where);
 187                         break;
 188
 189                 case SNAPPING_32:
 190                         ConvertToCanvas(where);
 191                         where->x /= 2.0;
 192                         where->y /= 2.0;
 193                         where->x = floorf(where->x + 0.5);
 194                         where->y = floorf(where->y + 0.5);
 195                         where->x *= 2.0;
 196                         where->y *= 2.0;
 197                         ConvertFromCanvas(where);
 198                         break;
 199
 200                 case SNAPPING_16:
 201                         ConvertToCanvas(where);
 202                         where->x /= 4.0;
 203                         where->y /= 4.0;
 204                         where->x = floorf(where->x + 0.5);
 205                         where->y = floorf(where->y + 0.5);
 206                         where->x *= 4.0;
 207                         where->y *= 4.0;
 208                         ConvertFromCanvas(where);
 209                         break;
 210
 211                 case SNAPPING_OFF:
 212                 default:
 213                         break;
 214         }
 215 }
 216
 217
 218 bool
 219 CanvasView::MouseWheelChanged(BPoint where, float x, float y)
 220 {
 221         if (!Bounds().Contains(where))
 222                 return false;
 223
 224         if (y > 0.0) {
 225                 _SetZoom(_NextZoomOutLevel(fZoomLevel), true);
 226                 return true;
 227         } else if (y < 0.0) {
 228                 _SetZoom(_NextZoomInLevel(fZoomLevel), true);
 229                 return true;
 230         }
 231         return false;
 232 }
 233
 234
 235 // #pragma mark -
 236
 237
 238 void
 239 CanvasView::SetScrollOffset(BPoint newOffset)
 240 {
 241         if (fInScrollTo)
 242                 return;
 243
 244         fInScrollTo = true;
 245
 246         newOffset = ValidScrollOffsetFor(newOffset);
 247         if (!fScrollTracking) {
 248                 BPoint mouseOffset = newOffset - ScrollOffset();
 249                 MouseMoved(fMouseInfo.position + mouseOffset, fMouseInfo.transit,
 250                         NULL);
 251         }
 252
 253         Scrollable::SetScrollOffset(newOffset);
 254
 255         fInScrollTo = false;
 256 }
 257
 258
 259 void
 260 CanvasView::ScrollOffsetChanged(BPoint oldOffset, BPoint newOffset)
 261 {
 262         BPoint offset = newOffset - oldOffset;
 263
 264         if (offset == B_ORIGIN) {
 265                 // prevent circular code (MouseMoved might call ScrollBy...)
 266                 return;
 267         }
 268
 269         ScrollBy(offset.x, offset.y);
 270 }
 271
 272
 273 void
 274 CanvasView::VisibleSizeChanged(float oldWidth, float oldHeight, float newWidth,
 275         float newHeight)
 276 {
 277         BRect dataRect(_LayoutCanvas());
 278         SetDataRect(dataRect);
 279 }
 280
 281
 282 // #pragma mark -
 283
 284
 285 void
 286 CanvasView::AreaInvalidated(const BRect& area)
 287 {
 288         if (fDirtyIconArea.Contains(area))
 289                 return;
 290
 291         fDirtyIconArea = fDirtyIconArea | area;
 292
 293         BRect viewArea(area);
 294         ConvertFromCanvas(&viewArea);
 295         Invalidate(viewArea);
 296 }
 297
 298
 299 // #pragma mark -
 300
 301
 302 void
 303 CanvasView::SetIcon(Icon* icon)
 304 {
 305         if (fIcon == icon)
 306                 return;
 307
 308         if (fIcon)
 309                 fIcon->RemoveListener(this);
 310
 311         fIcon = icon;
 312         fRenderer->SetIcon(icon);
 313
 314         if (fIcon)
 315                 fIcon->AddListener(this);
 316 }
 317
 318
 319 void
 320 CanvasView::SetMouseFilterMode(uint32 mode)
 321 {
 322         if (fMouseFilterMode == mode)
 323                 return;
 324
 325         fMouseFilterMode = mode;
 326         Invalidate(_CanvasRect());
 327 }
 328
 329
 330 void
 331 CanvasView::ConvertFromCanvas(BPoint* point) const
 332 {
 333         point->x = point->x * fZoomLevel + fCanvasOrigin.x;
 334         point->y = point->y * fZoomLevel + fCanvasOrigin.y;
 335 }
 336
 337
 338 void
 339 CanvasView::ConvertToCanvas(BPoint* point) const
 340 {
 341         point->x = (point->x - fCanvasOrigin.x) / fZoomLevel;
 342         point->y = (point->y - fCanvasOrigin.y) / fZoomLevel;
 343 }
 344
 345
 346 void
 347 CanvasView::ConvertFromCanvas(BRect* r) const
 348 {
 349         r->left = r->left * fZoomLevel + fCanvasOrigin.x;
 350         r->top = r->top * fZoomLevel + fCanvasOrigin.y;
 351         r->right++;
 352         r->bottom++;
 353         r->right = r->right * fZoomLevel + fCanvasOrigin.x;
 354         r->bottom = r->bottom * fZoomLevel + fCanvasOrigin.y;
 355         r->right--;
 356         r->bottom--;
 357 }
 358
 359
 360 void
 361 CanvasView::ConvertToCanvas(BRect* r) const
 362 {
 363         r->left = (r->left - fCanvasOrigin.x) / fZoomLevel;
 364         r->top = (r->top - fCanvasOrigin.y) / fZoomLevel;
 365         r->right = (r->right - fCanvasOrigin.x) / fZoomLevel;
 366         r->bottom = (r->bottom - fCanvasOrigin.y) / fZoomLevel;
 367 }
 368
 369
 370 // #pragma mark -
 371
 372
 373 bool
 374 CanvasView::_HandleKeyDown(uint32 key, uint32 modifiers)
 375 {
 376         switch (key) {
 377                 case 'z':
 378                 case 'y':
 379                         if (modifiers & B_SHIFT_KEY)
 380                                 CommandStack()->Redo();
 381                         else
 382                                 CommandStack()->Undo();
 383                         break;
 384
 385                 case '+':
 386                         _SetZoom(_NextZoomInLevel(fZoomLevel));
 387                         break;
 388                 case '-':
 389                         _SetZoom(_NextZoomOutLevel(fZoomLevel));
 390                         break;
 391
 392                 case B_SPACE:
 393                         fSpaceHeldDown = true;
 394                         _UpdateToolCursor();
 395                         break;
 396
 397                 default:
 398                         return StateView::_HandleKeyDown(key, modifiers);
 399         }
 400
 401         return true;
 402 }
 403
 404
 405 bool
 406 CanvasView::_HandleKeyUp(uint32 key, uint32 modifiers)
 407 {
 408         switch (key) {
 409                 case B_SPACE:
 410                         fSpaceHeldDown = false;
 411                         _UpdateToolCursor();
 412                         break;
 413
 414                 default:
 415                         return StateView::_HandleKeyUp(key, modifiers);
 416         }
 417
 418         return true;
 419 }
 420
 421
 422 BRect
 423 CanvasView::_CanvasRect() const
 424 {
 425         BRect r;
 426         if (fBitmap == NULL)
 427                 return r;
 428         r = fBitmap->Bounds();
 429         ConvertFromCanvas(&r);
 430         return r;
 431 }
 432
 433
 434 void
 435 CanvasView::_DrawInto(BView* view, BRect updateRect)
 436 {
 437         if (fDirtyIconArea.IsValid()) {
 438                 fRenderer->Render(fDirtyIconArea);
 439                 fDirtyIconArea.Set(LONG_MAX, LONG_MAX, LONG_MIN, LONG_MIN);
 440         }
 441
 442         // icon
 443         BRect canvas(_CanvasRect());
 444         view->DrawBitmap(fBitmap, fBitmap->Bounds(), canvas);
 445
 446         // grid
 447         int32 gridLines = 0;
 448         int32 scale = 1;
 449         switch (fMouseFilterMode) {
 450                 case SNAPPING_64:
 451                         gridLines = 63;
 452                         break;
 453                 case SNAPPING_32:
 454                         gridLines = 31;
 455                         scale = 2;
 456                         break;
 457                 case SNAPPING_16:
 458                         gridLines = 15;
 459                         scale = 4;
 460                         break;
 461                 case SNAPPING_OFF:
 462                 default:
 463                         break;
 464         }
 465         view->SetDrawingMode(B_OP_BLEND);
 466         for (int32 i = 1; i <= gridLines; i++) {
 467                 BPoint cross(i * scale, i * scale);
 468                 ConvertFromCanvas(&cross);
 469                 view->StrokeLine(BPoint(canvas.left, cross.y),
 470                                                  BPoint(canvas.right, cross.y));
 471                 view->StrokeLine(BPoint(cross.x, canvas.top),
 472                                                  BPoint(cross.x, canvas.bottom));
 473         }
 474         view->SetDrawingMode(B_OP_COPY);
 475
 476         // outside icon
 477         BRegion outside(Bounds() & updateRect);
 478         outside.Exclude(canvas);
 479         view->FillRegion(&outside, kStripes);
 480
 481         StateView::Draw(view, updateRect);
 482 }
 483
 484
 485 void
 486 CanvasView::_MakeBackground()
 487 {
 488         uint8* row = (uint8*)fBackground->Bits();
 489         uint32 bpr = fBackground->BytesPerRow();
 490         uint32 width = fBackground->Bounds().IntegerWidth() + 1;
 491         uint32 height = fBackground->Bounds().IntegerHeight() + 1;
 492
 493         const GammaTable& lut = fRenderer->GammaTable();
 494         uint8 redLow = lut.dir(kAlphaLow.red);
 495         uint8 greenLow = lut.dir(kAlphaLow.blue);
 496         uint8 blueLow = lut.dir(kAlphaLow.green);
 497         uint8 redHigh = lut.dir(kAlphaHigh.red);
 498         uint8 greenHigh = lut.dir(kAlphaHigh.blue);
 499         uint8 blueHigh = lut.dir(kAlphaHigh.green);
 500
 501         for (uint32 y = 0; y < height; y++) {
 502                 uint8* p = row;
 503                 for (uint32 x = 0; x < width; x++) {
 504                         p[3] = 255;
 505                         if (x % 8 >= 4) {
 506                                 if (y % 8 >= 4) {
 507                                         p[0] = blueLow;
 508                                         p[1] = greenLow;
 509                                         p[2] = redLow;
 510                                 } else {
 511                                         p[0] = blueHigh;
 512                                         p[1] = greenHigh;
 513                                         p[2] = redHigh;
 514                                 }
 515                         } else {
 516                                 if (y % 8 >= 4) {
 517                                         p[0] = blueHigh;
 518                                         p[1] = greenHigh;
 519                                         p[2] = redHigh;
 520                                 } else {
 521                                         p[0] = blueLow;
 522                                         p[1] = greenLow;
 523                                         p[2] = redLow;
 524                                 }
 525                         }
 526                         p += 4;
 527                 }
 528                 row += bpr;
 529         }
 530 }
 531
 532
 533 void
 534 CanvasView::_UpdateToolCursor()
 535 {
 536         if (fIcon) {
 537                 if (fScrollTracking || fSpaceHeldDown) {
 538                         // indicate scrolling mode
 539                         const uchar* cursorData = fScrollTracking ? kGrabCursor : kHandCursor;
 540                         BCursor cursor(cursorData);
 541                         SetViewCursor(&cursor, true);
 542                 } else {
 543                         // pass on to current state of StateView
 544                         UpdateStateCursor();
 545                 }
 546         } else {
 547                 BCursor cursor(kStopCursor);
 548                 SetViewCursor(&cursor, true);
 549         }
 550 }
 551
 552
 553 // #pragma mark -
 554
 555
 556 double
 557 CanvasView::_NextZoomInLevel(double zoom) const
 558 {
 559         if (zoom < 1)
 560                 return 1;
 561         if (zoom < 1.5)
 562                 return 1.5;
 563         if (zoom < 2)
 564                 return 2;
 565         if (zoom < 3)
 566                 return 3;
 567         if (zoom < 4)
 568                 return 4;
 569         if (zoom < 6)
 570                 return 6;
 571         if (zoom < 8)
 572                 return 8;
 573         if (zoom < 16)
 574                 return 16;
 575         if (zoom < 32)
 576                 return 32;
 577         return 64;
 578 }
 579
 580
 581 double
 582 CanvasView::_NextZoomOutLevel(double zoom) const
 583 {
 584         if (zoom > 32)
 585                 return 32;
 586         if (zoom > 16)
 587                 return 16;
 588         if (zoom > 8)
 589                 return 8;
 590         if (zoom > 6)
 591                 return 6;
 592         if (zoom > 4)
 593                 return 4;
 594         if (zoom > 3)
 595                 return 3;
 596         if (zoom > 2)
 597                 return 2;
 598         if (zoom > 1.5)
 599                 return 1.5;
 600         return 1;
 601 }
 602
 603
 604 void
 605 CanvasView::_SetZoom(double zoomLevel, bool mouseIsAnchor)
 606 {
 607         if (fZoomLevel == zoomLevel)
 608                 return;
 609
 610         BPoint anchor;
 611         if (mouseIsAnchor) {
 612                 // zoom into mouse position
 613                 anchor = MouseInfo()->position;
 614         } else {
 615                 // zoom into center of view
 616                 BRect bounds(Bounds());
 617                 anchor.x = (bounds.left + bounds.right + 1) / 2.0;
 618                 anchor.y = (bounds.top + bounds.bottom + 1) / 2.0;
 619         }
 620
 621         BPoint canvasAnchor = anchor;
 622         ConvertToCanvas(&canvasAnchor);
 623
 624         fZoomLevel = zoomLevel;
 625         BRect dataRect = _LayoutCanvas();
 626
 627         ConvertFromCanvas(&canvasAnchor);
 628
 629         BPoint offset = ScrollOffset();
 630         offset.x = roundf(offset.x + canvasAnchor.x - anchor.x);
 631         offset.y = roundf(offset.y + canvasAnchor.y - anchor.y);
 632
 633         Invalidate();
 634
 635         SetDataRectAndScrollOffset(dataRect, offset);
 636 }
 637
 638
 639 BRect
 640 CanvasView::_LayoutCanvas()
 641 {
 642         // size of zoomed bitmap
 643         BRect r(_CanvasRect());
 644         r.OffsetTo(B_ORIGIN);
 645
 646         // ask current view state to extend size
 647         // TODO: Ask StateViewState to extend bounds...
 648         BRect stateBounds = r; //ViewStateBounds();
 649
 650         // resize for empty area around bitmap
 651         // (the size we want, but might still be much smaller than view)
 652         r.InsetBy(-50, -50);
 653
 654         // center data rect in bounds
 655         BRect bounds(Bounds());
 656         if (bounds.Width() > r.Width())
 657                 r.InsetBy(-ceilf((bounds.Width() - r.Width()) / 2), 0);
 658         if (bounds.Height() > r.Height())
 659                 r.InsetBy(0, -ceilf((bounds.Height() - r.Height()) / 2));
 660
 661         if (stateBounds.IsValid()) {
 662                 stateBounds.InsetBy(-20, -20);
 663                 r = r | stateBounds;
 664         }
 665
 666         return r;
 667 }
 668