xref: /haiku/headers/os/interface/View.h (revision e1c4049fed1047bdb957b0529e1921e97ef94770)
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