xref: /haiku/src/kits/interface/TextControl.cpp (revision e81a954787e50e56a7f06f72705b7859b6ab06d1) 
1 /*
2  * Copyright 2001-2015, Haiku Inc.
3  * Distributed under the terms of the MIT License.
4  *
5  * Authors:
6  *		Frans van Nispen (xlr8@tref.nl)
7  *		Stephan Aßmus <superstippi@gmx.de>
8  *		Ingo Weinhold <bonefish@cs.tu-berlin.de>
9  */
10 
11 
12 /*!	BTextControl displays text that can act like a control. */
13 
14 
15 #include <TextControl.h>
16 
17 #include <string.h>
18 
19 #include <AbstractLayoutItem.h>
20 #include <ControlLook.h>
21 #include <LayoutUtils.h>
22 #include <Message.h>
23 #include <PropertyInfo.h>
24 #include <Region.h>
25 #include <Window.h>
26 
27 #include <binary_compatibility/Interface.h>
28 #include <binary_compatibility/Support.h>
29 
30 #include "TextInput.h"
31 
32 
33 //#define TRACE_TEXT_CONTROL
34 #ifdef TRACE_TEXT_CONTROL
35 #	include <stdio.h>
36 #	include <FunctionTracer.h>
37 	static int32 sFunctionDepth = -1;
38 #	define CALLED(x...)	FunctionTracer _ft("BTextControl", __FUNCTION__, \
39 							sFunctionDepth)
40 #	define TRACE(x...)	{ BString _to; \
41 							_to.Append(' ', (sFunctionDepth + 1) * 2); \
42 							printf("%s", _to.String()); printf(x); }
43 #else
44 #	define CALLED(x...)
45 #	define TRACE(x...)
46 #endif
47 
48 
49 namespace {
50 	const char* const kFrameField = "BTextControl:layoutitem:frame";
51 	const char* const kTextViewItemField = "BTextControl:textViewItem";
52 	const char* const kLabelItemField = "BMenuField:labelItem";
53 }
54 
55 
56 static property_info sPropertyList[] = {
57 	{
58 		"Value",
59 		{ B_GET_PROPERTY, B_SET_PROPERTY },
60 		{ B_DIRECT_SPECIFIER },
61 		NULL, 0,
62 		{ B_STRING_TYPE }
63 	},
64 
65 	{ 0 }
66 };
67 
68 
69 class BTextControl::LabelLayoutItem : public BAbstractLayoutItem {
70 public:
71 								LabelLayoutItem(BTextControl* parent);
72 								LabelLayoutItem(BMessage* from);
73 
74 	virtual	bool				IsVisible();
75 	virtual	void				SetVisible(bool visible);
76 
77 	virtual	BRect				Frame();
78 	virtual	void				SetFrame(BRect frame);
79 
80 			void				SetParent(BTextControl* parent);
81 	virtual	BView*				View();
82 
83 	virtual	BSize				BaseMinSize();
84 	virtual	BSize				BaseMaxSize();
85 	virtual	BSize				BasePreferredSize();
86 	virtual	BAlignment			BaseAlignment();
87 
88 			BRect				FrameInParent() const;
89 
90 	virtual status_t			Archive(BMessage* into, bool deep = true) const;
91 	static	BArchivable*		Instantiate(BMessage* from);
92 
93 private:
94 			BTextControl*		fParent;
95 			BRect				fFrame;
96 };
97 
98 
99 class BTextControl::TextViewLayoutItem : public BAbstractLayoutItem {
100 public:
101 								TextViewLayoutItem(BTextControl* parent);
102 								TextViewLayoutItem(BMessage* from);
103 
104 	virtual	bool				IsVisible();
105 	virtual	void				SetVisible(bool visible);
106 
107 	virtual	BRect				Frame();
108 	virtual	void				SetFrame(BRect frame);
109 
110 			void				SetParent(BTextControl* parent);
111 	virtual	BView*				View();
112 
113 	virtual	BSize				BaseMinSize();
114 	virtual	BSize				BaseMaxSize();
115 	virtual	BSize				BasePreferredSize();
116 	virtual	BAlignment			BaseAlignment();
117 
118 			BRect				FrameInParent() const;
119 
120 	virtual status_t			Archive(BMessage* into, bool deep = true) const;
121 	static	BArchivable*		Instantiate(BMessage* from);
122 private:
123 			BTextControl*		fParent;
124 			BRect				fFrame;
125 };
126 
127 
128 struct BTextControl::LayoutData {
129 	LayoutData(float width, float height)
130 		:
131 		label_layout_item(NULL),
132 		text_view_layout_item(NULL),
133 		previous_width(width),
134 		previous_height(height),
135 		valid(false)
136 	{
137 	}
138 
139 	LabelLayoutItem*	label_layout_item;
140 	TextViewLayoutItem*	text_view_layout_item;
141 	float				previous_width;		// used in FrameResized() for
142 	float				previous_height;	// invalidation
143 	font_height			font_info;
144 	float				label_width;
145 	float				label_height;
146 	BSize				min;
147 	BSize				text_view_min;
148 	bool				valid;
149 };
150 
151 
152 static const int32 kFrameMargin = 2;
153 static const int32 kLabelInputSpacing = 3;
154 
155 
156 // #pragma mark - BTextControl
157 
158 
159 BTextControl::BTextControl(BRect frame, const char* name, const char* label,
160 	const char* text, BMessage* message, uint32 resizeMask, uint32 flags)
161 	:
162 	BControl(frame, name, label, message, resizeMask, flags | B_FRAME_EVENTS)
163 {
164 	_InitData(label);
165 	_InitText(text);
166 	_ValidateLayout();
167 }
168 
169 
170 BTextControl::BTextControl(const char* name, const char* label,
171 	const char* text, BMessage* message, uint32 flags)
172 	:
173 	BControl(name, label, message, flags | B_FRAME_EVENTS)
174 {
175 	_InitData(label);
176 	_InitText(text);
177 	_ValidateLayout();
178 }
179 
180 
181 BTextControl::BTextControl(const char* label, const char* text,
182 	BMessage* message)
183 	:
184 	BControl(NULL, label, message,
185 		B_WILL_DRAW | B_NAVIGABLE | B_FRAME_EVENTS)
186 {
187 	_InitData(label);
188 	_InitText(text);
189 	_ValidateLayout();
190 }
191 
192 
193 BTextControl::~BTextControl()
194 {
195 	SetModificationMessage(NULL);
196 	delete fLayoutData;
197 }
198 
199 
200 //	#pragma mark - Archiving
201 
202 
203 BTextControl::BTextControl(BMessage* archive)
204 	:
205 	BControl(BUnarchiver::PrepareArchive(archive))
206 {
207 	BUnarchiver unarchiver(archive);
208 
209 	_InitData(Label(), archive);
210 
211 	if (!BUnarchiver::IsArchiveManaged(archive))
212 		_InitText(NULL, archive);
213 
214 	status_t err = B_OK;
215 	if (archive->HasFloat("_divide"))
216 		err = archive->FindFloat("_divide", &fDivider);
217 
218 	if (err == B_OK && archive->HasMessage("_mod_msg")) {
219 		BMessage* message = new BMessage;
220 		err = archive->FindMessage("_mod_msg", message);
221 		SetModificationMessage(message);
222 	}
223 
224 	unarchiver.Finish(err);
225 }
226 
227 
228 BArchivable*
229 BTextControl::Instantiate(BMessage* archive)
230 {
231 	if (validate_instantiation(archive, "BTextControl"))
232 		return new BTextControl(archive);
233 
234 	return NULL;
235 }
236 
237 
238 status_t
239 BTextControl::Archive(BMessage* data, bool deep) const
240 {
241 	BArchiver archiver(data);
242 	status_t result = BControl::Archive(data, deep);
243 
244 	alignment labelAlignment;
245 	alignment textAlignment;
246 	if (result == B_OK)
247 		GetAlignment(&labelAlignment, &textAlignment);
248 
249 	if (result == B_OK)
250 		result = data->AddInt32("_a_label", labelAlignment);
251 
252 	if (result == B_OK)
253 		result = data->AddInt32("_a_text", textAlignment);
254 
255 	if (result == B_OK)
256 		result = data->AddFloat("_divide", Divider());
257 
258 	if (result == B_OK && ModificationMessage() != NULL)
259 		result = data->AddMessage("_mod_msg", ModificationMessage());
260 
261 	return archiver.Finish(result);
262 }
263 
264 
265 status_t
266 BTextControl::AllArchived(BMessage* into) const
267 {
268 	BArchiver archiver(into);
269 	status_t err = B_OK;
270 
271 	if (archiver.IsArchived(fLayoutData->text_view_layout_item)) {
272 		err = archiver.AddArchivable(kTextViewItemField,
273 			fLayoutData->text_view_layout_item);
274 	}
275 
276 	if (err == B_OK && archiver.IsArchived(fLayoutData->label_layout_item)) {
277 		err = archiver.AddArchivable(kLabelItemField,
278 			fLayoutData->label_layout_item);
279 	}
280 
281 	return err;
282 }
283 
284 
285 status_t
286 BTextControl::AllUnarchived(const BMessage* from)
287 {
288 	status_t err;
289 	if ((err = BControl::AllUnarchived(from)) != B_OK)
290 		return err;
291 
292 	_InitText(NULL, from);
293 
294 	BUnarchiver unarchiver(from);
295 	if (unarchiver.IsInstantiated(kTextViewItemField)) {
296 		err = unarchiver.FindObject(kTextViewItemField,
297 			BUnarchiver::B_DONT_ASSUME_OWNERSHIP,
298 			fLayoutData->text_view_layout_item);
299 
300 		if (err == B_OK)
301 			fLayoutData->text_view_layout_item->SetParent(this);
302 		else
303 			return err;
304 	}
305 
306 	if (unarchiver.IsInstantiated(kLabelItemField)) {
307 		err = unarchiver.FindObject(kLabelItemField,
308 			BUnarchiver::B_DONT_ASSUME_OWNERSHIP,
309 			fLayoutData->label_layout_item);
310 
311 		if (err == B_OK)
312 			fLayoutData->label_layout_item->SetParent(this);
313 	}
314 	return err;
315 }
316 
317 
318 //	#pragma mark - Hook methods
319 
320 
321 void
322 BTextControl::AllAttached()
323 {
324 	BControl::AllAttached();
325 }
326 
327 
328 void
329 BTextControl::AllDetached()
330 {
331 	BControl::AllDetached();
332 }
333 
334 
335 void
336 BTextControl::AttachedToWindow()
337 {
338 	BControl::AttachedToWindow();
339 
340 	_UpdateTextViewColors(IsEnabled());
341 	fText->MakeEditable(IsEnabled());
342 }
343 
344 
345 void
346 BTextControl::DetachedFromWindow()
347 {
348 	BControl::DetachedFromWindow();
349 }
350 
351 
352 void
353 BTextControl::Draw(BRect updateRect)
354 {
355 	bool enabled = IsEnabled();
356 	bool active = fText->IsFocus() && Window()->IsActive();
357 
358 	BRect rect = fText->Frame();
359 	rect.InsetBy(-2, -2);
360 
361 	rgb_color base = ViewColor();
362 	uint32 flags = fLook;
363 	if (!enabled)
364 		flags |= BControlLook::B_DISABLED;
365 
366 	if (active)
367 		flags |= BControlLook::B_FOCUSED;
368 
369 	be_control_look->DrawTextControlBorder(this, rect, updateRect, base,
370 		flags);
371 
372 	if (Label() != NULL) {
373 		if (fLayoutData->label_layout_item != NULL) {
374 			rect = fLayoutData->label_layout_item->FrameInParent();
375 		} else {
376 			rect = Bounds();
377 			rect.right = fDivider - kLabelInputSpacing;
378 		}
379 
380 		// erase the is control flag before drawing the label so that the label
381 		// will get drawn using B_PANEL_TEXT_COLOR
382 		flags &= ~BControlLook::B_IS_CONTROL;
383 
384 		be_control_look->DrawLabel(this, Label(), rect, updateRect,
385 			base, flags, BAlignment(fLabelAlign, B_ALIGN_MIDDLE));
386 	}
387 }
388 
389 
390 void
391 BTextControl::FrameMoved(BPoint newPosition)
392 {
393 	BControl::FrameMoved(newPosition);
394 }
395 
396 
397 void
398 BTextControl::FrameResized(float width, float height)
399 {
400 	CALLED();
401 
402 	BControl::FrameResized(width, height);
403 
404 	// TODO: this causes flickering still...
405 
406 	// changes in width
407 
408 	BRect bounds = Bounds();
409 
410 	if (bounds.Width() > fLayoutData->previous_width) {
411 		// invalidate the region between the old and the new right border
412 		BRect rect = bounds;
413 		rect.left += fLayoutData->previous_width - kFrameMargin;
414 		rect.right--;
415 		Invalidate(rect);
416 	} else if (bounds.Width() < fLayoutData->previous_width) {
417 		// invalidate the region of the new right border
418 		BRect rect = bounds;
419 		rect.left = rect.right - kFrameMargin;
420 		Invalidate(rect);
421 	}
422 
423 	// changes in height
424 
425 	if (bounds.Height() > fLayoutData->previous_height) {
426 		// invalidate the region between the old and the new bottom border
427 		BRect rect = bounds;
428 		rect.top += fLayoutData->previous_height - kFrameMargin;
429 		rect.bottom--;
430 		Invalidate(rect);
431 		// invalidate label area
432 		rect = bounds;
433 		rect.right = fDivider;
434 		Invalidate(rect);
435 	} else if (bounds.Height() < fLayoutData->previous_height) {
436 		// invalidate the region of the new bottom border
437 		BRect rect = bounds;
438 		rect.top = rect.bottom - kFrameMargin;
439 		Invalidate(rect);
440 		// invalidate label area
441 		rect = bounds;
442 		rect.right = fDivider;
443 		Invalidate(rect);
444 	}
445 
446 	fLayoutData->previous_width = bounds.Width();
447 	fLayoutData->previous_height = bounds.Height();
448 
449 	TRACE("width: %.2f, height: %.2f\n", bounds.Width(), bounds.Height());
450 }
451 
452 
453 status_t
454 BTextControl::Invoke(BMessage* message)
455 {
456 	return BControl::Invoke(message);
457 }
458 
459 
460 void
461 BTextControl::LayoutInvalidated(bool descendants)
462 {
463 	CALLED();
464 
465 	fLayoutData->valid = false;
466 }
467 
468 
469 void
470 BTextControl::MessageReceived(BMessage* message)
471 {
472 	if (message->what == B_COLORS_UPDATED) {
473 
474 		if (message->HasColor(ui_color_name(B_PANEL_BACKGROUND_COLOR))
475 			|| message->HasColor(ui_color_name(B_PANEL_TEXT_COLOR))
476 			|| message->HasColor(ui_color_name(B_DOCUMENT_BACKGROUND_COLOR))
477 			|| message->HasColor(ui_color_name(B_DOCUMENT_TEXT_COLOR))) {
478 			_UpdateTextViewColors(IsEnabled());
479 		}
480 	}
481 
482 	if (message->what == B_GET_PROPERTY || message->what == B_SET_PROPERTY) {
483 		BMessage reply(B_REPLY);
484 		bool handled = false;
485 
486 		BMessage specifier;
487 		int32 index;
488 		int32 form;
489 		const char* property;
490 		if (message->GetCurrentSpecifier(&index, &specifier, &form, &property) == B_OK) {
491 			if (strcmp(property, "Value") == 0) {
492 				if (message->what == B_GET_PROPERTY) {
493 					reply.AddString("result", fText->Text());
494 					handled = true;
495 				} else {
496 					const char* value = NULL;
497 					// B_SET_PROPERTY
498 					if (message->FindString("data", &value) == B_OK) {
499 						fText->SetText(value);
500 						reply.AddInt32("error", B_OK);
501 						handled = true;
502 					}
503 				}
504 			}
505 		}
506 
507 		if (handled) {
508 			message->SendReply(&reply);
509 			return;
510 		}
511 	}
512 
513 	BControl::MessageReceived(message);
514 }
515 
516 
517 void
518 BTextControl::MouseDown(BPoint where)
519 {
520 	if (!fText->IsFocus())
521 		fText->MakeFocus(true);
522 }
523 
524 
525 void
526 BTextControl::MouseMoved(BPoint where, uint32 transit,
527 	const BMessage* dragMessage)
528 {
529 	BControl::MouseMoved(where, transit, dragMessage);
530 }
531 
532 
533 void
534 BTextControl::MouseUp(BPoint where)
535 {
536 	BControl::MouseUp(where);
537 }
538 
539 
540 void
541 BTextControl::WindowActivated(bool active)
542 {
543 	if (fText->IsFocus()) {
544 		// invalidate to remove/show focus indication
545 		BRect rect = fText->Frame();
546 		rect.InsetBy(-1, -1);
547 		Invalidate(rect);
548 
549 		// help out embedded text view which doesn't
550 		// get notified of this
551 		fText->Invalidate();
552 	}
553 }
554 
555 
556 //	#pragma mark - Getters and Setters
557 
558 
559 void
560 BTextControl::SetText(const char* text)
561 {
562 	if (InvokeKind() != B_CONTROL_INVOKED)
563 		return;
564 
565 	CALLED();
566 
567 	fText->SetText(text);
568 
569 	if (fText->IsFocus()) {
570 		fText->SetInitialText();
571 		fText->SelectAll();
572 	}
573 
574 	fText->Invalidate();
575 }
576 
577 
578 const char*
579 BTextControl::Text() const
580 {
581 	return fText->Text();
582 }
583 
584 
585 int32
586 BTextControl::TextLength() const
587 {
588 	return fText->TextLength();
589 }
590 
591 
592 void
593 BTextControl::MarkAsInvalid(bool invalid)
594 {
595 	uint32 look = fLook;
596 
597 	if (invalid)
598 		fLook |= BControlLook::B_INVALID;
599 	else
600 		fLook &= ~BControlLook::B_INVALID;
601 
602 	if (look != fLook)
603 		Invalidate();
604 }
605 
606 
607 void
608 BTextControl::SetValue(int32 value)
609 {
610 	BControl::SetValue(value);
611 }
612 
613 
614 BTextView*
615 BTextControl::TextView() const
616 {
617 	return fText;
618 }
619 
620 
621 void
622 BTextControl::SetModificationMessage(BMessage* message)
623 {
624 	delete fModificationMessage;
625 	fModificationMessage = message;
626 }
627 
628 
629 BMessage*
630 BTextControl::ModificationMessage() const
631 {
632 	return fModificationMessage;
633 }
634 
635 
636 void
637 BTextControl::SetAlignment(alignment labelAlignment, alignment textAlignment)
638 {
639 	fText->SetAlignment(textAlignment);
640 	fText->AlignTextRect();
641 
642 	if (fLabelAlign != labelAlignment) {
643 		fLabelAlign = labelAlignment;
644 		Invalidate();
645 	}
646 }
647 
648 
649 void
650 BTextControl::GetAlignment(alignment* _label, alignment* _text) const
651 {
652 	if (_label != NULL)
653 		*_label = fLabelAlign;
654 
655 	if (_text != NULL)
656 		*_text = fText->Alignment();
657 }
658 
659 
660 void
661 BTextControl::SetDivider(float position)
662 {
663 	fDivider = floorf(position + 0.5);
664 
665 	_LayoutTextView();
666 
667 	if (Window()) {
668 		fText->Invalidate();
669 		Invalidate();
670 	}
671 }
672 
673 
674 float
675 BTextControl::Divider() const
676 {
677 	return fDivider;
678 }
679 
680 
681 void
682 BTextControl::MakeFocus(bool state)
683 {
684 	if (state != fText->IsFocus()) {
685 		fText->MakeFocus(state);
686 
687 		if (state)
688 			fText->SelectAll();
689 	}
690 }
691 
692 
693 void
694 BTextControl::SetEnabled(bool enable)
695 {
696 	if (IsEnabled() == enable)
697 		return;
698 
699 	if (Window() != NULL) {
700 		fText->MakeEditable(enable);
701 		if (enable)
702 			fText->SetFlags(fText->Flags() | B_NAVIGABLE);
703 		else
704 			fText->SetFlags(fText->Flags() & ~B_NAVIGABLE);
705 
706 		_UpdateTextViewColors(enable);
707 
708 		fText->Invalidate();
709 		Window()->UpdateIfNeeded();
710 	}
711 
712 	BControl::SetEnabled(enable);
713 }
714 
715 
716 void
717 BTextControl::GetPreferredSize(float* _width, float* _height)
718 {
719 	CALLED();
720 
721 	_ValidateLayoutData();
722 
723 	if (_width) {
724 		float minWidth = fLayoutData->min.width;
725 		if (Label() == NULL && !(Flags() & B_SUPPORTS_LAYOUT)) {
726 			// Indeed, only if there is no label! BeOS backwards compatible
727 			// behavior:
728 			minWidth = max_c(minWidth, Bounds().Width());
729 		}
730 		*_width = minWidth;
731 	}
732 
733 	if (_height)
734 		*_height = fLayoutData->min.height;
735 }
736 
737 
738 void
739 BTextControl::ResizeToPreferred()
740 {
741 	BView::ResizeToPreferred();
742 
743 	fDivider = 0.0;
744 	const char* label = Label();
745 	if (label)
746 		fDivider = ceil(StringWidth(label)) + 2.0;
747 
748 	_LayoutTextView();
749 }
750 
751 
752 void
753 BTextControl::SetFlags(uint32 flags)
754 {
755 	// If the textview is navigable, set it to not navigable if needed
756 	// Else if it is not navigable, set it to navigable if needed
757 	if (fText->Flags() & B_NAVIGABLE) {
758 		if (!(flags & B_NAVIGABLE))
759 			fText->SetFlags(fText->Flags() & ~B_NAVIGABLE);
760 
761 	} else {
762 		if (flags & B_NAVIGABLE)
763 			fText->SetFlags(fText->Flags() | B_NAVIGABLE);
764 	}
765 
766 	// Don't make this one navigable
767 	flags &= ~B_NAVIGABLE;
768 
769 	BView::SetFlags(flags);
770 }
771 
772 
773 //	#pragma mark - Scripting
774 
775 
776 BHandler*
777 BTextControl::ResolveSpecifier(BMessage* message, int32 index,
778 	BMessage* specifier, int32 what, const char* property)
779 {
780 	BPropertyInfo propInfo(sPropertyList);
781 
782 	if (propInfo.FindMatch(message, 0, specifier, what, property) >= B_OK)
783 		return this;
784 
785 	return BControl::ResolveSpecifier(message, index, specifier, what,
786 		property);
787 }
788 
789 
790 status_t
791 BTextControl::GetSupportedSuites(BMessage* data)
792 {
793 	return BControl::GetSupportedSuites(data);
794 }
795 
796 
797 //	#pragma mark - Layout
798 
799 
800 BSize
801 BTextControl::MinSize()
802 {
803 	CALLED();
804 
805 	_ValidateLayoutData();
806 	return BLayoutUtils::ComposeSize(ExplicitMinSize(), fLayoutData->min);
807 }
808 
809 
810 BSize
811 BTextControl::MaxSize()
812 {
813 	CALLED();
814 
815 	_ValidateLayoutData();
816 
817 	BSize max = fLayoutData->min;
818 	max.width = B_SIZE_UNLIMITED;
819 
820 	return BLayoutUtils::ComposeSize(ExplicitMaxSize(), max);
821 }
822 
823 
824 BSize
825 BTextControl::PreferredSize()
826 {
827 	CALLED();
828 
829 	_ValidateLayoutData();
830 	return BLayoutUtils::ComposeSize(ExplicitPreferredSize(), fLayoutData->min);
831 }
832 
833 
834 BAlignment
835 BTextControl::LayoutAlignment()
836 {
837 	CALLED();
838 
839 	_ValidateLayoutData();
840 	return BLayoutUtils::ComposeAlignment(ExplicitAlignment(),
841 		BAlignment(B_ALIGN_LEFT, B_ALIGN_VERTICAL_CENTER));
842 }
843 
844 
845 BLayoutItem*
846 BTextControl::CreateLabelLayoutItem()
847 {
848 	if (!fLayoutData->label_layout_item)
849 		fLayoutData->label_layout_item = new LabelLayoutItem(this);
850 
851 	return fLayoutData->label_layout_item;
852 }
853 
854 
855 BLayoutItem*
856 BTextControl::CreateTextViewLayoutItem()
857 {
858 	if (!fLayoutData->text_view_layout_item)
859 		fLayoutData->text_view_layout_item = new TextViewLayoutItem(this);
860 
861 	return fLayoutData->text_view_layout_item;
862 }
863 
864 
865 void
866 BTextControl::DoLayout()
867 {
868 	// Bail out, if we shan't do layout.
869 	if (!(Flags() & B_SUPPORTS_LAYOUT))
870 		return;
871 
872 	CALLED();
873 
874 	// If the user set a layout, we let the base class version call its
875 	// hook.
876 	if (GetLayout()) {
877 		BView::DoLayout();
878 		return;
879 	}
880 
881 	_ValidateLayoutData();
882 
883 	// validate current size
884 	BSize size(Bounds().Size());
885 	if (size.width < fLayoutData->min.width)
886 		size.width = fLayoutData->min.width;
887 
888 	if (size.height < fLayoutData->min.height)
889 		size.height = fLayoutData->min.height;
890 
891 	BRect dirty(fText->Frame());
892 	BRect textFrame;
893 
894 	// divider
895 	float divider = 0;
896 	if (fLayoutData->text_view_layout_item != NULL) {
897 		if (fLayoutData->label_layout_item != NULL) {
898 			// We have layout items. They define the divider location.
899 			divider = fabs(fLayoutData->text_view_layout_item->Frame().left
900 				- fLayoutData->label_layout_item->Frame().left);
901 		}
902 		textFrame = fLayoutData->text_view_layout_item->FrameInParent();
903 	} else {
904 		if (fLayoutData->label_width > 0) {
905 			divider = fLayoutData->label_width
906 				+ be_control_look->DefaultLabelSpacing();
907 		}
908 		textFrame.Set(divider, 0, size.width, size.height);
909 	}
910 
911 	// place the text view and set the divider
912 	textFrame.InsetBy(kFrameMargin, kFrameMargin);
913 	BLayoutUtils::AlignInFrame(fText, textFrame);
914 
915 	fDivider = divider;
916 
917 	// invalidate dirty region
918 	dirty = dirty | fText->Frame();
919 	dirty.InsetBy(-kFrameMargin, -kFrameMargin);
920 
921 	Invalidate(dirty);
922 }
923 
924 
925 // #pragma mark - protected methods
926 
927 
928 status_t
929 BTextControl::SetIcon(const BBitmap* icon, uint32 flags)
930 {
931 	return BControl::SetIcon(icon, flags);
932 }
933 
934 
935 // #pragma mark - private methods
936 
937 
938 status_t
939 BTextControl::Perform(perform_code code, void* _data)
940 {
941 	switch (code) {
942 		case PERFORM_CODE_MIN_SIZE:
943 			((perform_data_min_size*)_data)->return_value
944 				= BTextControl::MinSize();
945 			return B_OK;
946 
947 		case PERFORM_CODE_MAX_SIZE:
948 			((perform_data_max_size*)_data)->return_value
949 				= BTextControl::MaxSize();
950 			return B_OK;
951 
952 		case PERFORM_CODE_PREFERRED_SIZE:
953 			((perform_data_preferred_size*)_data)->return_value
954 				= BTextControl::PreferredSize();
955 			return B_OK;
956 
957 		case PERFORM_CODE_LAYOUT_ALIGNMENT:
958 			((perform_data_layout_alignment*)_data)->return_value
959 				= BTextControl::LayoutAlignment();
960 			return B_OK;
961 
962 		case PERFORM_CODE_HAS_HEIGHT_FOR_WIDTH:
963 			((perform_data_has_height_for_width*)_data)->return_value
964 				= BTextControl::HasHeightForWidth();
965 			return B_OK;
966 
967 		case PERFORM_CODE_GET_HEIGHT_FOR_WIDTH:
968 		{
969 			perform_data_get_height_for_width* data
970 				= (perform_data_get_height_for_width*)_data;
971 			BTextControl::GetHeightForWidth(data->width, &data->min, &data->max,
972 				&data->preferred);
973 			return B_OK;
974 		}
975 
976 		case PERFORM_CODE_SET_LAYOUT:
977 		{
978 			perform_data_set_layout* data = (perform_data_set_layout*)_data;
979 			BTextControl::SetLayout(data->layout);
980 			return B_OK;
981 		}
982 
983 		case PERFORM_CODE_LAYOUT_INVALIDATED:
984 		{
985 			perform_data_layout_invalidated* data
986 				= (perform_data_layout_invalidated*)_data;
987 			BTextControl::LayoutInvalidated(data->descendants);
988 			return B_OK;
989 		}
990 
991 		case PERFORM_CODE_DO_LAYOUT:
992 		{
993 			BTextControl::DoLayout();
994 			return B_OK;
995 		}
996 
997 		case PERFORM_CODE_SET_ICON:
998 		{
999 			perform_data_set_icon* data = (perform_data_set_icon*)_data;
1000 			return BTextControl::SetIcon(data->icon, data->flags);
1001 		}
1002 
1003 		case PERFORM_CODE_ALL_UNARCHIVED:
1004 		{
1005 			perform_data_all_unarchived* data
1006 				= (perform_data_all_unarchived*)_data;
1007 			data->return_value = BTextControl::AllUnarchived(data->archive);
1008 			return B_OK;
1009 		}
1010 
1011 		case PERFORM_CODE_ALL_ARCHIVED:
1012 		{
1013 			perform_data_all_archived* data
1014 				= (perform_data_all_archived*)_data;
1015 			data->return_value = BTextControl::AllArchived(data->archive);
1016 			return B_OK;
1017 		}
1018 	}
1019 
1020 	return BControl::Perform(code, _data);
1021 }
1022 
1023 
1024 //	#pragma mark - FBC padding
1025 
1026 
1027 void BTextControl::_ReservedTextControl1() {}
1028 void BTextControl::_ReservedTextControl2() {}
1029 void BTextControl::_ReservedTextControl3() {}
1030 void BTextControl::_ReservedTextControl4() {}
1031 
1032 
1033 BTextControl&
1034 BTextControl::operator=(const BTextControl&)
1035 {
1036 	return *this;
1037 }
1038 
1039 
1040 void
1041 BTextControl::_UpdateTextViewColors(bool enable)
1042 {
1043 	rgb_color textColor = ui_color(B_DOCUMENT_TEXT_COLOR);
1044 	rgb_color viewColor = ui_color(B_DOCUMENT_BACKGROUND_COLOR);
1045 	BFont font;
1046 
1047 	fText->GetFontAndColor(0, &font);
1048 
1049 	if (!enable) {
1050 		textColor = disable_color(textColor, ViewColor());
1051 		viewColor = disable_color(ViewColor(), viewColor);
1052 	}
1053 
1054 	fText->SetFontAndColor(&font, B_FONT_ALL, &textColor);
1055 	fText->SetViewColor(viewColor);
1056 	fText->SetLowColor(viewColor);
1057 }
1058 
1059 
1060 void
1061 BTextControl::_CommitValue()
1062 {
1063 }
1064 
1065 
1066 void
1067 BTextControl::_InitData(const char* label, const BMessage* archive)
1068 {
1069 	BRect bounds(Bounds());
1070 
1071 	fText = NULL;
1072 	fModificationMessage = NULL;
1073 	fLabelAlign = B_ALIGN_LEFT;
1074 	fDivider = 0.0f;
1075 	fLayoutData = new LayoutData(bounds.Width(), bounds.Height());
1076 
1077 	int32 flags = 0;
1078 
1079 	BFont font(be_plain_font);
1080 
1081 	if (!archive || !archive->HasString("_fname"))
1082 		flags |= B_FONT_FAMILY_AND_STYLE;
1083 
1084 	if (!archive || !archive->HasFloat("_fflt"))
1085 		flags |= B_FONT_SIZE;
1086 
1087 	if (flags != 0)
1088 		SetFont(&font, flags);
1089 
1090 	if (label != NULL)
1091 		fDivider = floorf(bounds.Width() / 2.0f);
1092 
1093 	fLook = 0;
1094 }
1095 
1096 
1097 void
1098 BTextControl::_InitText(const char* initialText, const BMessage* archive)
1099 {
1100 	if (archive)
1101 		fText = static_cast<BPrivate::_BTextInput_*>(FindView("_input_"));
1102 
1103 	if (fText == NULL) {
1104 		BRect bounds(Bounds());
1105 		BRect frame(fDivider, bounds.top, bounds.right, bounds.bottom);
1106 		// we are stroking the frame around the text view, which
1107 		// is 2 pixels wide
1108 		frame.InsetBy(kFrameMargin, kFrameMargin);
1109 		BRect textRect(frame.OffsetToCopy(B_ORIGIN));
1110 
1111 		fText = new BPrivate::_BTextInput_(frame, textRect,
1112 			B_FOLLOW_ALL, B_WILL_DRAW | B_FRAME_EVENTS
1113 			| (Flags() & B_NAVIGABLE));
1114 		AddChild(fText);
1115 
1116 		SetText(initialText);
1117 		fText->SetAlignment(B_ALIGN_LEFT);
1118 		fText->AlignTextRect();
1119 	}
1120 
1121 	// Although this is not strictly initializing the text view,
1122 	// it cannot be done while fText is NULL, so it resides here.
1123 	if (archive) {
1124 		int32 labelAlignment = B_ALIGN_LEFT;
1125 		int32 textAlignment = B_ALIGN_LEFT;
1126 
1127 		status_t err = B_OK;
1128 		if (archive->HasInt32("_a_label"))
1129 			err = archive->FindInt32("_a_label", &labelAlignment);
1130 
1131 		if (err == B_OK && archive->HasInt32("_a_text"))
1132 			err = archive->FindInt32("_a_text", &textAlignment);
1133 
1134 		SetAlignment((alignment)labelAlignment, (alignment)textAlignment);
1135 	}
1136 
1137 	uint32 navigableFlags = Flags() & B_NAVIGABLE;
1138 	if (navigableFlags != 0)
1139 		BView::SetFlags(Flags() & ~B_NAVIGABLE);
1140 }
1141 
1142 
1143 void
1144 BTextControl::_ValidateLayout()
1145 {
1146 	CALLED();
1147 
1148 	_ValidateLayoutData();
1149 
1150 	ResizeTo(Bounds().Width(), fLayoutData->min.height);
1151 
1152 	_LayoutTextView();
1153 }
1154 
1155 
1156 void
1157 BTextControl::_LayoutTextView()
1158 {
1159 	CALLED();
1160 
1161 	BRect frame;
1162 	if (fLayoutData->text_view_layout_item != NULL) {
1163 		frame = fLayoutData->text_view_layout_item->FrameInParent();
1164 	} else {
1165 		frame = Bounds();
1166 		frame.left = fDivider;
1167 	}
1168 
1169 	// we are stroking the frame around the text view, which
1170 	// is 2 pixels wide
1171 	frame.InsetBy(kFrameMargin, kFrameMargin);
1172 	fText->MoveTo(frame.left, frame.top);
1173 	fText->ResizeTo(frame.Width(), frame.Height());
1174 	fText->AlignTextRect();
1175 
1176 	TRACE("width: %.2f, height: %.2f\n", Frame().Width(), Frame().Height());
1177 	TRACE("fDivider: %.2f\n", fDivider);
1178 	TRACE("fText frame: (%.2f, %.2f, %.2f, %.2f)\n",
1179 		frame.left, frame.top, frame.right, frame.bottom);
1180 }
1181 
1182 
1183 void
1184 BTextControl::_UpdateFrame()
1185 {
1186 	CALLED();
1187 
1188 	if (fLayoutData->text_view_layout_item != NULL) {
1189 		BRect textFrame = fLayoutData->text_view_layout_item->Frame();
1190 		BRect labelFrame;
1191 		if (fLayoutData->label_layout_item != NULL)
1192 			labelFrame = fLayoutData->label_layout_item->Frame();
1193 
1194 		BRect frame;
1195 		if (labelFrame.IsValid()) {
1196 			frame = textFrame | labelFrame;
1197 
1198 			// update divider
1199 			fDivider = fabs(textFrame.left - labelFrame.left);
1200 		} else {
1201 			frame = textFrame;
1202 			fDivider = 0;
1203 		}
1204 
1205 		// update our frame
1206 		MoveTo(frame.left, frame.top);
1207 		BSize oldSize(Bounds().Size());
1208 		ResizeTo(frame.Width(), frame.Height());
1209 		BSize newSize(Bounds().Size());
1210 
1211 		// If the size changes, ResizeTo() will trigger a relayout, otherwise
1212 		// we need to do that explicitly.
1213 		if (newSize != oldSize)
1214 			Relayout();
1215 	}
1216 }
1217 
1218 
1219 void
1220 BTextControl::_ValidateLayoutData()
1221 {
1222 	CALLED();
1223 
1224 	if (fLayoutData->valid)
1225 		return;
1226 
1227 	// cache font height
1228 	font_height& fh = fLayoutData->font_info;
1229 	GetFontHeight(&fh);
1230 
1231 	const char* label = Label();
1232 	if (label != NULL) {
1233 		fLayoutData->label_width = ceilf(StringWidth(label));
1234 		fLayoutData->label_height = ceilf(fh.ascent) + ceilf(fh.descent);
1235 	} else {
1236 		fLayoutData->label_width = 0;
1237 		fLayoutData->label_height = 0;
1238 	}
1239 
1240 	// compute the minimal divider
1241 	float divider = 0;
1242 	if (fLayoutData->label_width > 0) {
1243 		divider = fLayoutData->label_width
1244 			+ be_control_look->DefaultLabelSpacing();
1245 	}
1246 
1247 	// If we shan't do real layout, we let the current divider take influence.
1248 	if (!(Flags() & B_SUPPORTS_LAYOUT))
1249 		divider = max_c(divider, fDivider);
1250 
1251 	// get the minimal (== preferred) text view size
1252 	fLayoutData->text_view_min = fText->MinSize();
1253 
1254 	TRACE("text view min width: %.2f\n", fLayoutData->text_view_min.width);
1255 
1256 	// compute our minimal (== preferred) size
1257 	BSize min(fLayoutData->text_view_min);
1258 	min.width += 2 * kFrameMargin;
1259 	min.height += 2 * kFrameMargin;
1260 
1261 	if (divider > 0)
1262 		min.width += divider;
1263 
1264 	if (fLayoutData->label_height > min.height)
1265 		min.height = fLayoutData->label_height;
1266 
1267 	fLayoutData->min = min;
1268 
1269 	fLayoutData->valid = true;
1270 	ResetLayoutInvalidation();
1271 
1272 	TRACE("width: %.2f, height: %.2f\n", min.width, min.height);
1273 }
1274 
1275 
1276 // #pragma mark - BTextControl::LabelLayoutItem
1277 
1278 
1279 BTextControl::LabelLayoutItem::LabelLayoutItem(BTextControl* parent)
1280 	:
1281 	fParent(parent),
1282 	fFrame()
1283 {
1284 }
1285 
1286 
1287 BTextControl::LabelLayoutItem::LabelLayoutItem(BMessage* from)
1288 	:
1289 	BAbstractLayoutItem(from),
1290 	fParent(NULL),
1291 	fFrame()
1292 {
1293 	from->FindRect(kFrameField, &fFrame);
1294 }
1295 
1296 
1297 bool
1298 BTextControl::LabelLayoutItem::IsVisible()
1299 {
1300 	return !fParent->IsHidden(fParent);
1301 }
1302 
1303 
1304 void
1305 BTextControl::LabelLayoutItem::SetVisible(bool visible)
1306 {
1307 	// not allowed
1308 }
1309 
1310 
1311 BRect
1312 BTextControl::LabelLayoutItem::Frame()
1313 {
1314 	return fFrame;
1315 }
1316 
1317 
1318 void
1319 BTextControl::LabelLayoutItem::SetFrame(BRect frame)
1320 {
1321 	fFrame = frame;
1322 	fParent->_UpdateFrame();
1323 }
1324 
1325 
1326 void
1327 BTextControl::LabelLayoutItem::SetParent(BTextControl* parent)
1328 {
1329 	fParent = parent;
1330 }
1331 
1332 
1333 BView*
1334 BTextControl::LabelLayoutItem::View()
1335 {
1336 	return fParent;
1337 }
1338 
1339 
1340 BSize
1341 BTextControl::LabelLayoutItem::BaseMinSize()
1342 {
1343 	fParent->_ValidateLayoutData();
1344 
1345 	if (!fParent->Label())
1346 		return BSize(-1, -1);
1347 
1348 	return BSize(fParent->fLayoutData->label_width
1349 			+ be_control_look->DefaultLabelSpacing(),
1350 		fParent->fLayoutData->label_height);
1351 }
1352 
1353 
1354 BSize
1355 BTextControl::LabelLayoutItem::BaseMaxSize()
1356 {
1357 	return BaseMinSize();
1358 }
1359 
1360 
1361 BSize
1362 BTextControl::LabelLayoutItem::BasePreferredSize()
1363 {
1364 	return BaseMinSize();
1365 }
1366 
1367 
1368 BAlignment
1369 BTextControl::LabelLayoutItem::BaseAlignment()
1370 {
1371 	return BAlignment(B_ALIGN_USE_FULL_WIDTH, B_ALIGN_USE_FULL_HEIGHT);
1372 }
1373 
1374 
1375 BRect
1376 BTextControl::LabelLayoutItem::FrameInParent() const
1377 {
1378 	return fFrame.OffsetByCopy(-fParent->Frame().left, -fParent->Frame().top);
1379 }
1380 
1381 
1382 status_t
1383 BTextControl::LabelLayoutItem::Archive(BMessage* into, bool deep) const
1384 {
1385 	BArchiver archiver(into);
1386 	status_t err = BAbstractLayoutItem::Archive(into, deep);
1387 	if (err == B_OK)
1388 		err = into->AddRect(kFrameField, fFrame);
1389 
1390 	return archiver.Finish(err);
1391 }
1392 
1393 
1394 BArchivable*
1395 BTextControl::LabelLayoutItem::Instantiate(BMessage* from)
1396 {
1397 	if (validate_instantiation(from, "BTextControl::LabelLayoutItem"))
1398 		return new LabelLayoutItem(from);
1399 	return NULL;
1400 }
1401 
1402 
1403 // #pragma mark - BTextControl::TextViewLayoutItem
1404 
1405 
1406 BTextControl::TextViewLayoutItem::TextViewLayoutItem(BTextControl* parent)
1407 	:
1408 	fParent(parent),
1409 	fFrame()
1410 {
1411 	// by default the part right of the divider shall have an unlimited maximum
1412 	// width
1413 	SetExplicitMaxSize(BSize(B_SIZE_UNLIMITED, B_SIZE_UNSET));
1414 }
1415 
1416 
1417 BTextControl::TextViewLayoutItem::TextViewLayoutItem(BMessage* from)
1418 	:
1419 	BAbstractLayoutItem(from),
1420 	fParent(NULL),
1421 	fFrame()
1422 {
1423 	from->FindRect(kFrameField, &fFrame);
1424 }
1425 
1426 
1427 bool
1428 BTextControl::TextViewLayoutItem::IsVisible()
1429 {
1430 	return !fParent->IsHidden(fParent);
1431 }
1432 
1433 
1434 void
1435 BTextControl::TextViewLayoutItem::SetVisible(bool visible)
1436 {
1437 	// not allowed
1438 }
1439 
1440 
1441 BRect
1442 BTextControl::TextViewLayoutItem::Frame()
1443 {
1444 	return fFrame;
1445 }
1446 
1447 
1448 void
1449 BTextControl::TextViewLayoutItem::SetFrame(BRect frame)
1450 {
1451 	fFrame = frame;
1452 	fParent->_UpdateFrame();
1453 }
1454 
1455 
1456 void
1457 BTextControl::TextViewLayoutItem::SetParent(BTextControl* parent)
1458 {
1459 	fParent = parent;
1460 }
1461 
1462 
1463 BView*
1464 BTextControl::TextViewLayoutItem::View()
1465 {
1466 	return fParent;
1467 }
1468 
1469 
1470 BSize
1471 BTextControl::TextViewLayoutItem::BaseMinSize()
1472 {
1473 	fParent->_ValidateLayoutData();
1474 
1475 	BSize size = fParent->fLayoutData->text_view_min;
1476 	size.width += 2 * kFrameMargin;
1477 	size.height += 2 * kFrameMargin;
1478 
1479 	return size;
1480 }
1481 
1482 
1483 BSize
1484 BTextControl::TextViewLayoutItem::BaseMaxSize()
1485 {
1486 	BSize size(BaseMinSize());
1487 	size.width = B_SIZE_UNLIMITED;
1488 
1489 	return size;
1490 }
1491 
1492 
1493 BSize
1494 BTextControl::TextViewLayoutItem::BasePreferredSize()
1495 {
1496 	BSize size(BaseMinSize());
1497 	// puh, no idea...
1498 	size.width = 100;
1499 
1500 	return size;
1501 }
1502 
1503 
1504 BAlignment
1505 BTextControl::TextViewLayoutItem::BaseAlignment()
1506 {
1507 	return BAlignment(B_ALIGN_USE_FULL_WIDTH, B_ALIGN_USE_FULL_HEIGHT);
1508 }
1509 
1510 
1511 BRect
1512 BTextControl::TextViewLayoutItem::FrameInParent() const
1513 {
1514 	return fFrame.OffsetByCopy(-fParent->Frame().left, -fParent->Frame().top);
1515 }
1516 
1517 
1518 status_t
1519 BTextControl::TextViewLayoutItem::Archive(BMessage* into, bool deep) const
1520 {
1521 	BArchiver archiver(into);
1522 	status_t err = BAbstractLayoutItem::Archive(into, deep);
1523 	if (err == B_OK)
1524 		err = into->AddRect(kFrameField, fFrame);
1525 
1526 	return archiver.Finish(err);
1527 }
1528 
1529 
1530 BArchivable*
1531 BTextControl::TextViewLayoutItem::Instantiate(BMessage* from)
1532 {
1533 	if (validate_instantiation(from, "BTextControl::TextViewLayoutItem"))
1534 		return new TextViewLayoutItem(from);
1535 
1536 	return NULL;
1537 }
1538 
1539 
1540 extern "C" void
1541 B_IF_GCC_2(InvalidateLayout__12BTextControlb,
1542 	_ZN12BTextControl16InvalidateLayoutEb)(BView* view, bool descendants)
1543 {
1544 	perform_data_layout_invalidated data;
1545 	data.descendants = descendants;
1546 
1547 	view->Perform(PERFORM_CODE_LAYOUT_INVALIDATED, &data);
1548 }
1549