1 /* 2 * Copyright 2001-2020 Haiku, Inc. All rights reserved. 3 * Distributed under the terms of the MIT License. 4 */ 5 #ifndef _VIEW_H 6 #define _VIEW_H 7 8 9 #include <AffineTransform.h> 10 #include <Alignment.h> 11 #include <Font.h> 12 #include <Handler.h> 13 #include <InterfaceDefs.h> 14 #include <Rect.h> 15 #include <Gradient.h> 16 17 18 // mouse button 19 #define B_MOUSE_BUTTON(n) (1 << ((n) - 1)) 20 21 // Legacy BeOS R5 mouse button definitions 22 enum { 23 B_PRIMARY_MOUSE_BUTTON = B_MOUSE_BUTTON(1), 24 B_SECONDARY_MOUSE_BUTTON = B_MOUSE_BUTTON(2), 25 B_TERTIARY_MOUSE_BUTTON = B_MOUSE_BUTTON(3) 26 }; 27 28 // mouse transit 29 enum { 30 B_ENTERED_VIEW = 0, 31 B_INSIDE_VIEW, 32 B_EXITED_VIEW, 33 B_OUTSIDE_VIEW 34 }; 35 36 // event mask 37 enum { 38 B_POINTER_EVENTS = 0x00000001, 39 B_KEYBOARD_EVENTS = 0x00000002 40 }; 41 42 // event mask options 43 enum { 44 B_LOCK_WINDOW_FOCUS = 0x00000001, 45 B_SUSPEND_VIEW_FOCUS = 0x00000002, 46 B_NO_POINTER_HISTORY = 0x00000004, 47 // NOTE: This is the default behavior in Haiku, unlike in BeOS 48 B_FULL_POINTER_HISTORY = 0x00000008 49 // NOTE: New in Haiku (unless this flag is 50 // specified, both BWindow and BView::GetMouse() 51 // will filter out older mouse moved messages) 52 }; 53 54 enum rect_tracking_style { 55 B_TRACK_WHOLE_RECT, 56 B_TRACK_RECT_CORNER 57 }; 58 59 // set font mask 60 enum set_font_mask { 61 B_FONT_FAMILY_AND_STYLE = 0x00000001, 62 B_FONT_SIZE = 0x00000002, 63 B_FONT_SHEAR = 0x00000004, 64 B_FONT_ROTATION = 0x00000008, 65 B_FONT_SPACING = 0x00000010, 66 B_FONT_ENCODING = 0x00000020, 67 B_FONT_FACE = 0x00000040, 68 B_FONT_FLAGS = 0x00000080, 69 B_FONT_FALSE_BOLD_WIDTH = 0x00000100, 70 B_FONT_ALL = 0x000001FF 71 }; 72 73 typedef enum { 74 B_CURRENT_STATE_COORDINATES, 75 B_PREVIOUS_STATE_COORDINATES, 76 B_VIEW_COORDINATES, 77 B_PARENT_VIEW_DRAW_COORDINATES, 78 B_PARENT_VIEW_COORDINATES, 79 B_WINDOW_COORDINATES, 80 B_SCREEN_COORDINATES 81 } coordinate_space; 82 83 // view flags 84 const uint32 B_FULL_UPDATE_ON_RESIZE = 0x80000000UL; /* 31 */ 85 const uint32 _B_RESERVED1_ = 0x40000000UL; /* 30 */ 86 const uint32 B_WILL_DRAW = 0x20000000UL; /* 29 */ 87 const uint32 B_PULSE_NEEDED = 0x10000000UL; /* 28 */ 88 const uint32 B_NAVIGABLE_JUMP = 0x08000000UL; /* 27 */ 89 const uint32 B_FRAME_EVENTS = 0x04000000UL; /* 26 */ 90 const uint32 B_NAVIGABLE = 0x02000000UL; /* 25 */ 91 const uint32 B_SUBPIXEL_PRECISE = 0x01000000UL; /* 24 */ 92 const uint32 B_DRAW_ON_CHILDREN = 0x00800000UL; /* 23 */ 93 const uint32 B_INPUT_METHOD_AWARE = 0x00400000UL; /* 22 */ 94 const uint32 B_SCROLL_VIEW_AWARE = 0x00200000UL; /* 21 */ 95 const uint32 B_SUPPORTS_LAYOUT = 0x00100000UL; /* 20 */ 96 const uint32 B_INVALIDATE_AFTER_LAYOUT = 0x00080000UL; /* 19 */ 97 const uint32 B_TRANSPARENT_BACKGROUND = 0x00040000UL; /* 18 */ 98 99 #define _RESIZE_MASK_ (0xffff) 100 101 const uint32 _VIEW_TOP_ = 1UL; 102 const uint32 _VIEW_LEFT_ = 2UL; 103 const uint32 _VIEW_BOTTOM_ = 3UL; 104 const uint32 _VIEW_RIGHT_ = 4UL; 105 const uint32 _VIEW_CENTER_ = 5UL; 106 107 #define _rule_(r1, r2, r3, r4) (((r1) << 12) | ((r2) << 8) | ((r3) << 4) | (r4)) 108 109 const uint32 B_FOLLOW_NONE = 0; 110 const uint32 B_FOLLOW_ALL_SIDES = _rule_(_VIEW_TOP_, _VIEW_LEFT_, 111 _VIEW_BOTTOM_, _VIEW_RIGHT_); 112 const uint32 B_FOLLOW_ALL = B_FOLLOW_ALL_SIDES; 113 114 const uint32 B_FOLLOW_LEFT = _rule_(0, _VIEW_LEFT_, 0, _VIEW_LEFT_); 115 const uint32 B_FOLLOW_RIGHT = _rule_(0, _VIEW_RIGHT_, 0, _VIEW_RIGHT_); 116 const uint32 B_FOLLOW_LEFT_RIGHT = _rule_(0, _VIEW_LEFT_, 0, _VIEW_RIGHT_); 117 const uint32 B_FOLLOW_H_CENTER = _rule_(0, _VIEW_CENTER_, 0, _VIEW_CENTER_); 118 119 const uint32 B_FOLLOW_TOP = _rule_(_VIEW_TOP_, 0, _VIEW_TOP_, 0); 120 const uint32 B_FOLLOW_BOTTOM = _rule_(_VIEW_BOTTOM_, 0, _VIEW_BOTTOM_, 0); 121 const uint32 B_FOLLOW_TOP_BOTTOM = _rule_(_VIEW_TOP_, 0, _VIEW_BOTTOM_, 0); 122 const uint32 B_FOLLOW_V_CENTER = _rule_(_VIEW_CENTER_, 0, _VIEW_CENTER_, 0); 123 124 const uint32 B_FOLLOW_LEFT_TOP = B_FOLLOW_TOP | B_FOLLOW_LEFT; 125 126 class BBitmap; 127 class BCursor; 128 class BLayout; 129 class BLayoutContext; 130 class BLayoutItem; 131 class BMessage; 132 class BPicture; 133 class BPolygon; 134 class BRegion; 135 class BScrollBar; 136 class BScrollView; 137 class BShape; 138 class BShelf; 139 class BString; 140 class BToolTip; 141 class BWindow; 142 struct _array_data_; 143 struct _array_hdr_; 144 struct overlay_restrictions; 145 146 namespace BPrivate { 147 class ViewState; 148 }; 149 150 151 class BView : public BHandler { 152 public: 153 BView(const char* name, uint32 flags, 154 BLayout* layout = NULL); 155 BView(BRect frame, const char* name, 156 uint32 resizingMode, uint32 flags); 157 virtual ~BView(); 158 159 BView(BMessage* archive); 160 static BArchivable* Instantiate(BMessage* archive); 161 virtual status_t Archive(BMessage* archive, 162 bool deep = true) const; 163 virtual status_t AllUnarchived(const BMessage* archive); 164 virtual status_t AllArchived(BMessage* archive) const; 165 166 virtual void AttachedToWindow(); 167 virtual void AllAttached(); 168 virtual void DetachedFromWindow(); 169 virtual void AllDetached(); 170 171 virtual void MessageReceived(BMessage* message); 172 173 void AddChild(BView* child, BView* before = NULL); 174 bool AddChild(BLayoutItem* child); 175 bool RemoveChild(BView* child); 176 int32 CountChildren() const; 177 BView* ChildAt(int32 index) const; 178 BView* NextSibling() const; 179 BView* PreviousSibling() const; 180 bool RemoveSelf(); 181 182 BWindow* Window() const; 183 184 virtual void Draw(BRect updateRect); 185 virtual void MouseDown(BPoint where); 186 virtual void MouseUp(BPoint where); 187 virtual void MouseMoved(BPoint where, uint32 code, 188 const BMessage* dragMessage); 189 virtual void WindowActivated(bool active); 190 virtual void KeyDown(const char* bytes, int32 numBytes); 191 virtual void KeyUp(const char* bytes, int32 numBytes); 192 virtual void Pulse(); 193 virtual void FrameMoved(BPoint newPosition); 194 virtual void FrameResized(float newWidth, float newHeight); 195 196 virtual void TargetedByScrollView(BScrollView* scrollView); 197 void BeginRectTracking(BRect startRect, 198 uint32 style = B_TRACK_WHOLE_RECT); 199 void EndRectTracking(); 200 201 void GetMouse(BPoint* location, uint32* buttons, 202 bool checkMessageQueue = true); 203 204 void DragMessage(BMessage* message, BRect dragRect, 205 BHandler* replyTo = NULL); 206 void DragMessage(BMessage* message, BBitmap* bitmap, 207 BPoint offset, BHandler* replyTo = NULL); 208 void DragMessage(BMessage* message, BBitmap* bitmap, 209 drawing_mode dragMode, BPoint offset, 210 BHandler* replyTo = NULL); 211 212 BView* FindView(const char* name) const; 213 BView* Parent() const; 214 BRect Bounds() const; 215 BRect Frame() const; 216 void ConvertToScreen(BPoint* point) const; 217 BPoint ConvertToScreen(BPoint point) const; 218 void ConvertFromScreen(BPoint* point) const; 219 BPoint ConvertFromScreen(BPoint point) const; 220 void ConvertToScreen(BRect* rect) const; 221 BRect ConvertToScreen(BRect rect) const; 222 void ConvertFromScreen(BRect* rect) const; 223 BRect ConvertFromScreen(BRect rect) const; 224 void ConvertToParent(BPoint* point) const; 225 BPoint ConvertToParent(BPoint point) const; 226 void ConvertFromParent(BPoint* point) const; 227 BPoint ConvertFromParent(BPoint point) const; 228 void ConvertToParent(BRect* rect) const; 229 BRect ConvertToParent(BRect rect) const; 230 void ConvertFromParent(BRect* rect) const; 231 BRect ConvertFromParent(BRect rect) const; 232 BPoint LeftTop() const; 233 234 void GetClippingRegion(BRegion* region) const; 235 virtual void ConstrainClippingRegion(BRegion* region); 236 void ClipToPicture(BPicture* picture, 237 BPoint where = B_ORIGIN, bool sync = true); 238 void ClipToInversePicture(BPicture* picture, 239 BPoint where = B_ORIGIN, bool sync = true); 240 241 void ClipToRect(BRect rect); 242 void ClipToInverseRect(BRect rect); 243 void ClipToShape(BShape* shape); 244 void ClipToInverseShape(BShape* shape); 245 246 virtual void SetDrawingMode(drawing_mode mode); 247 drawing_mode DrawingMode() const; 248 249 void SetBlendingMode(source_alpha srcAlpha, 250 alpha_function alphaFunc); 251 void GetBlendingMode(source_alpha* srcAlpha, 252 alpha_function* alphaFunc) const; 253 254 virtual void SetPenSize(float size); 255 float PenSize() const; 256 257 void SetViewCursor(const BCursor* cursor, 258 bool sync = true); 259 260 bool HasDefaultColors() const; 261 bool HasSystemColors() const; 262 void AdoptParentColors(); 263 void AdoptSystemColors(); 264 void AdoptViewColors(BView* view); 265 266 virtual void SetViewColor(rgb_color color); 267 void SetViewColor(uchar red, uchar green, uchar blue, 268 uchar alpha = 255); 269 rgb_color ViewColor() const; 270 271 void SetViewUIColor(color_which which, 272 float tint = B_NO_TINT); 273 color_which ViewUIColor(float* tint = NULL) const; 274 275 void SetViewBitmap(const BBitmap* bitmap, 276 BRect srcRect, BRect dstRect, 277 uint32 followFlags = B_FOLLOW_LEFT_TOP, 278 uint32 options = B_TILE_BITMAP); 279 void SetViewBitmap(const BBitmap* bitmap, 280 uint32 followFlags = B_FOLLOW_LEFT_TOP, 281 uint32 options = B_TILE_BITMAP); 282 void ClearViewBitmap(); 283 284 status_t SetViewOverlay(const BBitmap* overlay, 285 BRect srcRect, BRect dstRect, 286 rgb_color* colorKey, 287 uint32 followFlags = B_FOLLOW_LEFT_TOP, 288 uint32 options = 0); 289 status_t SetViewOverlay(const BBitmap* overlay, 290 rgb_color* colorKey, 291 uint32 followFlags = B_FOLLOW_LEFT_TOP, 292 uint32 options = 0); 293 void ClearViewOverlay(); 294 295 virtual void SetHighColor(rgb_color color); 296 void SetHighColor(uchar red, uchar green, uchar blue, 297 uchar alpha = 255); 298 rgb_color HighColor() const; 299 300 void SetHighUIColor(color_which which, 301 float tint = B_NO_TINT); 302 color_which HighUIColor(float* tint = NULL) const; 303 304 virtual void SetLowColor(rgb_color color); 305 void SetLowColor(uchar red, uchar green, uchar blue, 306 uchar alpha = 255); 307 rgb_color LowColor() const; 308 309 void SetLowUIColor(color_which which, 310 float tint = B_NO_TINT); 311 color_which LowUIColor(float* tint = NULL) const; 312 313 void SetLineMode(cap_mode lineCap, 314 join_mode lineJoin, 315 float miterLimit = B_DEFAULT_MITER_LIMIT); 316 join_mode LineJoinMode() const; 317 cap_mode LineCapMode() const; 318 float LineMiterLimit() const; 319 320 void SetFillRule(int32 rule); 321 int32 FillRule() const; 322 323 void SetOrigin(BPoint where); 324 void SetOrigin(float x, float y); 325 BPoint Origin() const; 326 327 // Works in addition to Origin and Scale. 328 // May be used in parallel or as a much 329 // more powerful alternative. 330 void SetTransform(BAffineTransform transform); 331 BAffineTransform Transform() const; 332 void TranslateBy(double x, double y); 333 void ScaleBy(double x, double y); 334 void RotateBy(double angleRadians); 335 336 BAffineTransform TransformTo(coordinate_space basis) const; 337 338 void PushState(); 339 void PopState(); 340 341 void MovePenTo(BPoint pt); 342 void MovePenTo(float x, float y); 343 void MovePenBy(float x, float y); 344 BPoint PenLocation() const; 345 void StrokeLine(BPoint toPoint, 346 ::pattern pattern = B_SOLID_HIGH); 347 void StrokeLine(BPoint start, BPoint end, 348 ::pattern pattern = B_SOLID_HIGH); 349 void BeginLineArray(int32 count); 350 void AddLine(BPoint start, BPoint end, 351 rgb_color color); 352 void EndLineArray(); 353 354 void StrokePolygon(const BPolygon* polygon, 355 bool closed = true, 356 ::pattern pattern = B_SOLID_HIGH); 357 void StrokePolygon(const BPoint* pointArray, 358 int32 numPoints, bool closed = true, 359 ::pattern pattern = B_SOLID_HIGH); 360 void StrokePolygon(const BPoint* pointArray, 361 int32 numPoints, BRect bounds, 362 bool closed = true, 363 ::pattern pattern = B_SOLID_HIGH); 364 void FillPolygon(const BPolygon* polygon, 365 ::pattern pattern = B_SOLID_HIGH); 366 void FillPolygon(const BPoint* pointArray, 367 int32 numPoints, 368 ::pattern pattern = B_SOLID_HIGH); 369 void FillPolygon(const BPoint* pointArray, 370 int32 numPoints, BRect bounds, 371 ::pattern pattern = B_SOLID_HIGH); 372 void FillPolygon(const BPolygon* polygon, 373 const BGradient& gradient); 374 void FillPolygon(const BPoint* pointArray, 375 int32 numPoints, const BGradient& gradient); 376 void FillPolygon(const BPoint* pointArray, 377 int32 numPoints, BRect bounds, 378 const BGradient& gradient); 379 380 void StrokeTriangle(BPoint point1, BPoint point2, 381 BPoint point3, BRect bounds, 382 ::pattern pattern = B_SOLID_HIGH); 383 void StrokeTriangle(BPoint point1, BPoint point2, 384 BPoint point3, 385 ::pattern pattern = B_SOLID_HIGH); 386 void FillTriangle(BPoint point1, BPoint point2, 387 BPoint point3, 388 ::pattern pattern = B_SOLID_HIGH); 389 void FillTriangle(BPoint point1, BPoint point2, 390 BPoint point3, BRect bounds, 391 ::pattern pattern = B_SOLID_HIGH); 392 void FillTriangle(BPoint point1, BPoint point2, 393 BPoint point3, const BGradient& gradient); 394 void FillTriangle(BPoint point1, BPoint point2, 395 BPoint point3, BRect bounds, 396 const BGradient& gradient); 397 398 void StrokeRect(BRect rect, 399 ::pattern pattern = B_SOLID_HIGH); 400 void FillRect(BRect rect, 401 ::pattern pattern = B_SOLID_HIGH); 402 void FillRect(BRect rect, const BGradient& gradient); 403 void FillRegion(BRegion* rectegion, 404 ::pattern pattern = B_SOLID_HIGH); 405 void FillRegion(BRegion* rectegion, 406 const BGradient& gradient); 407 void InvertRect(BRect rect); 408 409 void StrokeRoundRect(BRect rect, float xRadius, 410 float yRadius, 411 ::pattern pattern = B_SOLID_HIGH); 412 void FillRoundRect(BRect rect, float xRadius, 413 float yRadius, 414 ::pattern pattern = B_SOLID_HIGH); 415 void FillRoundRect(BRect rect, float xRadius, 416 float yRadius, const BGradient& gradient); 417 418 void StrokeEllipse(BPoint center, float xRadius, 419 float yRadius, 420 ::pattern pattern = B_SOLID_HIGH); 421 void StrokeEllipse(BRect rect, 422 ::pattern pattern = B_SOLID_HIGH); 423 void FillEllipse(BPoint center, float xRadius, 424 float yRadius, 425 ::pattern pattern = B_SOLID_HIGH); 426 void FillEllipse(BRect rect, 427 ::pattern pattern = B_SOLID_HIGH); 428 void FillEllipse(BPoint center, float xRadius, 429 float yRadius, const BGradient& gradient); 430 void FillEllipse(BRect rect, 431 const BGradient& gradient); 432 433 void StrokeArc(BPoint center, float xRadius, 434 float yRadius, float startAngle, 435 float arcAngle, 436 ::pattern pattern = B_SOLID_HIGH); 437 void StrokeArc(BRect rect, float startAngle, 438 float arcAngle, 439 ::pattern pattern = B_SOLID_HIGH); 440 void FillArc(BPoint center, float xRadius, 441 float yRadius, float startAngle, 442 float arcAngle, 443 ::pattern pattern = B_SOLID_HIGH); 444 void FillArc(BRect rect, float startAngle, 445 float arcAngle, 446 ::pattern pattern = B_SOLID_HIGH); 447 void FillArc(BPoint center, float xRadius, 448 float yRadius, float startAngle, 449 float arcAngle, const BGradient& gradient); 450 void FillArc(BRect rect, float startAngle, 451 float arcAngle, const BGradient& gradient); 452 453 void StrokeBezier(BPoint* controlPoints, 454 ::pattern pattern = B_SOLID_HIGH); 455 void FillBezier(BPoint* controlPoints, 456 ::pattern pattern = B_SOLID_HIGH); 457 void FillBezier(BPoint* controlPoints, 458 const BGradient& gradient); 459 460 void StrokeShape(BShape* shape, 461 ::pattern pattern = B_SOLID_HIGH); 462 void FillShape(BShape* shape, 463 ::pattern pattern = B_SOLID_HIGH); 464 void FillShape(BShape* shape, 465 const BGradient& gradient); 466 467 void CopyBits(BRect src, BRect dst); 468 469 void DrawBitmapAsync(const BBitmap* aBitmap, 470 BRect bitmapRect, BRect viewRect, 471 uint32 options); 472 void DrawBitmapAsync(const BBitmap* aBitmap, 473 BRect bitmapRect, BRect viewRect); 474 void DrawBitmapAsync(const BBitmap* aBitmap, 475 BRect viewRect); 476 void DrawBitmapAsync(const BBitmap* aBitmap, 477 BPoint where); 478 void DrawBitmapAsync(const BBitmap* aBitmap); 479 480 void DrawBitmap(const BBitmap* aBitmap, 481 BRect bitmapRect, BRect viewRect, 482 uint32 options); 483 void DrawBitmap(const BBitmap* aBitmap, 484 BRect bitmapRect, BRect viewRect); 485 void DrawBitmap(const BBitmap* aBitmap, 486 BRect viewRect); 487 void DrawBitmap(const BBitmap* aBitmap, 488 BPoint where); 489 void DrawBitmap(const BBitmap* aBitmap); 490 491 void DrawTiledBitmapAsync(const BBitmap* aBitmap, 492 BRect viewRect, BPoint phase = B_ORIGIN); 493 494 void DrawTiledBitmap(const BBitmap* aBitmap, 495 BRect viewRect, BPoint phase = B_ORIGIN); 496 497 void DrawChar(char aChar); 498 void DrawChar(char aChar, BPoint location); 499 void DrawString(const char* string, 500 escapement_delta* delta = NULL); 501 void DrawString(const char* string, 502 BPoint location, 503 escapement_delta* delta = NULL); 504 void DrawString(const char* string, int32 length, 505 escapement_delta* delta = NULL); 506 void DrawString(const char* string, int32 length, 507 BPoint location, 508 escapement_delta* delta = 0L); 509 void DrawString(const char* string, 510 const BPoint* locations, 511 int32 locationCount); 512 void DrawString(const char* string, int32 length, 513 const BPoint* locations, 514 int32 locationCount); 515 516 virtual void SetFont(const BFont* font, 517 uint32 mask = B_FONT_ALL); 518 519 void GetFont(BFont* font) const; 520 void TruncateString(BString* in_out, uint32 mode, 521 float width) const; 522 float StringWidth(const char* string) const; 523 float StringWidth(const char* string, 524 int32 length) const; 525 void GetStringWidths(char* stringArray[], 526 int32 lengthArray[], int32 numStrings, 527 float widthArray[]) const; 528 void SetFontSize(float size); 529 void ForceFontAliasing(bool enable); 530 void GetFontHeight(font_height* height) const; 531 532 void Invalidate(BRect invalRect); 533 void Invalidate(const BRegion* invalRegion); 534 void Invalidate(); 535 void DelayedInvalidate(bigtime_t delay); 536 void DelayedInvalidate(bigtime_t delay, 537 BRect invalRect); 538 539 void SetDiskMode(char* filename, long offset); 540 541 void BeginPicture(BPicture* a_picture); 542 void AppendToPicture(BPicture* a_picture); 543 BPicture* EndPicture(); 544 545 void DrawPicture(const BPicture* a_picture); 546 void DrawPicture(const BPicture* a_picture, 547 BPoint where); 548 void DrawPicture(const char* filename, long offset, 549 BPoint where); 550 void DrawPictureAsync(const BPicture* a_picture); 551 void DrawPictureAsync(const BPicture* a_picture, 552 BPoint where); 553 void DrawPictureAsync(const char* filename, 554 long offset, BPoint where); 555 556 void BeginLayer(uint8 opacity); 557 void EndLayer(); 558 559 status_t SetEventMask(uint32 mask, uint32 options = 0); 560 uint32 EventMask(); 561 status_t SetMouseEventMask(uint32 mask, 562 uint32 options = 0); 563 564 virtual void SetFlags(uint32 flags); 565 uint32 Flags() const; 566 virtual void SetResizingMode(uint32 mode); 567 uint32 ResizingMode() const; 568 void MoveBy(float dh, float dv); 569 void MoveTo(BPoint where); 570 void MoveTo(float x, float y); 571 void ResizeBy(float dh, float dv); 572 void ResizeTo(float width, float height); 573 void ResizeTo(BSize size); 574 void ScrollBy(float dh, float dv); 575 void ScrollTo(float x, float y); 576 virtual void ScrollTo(BPoint where); 577 virtual void MakeFocus(bool focus = true); 578 bool IsFocus() const; 579 580 virtual void Show(); 581 virtual void Hide(); 582 bool IsHidden() const; 583 bool IsHidden(const BView* looking_from) const; 584 585 void Flush() const; 586 void Sync() const; 587 588 virtual void GetPreferredSize(float* _width, float* _height); 589 virtual void ResizeToPreferred(); 590 591 BScrollBar* ScrollBar(orientation direction) const; 592 593 virtual BHandler* ResolveSpecifier(BMessage* message, int32 index, 594 BMessage* specifier, int32 form, 595 const char* property); 596 virtual status_t GetSupportedSuites(BMessage* data); 597 598 bool IsPrinting() const; 599 void SetScale(float scale) const; 600 float Scale() const; 601 // new for Haiku 602 603 virtual status_t Perform(perform_code code, void* data); 604 605 virtual void DrawAfterChildren(BRect updateRect); 606 607 // layout related 608 609 virtual BSize MinSize(); 610 virtual BSize MaxSize(); 611 virtual BSize PreferredSize(); 612 virtual BAlignment LayoutAlignment(); 613 614 void SetExplicitMinSize(BSize size); 615 void SetExplicitMaxSize(BSize size); 616 void SetExplicitPreferredSize(BSize size); 617 void SetExplicitSize(BSize size); 618 void SetExplicitAlignment(BAlignment alignment); 619 620 BSize ExplicitMinSize() const; 621 BSize ExplicitMaxSize() const; 622 BSize ExplicitPreferredSize() const; 623 BAlignment ExplicitAlignment() const; 624 625 virtual bool HasHeightForWidth(); 626 virtual void GetHeightForWidth(float width, float* min, 627 float* max, float* preferred); 628 629 void InvalidateLayout(bool descendants = false); 630 virtual void SetLayout(BLayout* layout); 631 BLayout* GetLayout() const; 632 633 void EnableLayoutInvalidation(); 634 void DisableLayoutInvalidation(); 635 bool IsLayoutInvalidationDisabled(); 636 bool IsLayoutValid() const; 637 void ResetLayoutInvalidation(); 638 639 BLayoutContext* LayoutContext() const; 640 641 void Layout(bool force); 642 void Relayout(); 643 644 class Private; 645 646 protected: 647 virtual void LayoutInvalidated(bool descendants = false); 648 virtual void DoLayout(); 649 650 public: 651 // tool tip support 652 653 void SetToolTip(const char* text); 654 void SetToolTip(BToolTip* tip); 655 BToolTip* ToolTip() const; 656 657 void ShowToolTip(BToolTip* tip = NULL); 658 void HideToolTip(); 659 660 protected: 661 virtual bool GetToolTipAt(BPoint point, BToolTip** _tip); 662 663 virtual void LayoutChanged(); 664 665 status_t ScrollWithMouseWheelDelta(BScrollBar*, float); 666 667 private: 668 void _Layout(bool force, BLayoutContext* context); 669 void _LayoutLeft(BLayout* deleted); 670 void _InvalidateParentLayout(); 671 672 private: 673 // FBC padding and forbidden methods 674 virtual void _ReservedView13(); 675 virtual void _ReservedView14(); 676 virtual void _ReservedView15(); 677 virtual void _ReservedView16(); 678 679 BView(const BView&); 680 BView& operator=(const BView&); 681 682 private: 683 struct LayoutData; 684 685 friend class Private; 686 friend class BBitmap; 687 friend class BLayout; 688 friend class BPrintJob; 689 friend class BScrollBar; 690 friend class BShelf; 691 friend class BTabView; 692 friend class BWindow; 693 694 void _InitData(BRect frame, const char* name, 695 uint32 resizingMode, uint32 flags); 696 status_t _SetViewBitmap(const BBitmap* bitmap, 697 BRect srcRect, BRect dstRect, 698 uint32 followFlags, uint32 options); 699 void _ClipToPicture(BPicture* picture, BPoint where, 700 bool invert, bool sync); 701 702 void _ClipToRect(BRect rect, bool inverse); 703 void _ClipToShape(BShape* shape, bool inverse); 704 705 bool _CheckOwnerLockAndSwitchCurrent() const; 706 bool _CheckOwnerLock() const; 707 void _CheckLockAndSwitchCurrent() const; 708 void _CheckLock() const; 709 void _SwitchServerCurrentView() const; 710 711 void _SetOwner(BWindow* newOwner); 712 void _RemoveCommArray(); 713 714 BShelf* _Shelf() const; 715 void _SetShelf(BShelf* shelf); 716 717 void _MoveTo(int32 x, int32 y); 718 void _ResizeBy(int32 deltaWidth, int32 deltaHeight); 719 void _ParentResizedBy(int32 deltaWidth, 720 int32 deltaHeight); 721 722 void _ConvertToScreen(BPoint* pt, 723 bool checkLock) const; 724 void _ConvertFromScreen(BPoint* pt, 725 bool checkLock) const; 726 727 void _ConvertToParent(BPoint* pt, 728 bool checkLock) const; 729 void _ConvertFromParent(BPoint* pt, 730 bool checkLock) const; 731 732 void _Activate(bool state); 733 void _Attach(); 734 void _ColorsUpdated(BMessage* message); 735 void _Detach(); 736 void _Draw(BRect screenUpdateRect); 737 void _DrawAfterChildren(BRect screenUpdateRect); 738 void _FontsUpdated(BMessage*); 739 void _Pulse(); 740 741 void _UpdateStateForRemove(); 742 void _UpdatePattern(::pattern pattern); 743 744 void _FlushIfNotInTransaction(); 745 746 bool _CreateSelf(); 747 bool _AddChildToList(BView* child, 748 BView* before = NULL); 749 bool _RemoveChildFromList(BView* child); 750 751 bool _AddChild(BView *child, BView *before); 752 bool _RemoveSelf(); 753 void _RemoveLayoutItemsFromLayout(bool deleteItems); 754 755 // Debugging methods 756 void _PrintToStream(); 757 void _PrintTree(); 758 759 int32 _unused_int1; 760 761 uint32 fFlags; 762 BPoint fParentOffset; 763 BWindow* fOwner; 764 BView* fParent; 765 BView* fNextSibling; 766 BView* fPreviousSibling; 767 BView* fFirstChild; 768 769 int16 fShowLevel; 770 bool fTopLevelView; 771 bool fNoISInteraction; 772 BPicture* fCurrentPicture; 773 _array_data_* fCommArray; 774 775 BScrollBar* fVerScroller; 776 BScrollBar* fHorScroller; 777 bool fIsPrinting; 778 bool fAttached; 779 bool _unused_bool1; 780 bool _unused_bool2; 781 ::BPrivate::ViewState* fState; 782 BRect fBounds; 783 BShelf* fShelf; 784 uint32 fEventMask; 785 uint32 fEventOptions; 786 uint32 fMouseEventOptions; 787 788 LayoutData* fLayoutData; 789 BToolTip* fToolTip; 790 791 uint32 _reserved[6]; 792 }; 793 794 795 // #pragma mark - inline definitions 796 797 798 inline void 799 BView::ScrollTo(float x, float y) 800 { 801 ScrollTo(BPoint(x, y)); 802 } 803 804 805 inline void 806 BView::SetViewColor(uchar red, uchar green, uchar blue, uchar alpha) 807 { 808 rgb_color color; 809 color.red = red; 810 color.green = green; 811 color.blue = blue; 812 color.alpha = alpha; 813 SetViewColor(color); 814 } 815 816 817 inline void 818 BView::SetHighColor(uchar red, uchar green, uchar blue, uchar alpha) 819 { 820 rgb_color color; 821 color.red = red; 822 color.green = green; 823 color.blue = blue; 824 color.alpha = alpha; 825 SetHighColor(color); 826 } 827 828 829 inline void 830 BView::SetLowColor(uchar red, uchar green, uchar blue, uchar alpha) 831 { 832 rgb_color color; 833 color.red = red; 834 color.green = green; 835 color.blue = blue; 836 color.alpha = alpha; 837 SetLowColor(color); 838 } 839 840 841 #endif // _VIEW_H 842