xref: /haiku/src/kits/interface/ScrollView.cpp (revision bf57c148f7787f0df15980976997c6dfb70ee067) 
1 /*
2  * Copyright 2004-2009, Axel Dörfler, axeld@pinc-software.de.
3  * Copyright 2009 Stephan Aßmus, superstippi@gmx.de.
4  * Copyright 2014 Haiku, Inc. All rights reserved.
5  * Distributed under the terms of the MIT License.
6  *
7  * Authors:
8  *		Stephan Aßmus, superstippi@gmx.de
9  *		Axel Dörfler, axeld@pinc-software.de
10  *		John Scipione, jscpione@gmail.com
11  */
12 
13 
14 #include <ScrollView.h>
15 
16 #include <ControlLook.h>
17 #include <LayoutUtils.h>
18 #include <Message.h>
19 #include <Region.h>
20 #include <Window.h>
21 
22 #include <binary_compatibility/Interface.h>
23 
24 
25 static const float kFancyBorderSize = 2;
26 static const float kPlainBorderSize = 1;
27 
28 
29 BScrollView::BScrollView(const char* name, BView* target, uint32 resizingMode,
30 	uint32 flags, bool horizontal, bool vertical, border_style border)
31 	:
32 	BView(_ComputeFrame(target, horizontal, vertical, border), name,
33 		resizingMode, _ModifyFlags(flags, border)),
34 	fTarget(target),
35 	fBorder(border)
36 {
37 	_Init(horizontal, vertical);
38 }
39 
40 
41 BScrollView::BScrollView(const char* name, BView* target, uint32 flags,
42 	bool horizontal, bool vertical, border_style border)
43 	:
44 	BView(name, _ModifyFlags(flags, border)),
45 	fTarget(target),
46 	fBorder(border)
47 {
48 	_Init(horizontal, vertical);
49 }
50 
51 
52 BScrollView::BScrollView(BMessage* archive)
53 	:
54 	BView(archive),
55 	fHighlighted(false)
56 {
57 	int32 border;
58 	fBorder = archive->FindInt32("_style", &border) == B_OK ?
59 		(border_style)border : B_FANCY_BORDER;
60 
61 	// in a shallow archive, we may not have a target anymore. We must
62 	// be prepared for this case
63 
64 	// don't confuse our scroll bars with our (eventual) target
65 	int32 firstBar = 0;
66 	if (!archive->FindBool("_no_target_")) {
67 		fTarget = ChildAt(0);
68 		firstBar++;
69 	} else
70 		fTarget = NULL;
71 
72 	// search for our scroll bars
73 	// This will not work for managed archives (when the layout kit is used).
74 	// In that case the children are attached later, and we perform the search
75 	// again in the AllUnarchived method.
76 
77 	fHorizontalScrollBar = NULL;
78 	fVerticalScrollBar = NULL;
79 
80 	BView* view;
81 	while ((view = ChildAt(firstBar++)) != NULL) {
82 		BScrollBar *bar = dynamic_cast<BScrollBar *>(view);
83 		if (bar == NULL)
84 			continue;
85 
86 		if (bar->Orientation() == B_HORIZONTAL)
87 			fHorizontalScrollBar = bar;
88 		else if (bar->Orientation() == B_VERTICAL)
89 			fVerticalScrollBar = bar;
90 	}
91 
92 	fPreviousWidth = uint16(Bounds().Width());
93 	fPreviousHeight = uint16(Bounds().Height());
94 
95 }
96 
97 
98 BScrollView::~BScrollView()
99 {
100 }
101 
102 
103 // #pragma mark - Archiving
104 
105 
106 BArchivable*
107 BScrollView::Instantiate(BMessage* archive)
108 {
109 	if (validate_instantiation(archive, "BScrollView"))
110 		return new BScrollView(archive);
111 
112 	return NULL;
113 }
114 
115 
116 status_t
117 BScrollView::Archive(BMessage* archive, bool deep) const
118 {
119 	status_t status = BView::Archive(archive, deep);
120 	if (status != B_OK)
121 		return status;
122 
123 	// If this is a deep archive, the BView class will take care
124 	// of our children.
125 
126 	if (status == B_OK && fBorder != B_FANCY_BORDER)
127 		status = archive->AddInt32("_style", fBorder);
128 	if (status == B_OK && fTarget == NULL)
129 		status = archive->AddBool("_no_target_", true);
130 
131 	// The highlighted state is not archived, but since it is
132 	// usually (or should be) used to indicate focus, this
133 	// is probably the right thing to do.
134 
135 	return status;
136 }
137 
138 
139 status_t
140 BScrollView::AllUnarchived(const BMessage* archive)
141 {
142 	status_t result = BView::AllUnarchived(archive);
143 	if (result != B_OK)
144 		return result;
145 
146 	// search for our scroll bars and target
147 	int32 firstBar = 0;
148 	BView* view;
149 	while ((view = ChildAt(firstBar++)) != NULL) {
150 		BScrollBar *bar = dynamic_cast<BScrollBar *>(view);
151 		// We assume that the first non-scrollbar child view is the target.
152 		// So the target view can't be a BScrollBar, but who would do that?
153 		if (bar == NULL) {
154 			// in a shallow archive, we may not have a target anymore. We must
155 			// be prepared for this case
156 			if (fTarget == NULL && !archive->FindBool("_no_target_"))
157 				fTarget = view;
158 			continue;
159 		}
160 
161 		if (bar->Orientation() == B_HORIZONTAL)
162 			fHorizontalScrollBar = bar;
163 		else if (bar->Orientation() == B_VERTICAL)
164 			fVerticalScrollBar = bar;
165 	}
166 
167 	// Now connect the bars to the target, and make the target aware of them
168 	if (fHorizontalScrollBar)
169 		fHorizontalScrollBar->SetTarget(fTarget);
170 	if (fVerticalScrollBar)
171 		fVerticalScrollBar->SetTarget(fTarget);
172 
173 	if (fTarget)
174 		fTarget->TargetedByScrollView(this);
175 
176 	fPreviousWidth = uint16(Bounds().Width());
177 	fPreviousHeight = uint16(Bounds().Height());
178 
179 	return B_OK;
180 }
181 
182 
183 // #pragma mark - Hook methods
184 
185 
186 void
187 BScrollView::AttachedToWindow()
188 {
189 	BView::AttachedToWindow();
190 
191 	if ((fHorizontalScrollBar == NULL && fVerticalScrollBar == NULL)
192 		|| (fHorizontalScrollBar != NULL && fVerticalScrollBar != NULL)
193 		|| Window()->Look() != B_DOCUMENT_WINDOW_LOOK) {
194 		return;
195 	}
196 
197 	// If we have only one bar, we need to check if we are in the
198 	// bottom right edge of a window with the B_DOCUMENT_LOOK to
199 	// adjust the size of the bar to acknowledge the resize knob.
200 
201 	BRect bounds = ConvertToScreen(Bounds());
202 	BRect windowBounds = Window()->Frame();
203 
204 	if (bounds.right - _BorderSize() != windowBounds.right
205 		|| bounds.bottom - _BorderSize() != windowBounds.bottom) {
206 		return;
207 	}
208 
209 	if (fHorizontalScrollBar)
210 		fHorizontalScrollBar->ResizeBy(-B_V_SCROLL_BAR_WIDTH, 0);
211 	else if (fVerticalScrollBar)
212 		fVerticalScrollBar->ResizeBy(0, -B_H_SCROLL_BAR_HEIGHT);
213 }
214 
215 
216 void
217 BScrollView::DetachedFromWindow()
218 {
219 	BView::DetachedFromWindow();
220 }
221 
222 
223 void
224 BScrollView::AllAttached()
225 {
226 	BView::AllAttached();
227 }
228 
229 
230 void
231 BScrollView::AllDetached()
232 {
233 	BView::AllDetached();
234 }
235 
236 
237 void
238 BScrollView::Draw(BRect updateRect)
239 {
240 	uint32 flags = 0;
241 	if (fHighlighted && Window()->IsActive())
242 		flags |= BControlLook::B_FOCUSED;
243 
244 	BRect rect(Bounds());
245 	rgb_color base = ui_color(B_PANEL_BACKGROUND_COLOR);
246 
247 	BRect verticalScrollBarFrame(0, 0, -1, -1);
248 	if (fVerticalScrollBar)
249 		verticalScrollBarFrame = fVerticalScrollBar->Frame();
250 
251 	BRect horizontalScrollBarFrame(0, 0, -1, -1);
252 	if (fHorizontalScrollBar)
253 		horizontalScrollBarFrame = fHorizontalScrollBar->Frame();
254 
255 	be_control_look->DrawScrollViewFrame(this, rect, updateRect,
256 		verticalScrollBarFrame, horizontalScrollBarFrame, base, fBorder,
257 		flags);
258 }
259 
260 
261 void
262 BScrollView::FrameMoved(BPoint newPosition)
263 {
264 	BView::FrameMoved(newPosition);
265 }
266 
267 
268 void
269 BScrollView::FrameResized(float newWidth, float newHeight)
270 {
271 	BView::FrameResized(newWidth, newHeight);
272 
273 	if (fBorder == B_NO_BORDER)
274 		return;
275 
276 	BRect bounds = Bounds();
277 	float border = _BorderSize() - 1;
278 
279 	if (be_control_look && fHorizontalScrollBar && fVerticalScrollBar) {
280 		BRect scrollCorner(bounds);
281 		scrollCorner.left = min_c(
282 			fPreviousWidth - fVerticalScrollBar->Frame().Height(),
283 			fHorizontalScrollBar->Frame().right + 1);
284 		scrollCorner.top = min_c(
285 			fPreviousHeight - fHorizontalScrollBar->Frame().Width(),
286 			fVerticalScrollBar->Frame().bottom + 1);
287 		Invalidate(scrollCorner);
288 	}
289 
290 	// changes in newWidth
291 
292 	if (bounds.Width() > fPreviousWidth) {
293 		// invalidate the region between the old and the new right border
294 		BRect rect = bounds;
295 		rect.left += fPreviousWidth - border;
296 		rect.right--;
297 		Invalidate(rect);
298 	} else if (bounds.Width() < fPreviousWidth) {
299 		// invalidate the region of the new right border
300 		BRect rect = bounds;
301 		rect.left = rect.right - border;
302 		Invalidate(rect);
303 	}
304 
305 	// changes in newHeight
306 
307 	if (bounds.Height() > fPreviousHeight) {
308 		// invalidate the region between the old and the new bottom border
309 		BRect rect = bounds;
310 		rect.top += fPreviousHeight - border;
311 		rect.bottom--;
312 		Invalidate(rect);
313 	} else if (bounds.Height() < fPreviousHeight) {
314 		// invalidate the region of the new bottom border
315 		BRect rect = bounds;
316 		rect.top = rect.bottom - border;
317 		Invalidate(rect);
318 	}
319 
320 	fPreviousWidth = uint16(bounds.Width());
321 	fPreviousHeight = uint16(bounds.Height());
322 }
323 
324 
325 void
326 BScrollView::MessageReceived(BMessage* message)
327 {
328 	BView::MessageReceived(message);
329 }
330 
331 
332 void
333 BScrollView::MouseDown(BPoint where)
334 {
335 	BView::MouseDown(where);
336 }
337 
338 
339 void
340 BScrollView::MouseMoved(BPoint where, uint32 code,
341 	const BMessage* dragMessage)
342 {
343 	BView::MouseMoved(where, code, dragMessage);
344 }
345 
346 
347 void
348 BScrollView::MouseUp(BPoint where)
349 {
350 	BView::MouseUp(where);
351 }
352 
353 
354 void
355 BScrollView::WindowActivated(bool active)
356 {
357 	if (fHighlighted)
358 		Invalidate();
359 
360 	BView::WindowActivated(active);
361 }
362 
363 
364 // #pragma mark - Size methods
365 
366 
367 void
368 BScrollView::GetPreferredSize(float* _width, float* _height)
369 {
370 	BSize size = PreferredSize();
371 
372 	if (_width)
373 		*_width = size.width;
374 
375 	if (_height)
376 		*_height = size.height;
377 }
378 
379 
380 void
381 BScrollView::ResizeToPreferred()
382 {
383 	if (Window() == NULL)
384 		return;
385 	BView::ResizeToPreferred();
386 }
387 
388 
389 void
390 BScrollView::MakeFocus(bool focus)
391 {
392 	BView::MakeFocus(focus);
393 }
394 
395 
396 BSize
397 BScrollView::MinSize()
398 {
399 	BSize size = _ComputeSize(fTarget != NULL ? fTarget->MinSize()
400 		: BSize(16, 16));
401 
402 	return BLayoutUtils::ComposeSize(ExplicitMinSize(), size);
403 }
404 
405 
406 BSize
407 BScrollView::MaxSize()
408 {
409 	BSize size = _ComputeSize(fTarget != NULL ? fTarget->MaxSize()
410 		: BSize(B_SIZE_UNLIMITED, B_SIZE_UNLIMITED));
411 
412 	return BLayoutUtils::ComposeSize(ExplicitMaxSize(), size);
413 }
414 
415 
416 BSize
417 BScrollView::PreferredSize()
418 {
419 	BSize size = _ComputeSize(fTarget != NULL ? fTarget->PreferredSize()
420 		: BSize(32, 32));
421 
422 	return BLayoutUtils::ComposeSize(ExplicitPreferredSize(), size);
423 }
424 
425 
426 // #pragma mark - BScrollView methods
427 
428 
429 BScrollBar*
430 BScrollView::ScrollBar(orientation direction) const
431 {
432 	if (direction == B_HORIZONTAL)
433 		return fHorizontalScrollBar;
434 
435 	return fVerticalScrollBar;
436 }
437 
438 
439 void
440 BScrollView::SetBorder(border_style border)
441 {
442 	if (fBorder == border)
443 		return;
444 
445 	if (Flags() & B_SUPPORTS_LAYOUT) {
446 		fBorder = border;
447 		SetFlags(_ModifyFlags(Flags(), border));
448 
449 		DoLayout();
450 
451 		BRect bounds(Bounds());
452 		Invalidate(BRect(bounds.LeftTop(), bounds.RightBottom()));
453 		Invalidate(BRect(bounds.LeftBottom(), bounds.RightBottom()));
454 		return;
455 	}
456 
457 	float offset = _BorderSize() - _BorderSize(border);
458 	float resize = 2 * offset;
459 
460 	float horizontalGap = 0, verticalGap = 0;
461 	float change = 0;
462 	if (border == B_NO_BORDER || fBorder == B_NO_BORDER) {
463 		if (fHorizontalScrollBar != NULL)
464 			verticalGap = border != B_NO_BORDER ? 1 : -1;
465 		if (fVerticalScrollBar != NULL)
466 			horizontalGap = border != B_NO_BORDER ? 1 : -1;
467 
468 		change = border != B_NO_BORDER ? -1 : 1;
469 		if (fHorizontalScrollBar == NULL || fVerticalScrollBar == NULL)
470 			change *= 2;
471 	}
472 
473 	fBorder = border;
474 
475 	int32 savedResizingMode = 0;
476 	if (fTarget != NULL) {
477 		savedResizingMode = fTarget->ResizingMode();
478 		fTarget->SetResizingMode(B_FOLLOW_NONE);
479 	}
480 
481 	MoveBy(offset, offset);
482 	ResizeBy(-resize - horizontalGap, -resize - verticalGap);
483 
484 	if (fTarget != NULL) {
485 		fTarget->MoveBy(-offset, -offset);
486 		fTarget->SetResizingMode(savedResizingMode);
487 	}
488 
489 	if (fHorizontalScrollBar != NULL) {
490 		fHorizontalScrollBar->MoveBy(-offset - verticalGap, offset + verticalGap);
491 		fHorizontalScrollBar->ResizeBy(resize + horizontalGap - change, 0);
492 	}
493 	if (fVerticalScrollBar != NULL) {
494 		fVerticalScrollBar->MoveBy(offset + horizontalGap, -offset - horizontalGap);
495 		fVerticalScrollBar->ResizeBy(0, resize + verticalGap - change);
496 	}
497 
498 	SetFlags(_ModifyFlags(Flags(), border));
499 }
500 
501 
502 border_style
503 BScrollView::Border() const
504 {
505 	return fBorder;
506 }
507 
508 
509 status_t
510 BScrollView::SetBorderHighlighted(bool highlight)
511 {
512 	if (fHighlighted == highlight)
513 		return B_OK;
514 
515 	if (fBorder != B_FANCY_BORDER)
516 		// highlighting only works for B_FANCY_BORDER
517 		return B_ERROR;
518 
519 	fHighlighted = highlight;
520 
521 	if (fHorizontalScrollBar != NULL)
522 		fHorizontalScrollBar->SetBorderHighlighted(highlight);
523 	if (fVerticalScrollBar != NULL)
524 		fVerticalScrollBar->SetBorderHighlighted(highlight);
525 
526 	BRect bounds = Bounds();
527 	if (be_control_look != NULL)
528 		bounds.InsetBy(1, 1);
529 
530 	Invalidate(BRect(bounds.left, bounds.top, bounds.right, bounds.top));
531 	Invalidate(BRect(bounds.left, bounds.top + 1, bounds.left,
532 		bounds.bottom - 1));
533 	Invalidate(BRect(bounds.right, bounds.top + 1, bounds.right,
534 		bounds.bottom - 1));
535 	Invalidate(BRect(bounds.left, bounds.bottom, bounds.right, bounds.bottom));
536 
537 	return B_OK;
538 }
539 
540 
541 bool
542 BScrollView::IsBorderHighlighted() const
543 {
544 	return fHighlighted;
545 }
546 
547 
548 void
549 BScrollView::SetTarget(BView* target)
550 {
551 	if (fTarget == target)
552 		return;
553 
554 	if (fTarget != NULL) {
555 		fTarget->TargetedByScrollView(NULL);
556 		RemoveChild(fTarget);
557 
558 		// we are not supposed to delete the view
559 	}
560 
561 	fTarget = target;
562 	if (fHorizontalScrollBar != NULL)
563 		fHorizontalScrollBar->SetTarget(target);
564 	if (fVerticalScrollBar != NULL)
565 		fVerticalScrollBar->SetTarget(target);
566 
567 	if (target != NULL) {
568 		target->MoveTo(_BorderSize(), _BorderSize());
569 		BRect innerFrame = _InnerFrame();
570 		target->ResizeTo(innerFrame.Width() - 1, innerFrame.Height() - 1);
571 		target->TargetedByScrollView(this);
572 
573 		AddChild(target, ChildAt(0));
574 			// This way, we are making sure that the target will
575 			// be added top most in the list (which is important
576 			// for unarchiving)
577 	}
578 }
579 
580 
581 BView*
582 BScrollView::Target() const
583 {
584 	return fTarget;
585 }
586 
587 
588 // #pragma mark - Scripting methods
589 
590 
591 
592 BHandler*
593 BScrollView::ResolveSpecifier(BMessage* message, int32 index,
594 	BMessage* specifier, int32 what, const char* property)
595 {
596 	return BView::ResolveSpecifier(message, index, specifier, what, property);
597 }
598 
599 
600 status_t
601 BScrollView::GetSupportedSuites(BMessage* message)
602 {
603 	return BView::GetSupportedSuites(message);
604 }
605 
606 
607 //	#pragma mark - Perform
608 
609 
610 status_t
611 BScrollView::Perform(perform_code code, void* _data)
612 {
613 	switch (code) {
614 		case PERFORM_CODE_MIN_SIZE:
615 			((perform_data_min_size*)_data)->return_value
616 				= BScrollView::MinSize();
617 			return B_OK;
618 
619 		case PERFORM_CODE_MAX_SIZE:
620 			((perform_data_max_size*)_data)->return_value
621 				= BScrollView::MaxSize();
622 			return B_OK;
623 
624 		case PERFORM_CODE_PREFERRED_SIZE:
625 			((perform_data_preferred_size*)_data)->return_value
626 				= BScrollView::PreferredSize();
627 			return B_OK;
628 
629 		case PERFORM_CODE_LAYOUT_ALIGNMENT:
630 			((perform_data_layout_alignment*)_data)->return_value
631 				= BScrollView::LayoutAlignment();
632 			return B_OK;
633 
634 		case PERFORM_CODE_HAS_HEIGHT_FOR_WIDTH:
635 			((perform_data_has_height_for_width*)_data)->return_value
636 				= BScrollView::HasHeightForWidth();
637 			return B_OK;
638 
639 		case PERFORM_CODE_GET_HEIGHT_FOR_WIDTH:
640 		{
641 			perform_data_get_height_for_width* data
642 				= (perform_data_get_height_for_width*)_data;
643 			BScrollView::GetHeightForWidth(data->width, &data->min, &data->max,
644 				&data->preferred);
645 			return B_OK;
646 		}
647 
648 		case PERFORM_CODE_SET_LAYOUT:
649 		{
650 			perform_data_set_layout* data = (perform_data_set_layout*)_data;
651 			BScrollView::SetLayout(data->layout);
652 			return B_OK;
653 		}
654 
655 		case PERFORM_CODE_LAYOUT_INVALIDATED:
656 		{
657 			perform_data_layout_invalidated* data
658 				= (perform_data_layout_invalidated*)_data;
659 			BScrollView::LayoutInvalidated(data->descendants);
660 			return B_OK;
661 		}
662 
663 		case PERFORM_CODE_DO_LAYOUT:
664 		{
665 			BScrollView::DoLayout();
666 			return B_OK;
667 		}
668 	}
669 
670 	return BView::Perform(code, _data);
671 }
672 
673 
674 //	#pragma mark - Protected methods
675 
676 
677 void
678 BScrollView::LayoutInvalidated(bool descendants)
679 {
680 }
681 
682 
683 void
684 BScrollView::DoLayout()
685 {
686 	if ((Flags() & B_SUPPORTS_LAYOUT) == 0)
687 		return;
688 
689 	// If the user set a layout, we let the base class version call its hook.
690 	if (GetLayout() != NULL) {
691 		BView::DoLayout();
692 		return;
693 	}
694 
695 	BRect innerFrame = _InnerFrame();
696 
697 	if (fTarget != NULL) {
698 		fTarget->MoveTo(innerFrame.left, innerFrame.top);
699 		fTarget->ResizeTo(innerFrame.Width(), innerFrame.Height());
700 
701 		//BLayoutUtils::AlignInFrame(fTarget, fTarget->Bounds());
702 	}
703 
704 	_AlignScrollBars(fHorizontalScrollBar != NULL, fVerticalScrollBar != NULL,
705 		innerFrame);
706 }
707 
708 
709 // #pragma mark - Private methods
710 
711 
712 void
713 BScrollView::_Init(bool horizontal, bool vertical)
714 {
715 	fHorizontalScrollBar = NULL;
716 	fVerticalScrollBar = NULL;
717 	fHighlighted = false;
718 
719 	if (be_control_look != NULL)
720 		SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR));
721 
722 	if (horizontal) {
723 		fHorizontalScrollBar = new BScrollBar(BRect(0, 0, 14, 14), "_HSB_",
724 			fTarget, 0, 1000, B_HORIZONTAL);
725 		AddChild(fHorizontalScrollBar);
726 	}
727 
728 	if (vertical) {
729 		fVerticalScrollBar = new BScrollBar(BRect(0, 0, 14, 14), "_VSB_",
730 			fTarget, 0, 1000, B_VERTICAL);
731 		AddChild(fVerticalScrollBar);
732 	}
733 
734 	BRect targetFrame;
735 	if (fTarget) {
736 		// layout target and add it
737 		fTarget->TargetedByScrollView(this);
738 		fTarget->MoveTo(B_ORIGIN);
739 
740 		if (fBorder != B_NO_BORDER)
741 			fTarget->MoveBy(_BorderSize(), _BorderSize());
742 
743 		AddChild(fTarget);
744 		targetFrame = fTarget->Frame();
745 	} else {
746 		// no target specified
747 		targetFrame = Bounds();
748 		if (horizontal)
749 			targetFrame.bottom -= B_H_SCROLL_BAR_HEIGHT + 1;
750 		if (vertical)
751 			targetFrame.right -= B_V_SCROLL_BAR_WIDTH + 1;
752 		if (fBorder == B_FANCY_BORDER) {
753 			targetFrame.bottom--;
754 			targetFrame.right--;
755 		}
756 	}
757 
758 	_AlignScrollBars(horizontal, vertical, targetFrame);
759 
760 	fPreviousWidth = uint16(Bounds().Width());
761 	fPreviousHeight = uint16(Bounds().Height());
762 }
763 
764 
765 float
766 BScrollView::_BorderSize() const
767 {
768 	return _BorderSize(fBorder);
769 }
770 
771 
772 BRect
773 BScrollView::_InnerFrame() const
774 {
775 	BRect frame = Bounds();
776 
777 	float borderSize = _BorderSize();
778 	frame.InsetBy(borderSize, borderSize);
779 
780 	if (fHorizontalScrollBar != NULL) {
781 		frame.bottom -= B_H_SCROLL_BAR_HEIGHT;
782 		if (borderSize == 0)
783 			frame.bottom--;
784 	}
785 	if (fVerticalScrollBar != NULL) {
786 		frame.right -= B_V_SCROLL_BAR_WIDTH;
787 		if (borderSize == 0)
788 			frame.right--;
789 	}
790 
791 	return frame;
792 }
793 
794 
795 BSize
796 BScrollView::_ComputeSize(BSize targetSize) const
797 {
798 	BRect frame = _ComputeFrame(
799 		BRect(0, 0, targetSize.width, targetSize.height));
800 
801 	return BSize(frame.Width(), frame.Height());
802 }
803 
804 
805 BRect
806 BScrollView::_ComputeFrame(BRect targetRect) const
807 {
808 	return _ComputeFrame(targetRect, fHorizontalScrollBar != NULL,
809 		fVerticalScrollBar != NULL, fBorder);
810 }
811 
812 
813 void
814 BScrollView::_AlignScrollBars(bool horizontal, bool vertical, BRect targetFrame)
815 {
816 	if (horizontal) {
817 		BRect rect = targetFrame;
818 		rect.top = rect.bottom + 1;
819 		rect.bottom = rect.top + B_H_SCROLL_BAR_HEIGHT;
820 		if (fBorder != B_NO_BORDER || vertical) {
821 			// extend scrollbar so that it overlaps one pixel with vertical
822 			// scrollbar
823 			rect.right++;
824 		}
825 
826 		if (fBorder != B_NO_BORDER) {
827 			// the scrollbar draws part of the surrounding frame on the left
828 			rect.left--;
829 		}
830 
831 		fHorizontalScrollBar->MoveTo(rect.left, rect.top);
832 		fHorizontalScrollBar->ResizeTo(rect.Width(), rect.Height());
833 	}
834 
835 	if (vertical) {
836 		BRect rect = targetFrame;
837 		rect.left = rect.right + 1;
838 		rect.right = rect.left + B_V_SCROLL_BAR_WIDTH;
839 		if (fBorder != B_NO_BORDER || horizontal) {
840 			// extend scrollbar so that it overlaps one pixel with vertical
841 			// scrollbar
842 			rect.bottom++;
843 		}
844 
845 		if (fBorder != B_NO_BORDER) {
846 			// the scrollbar draws part of the surrounding frame on the left
847 			rect.top--;
848 		}
849 
850 		fVerticalScrollBar->MoveTo(rect.left, rect.top);
851 		fVerticalScrollBar->ResizeTo(rect.Width(), rect.Height());
852 	}
853 }
854 
855 
856 /*!	This static method is used to calculate the frame that the
857 	ScrollView will cover depending on the frame of its target
858 	and which border style is used.
859 	It is used in the constructor and at other places.
860 */
861 /*static*/ BRect
862 BScrollView::_ComputeFrame(BRect frame, bool horizontal, bool vertical,
863 	border_style border)
864 {
865 	if (vertical)
866 		frame.right += B_V_SCROLL_BAR_WIDTH;
867 	if (horizontal)
868 		frame.bottom += B_H_SCROLL_BAR_HEIGHT;
869 
870 	float borderSize = _BorderSize(border);
871 	frame.InsetBy(-borderSize, -borderSize);
872 
873 	if (borderSize == 0) {
874 		if (vertical)
875 			frame.right++;
876 		if (horizontal)
877 			frame.bottom++;
878 	}
879 
880 	return frame;
881 }
882 
883 
884 /*static*/ BRect
885 BScrollView::_ComputeFrame(BView *target, bool horizontal, bool vertical,
886 	border_style border)
887 {
888 	return _ComputeFrame(target != NULL ? target->Frame()
889 		: BRect(0, 0, 16, 16), horizontal, vertical, border);
890 }
891 
892 
893 /*! This method returns the size of the specified border.
894 */
895 /*static*/ float
896 BScrollView::_BorderSize(border_style border)
897 {
898 	if (border == B_FANCY_BORDER)
899 		return kFancyBorderSize;
900 	if (border == B_PLAIN_BORDER)
901 		return kPlainBorderSize;
902 
903 	return 0;
904 }
905 
906 
907 /*!	This method changes the "flags" argument as passed on to
908 	the BView constructor.
909 */
910 /*static*/ int32
911 BScrollView::_ModifyFlags(int32 flags, border_style border)
912 {
913 	// We either need B_FULL_UPDATE_ON_RESIZE or
914 	// B_FRAME_EVENTS if we have to draw a border
915 	if (border != B_NO_BORDER)
916 		return flags | B_WILL_DRAW | (flags & B_FULL_UPDATE_ON_RESIZE ? 0 : B_FRAME_EVENTS);
917 
918 	return flags & ~(B_WILL_DRAW | B_FRAME_EVENTS | B_FULL_UPDATE_ON_RESIZE);
919 }
920 
921 
922 //	#pragma mark - FBC and forbidden
923 
924 
925 BScrollView&
926 BScrollView::operator=(const BScrollView &)
927 {
928 	return *this;
929 }
930 
931 
932 void BScrollView::_ReservedScrollView1() {}
933 void BScrollView::_ReservedScrollView2() {}
934 void BScrollView::_ReservedScrollView3() {}
935 void BScrollView::_ReservedScrollView4() {}
936 
937 
938 extern "C" void
939 B_IF_GCC_2(InvalidateLayout__11BScrollViewb,
940 	_ZN11BScrollView16InvalidateLayoutEb)(BScrollView* view, bool descendants)
941 {
942 	perform_data_layout_invalidated data;
943 	data.descendants = descendants;
944 
945 	view->Perform(PERFORM_CODE_LAYOUT_INVALIDATED, &data);
946 }
947