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