i2p/haiku-beta6
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fixes

Browse Source 
git-svn-id: file:///srv/svn/repos/haiku/trunk/current@3536 a95241bf-73f2-0310-859d-f6bbb57e9c96
This commit is contained in:
Marc Flerackers
2003-06-16 07:27:24 +00:00
parent 0e06ebe5d7
commit 9cb2dbe29d
5 changed files with 1774 additions and 1521 deletions
Download Patch File Download Diff File Expand all files Collapse all files
headers/private/interface/TextInput.h
+27 -18
View File
@@ -46,27 +46,36 @@ class BTextControl;
// _BTextInput_ class ---------------------------------------------------------- // _BTextInput_ class ----------------------------------------------------------
class _BTextInput_ : public BTextView { class _BTextInput_ : public BTextView {
public: public:
_BTextInput_(BTextControl* parent, BRect frame, _BTextInput_(BRect frame, BRect textRect,
const char* name, BRect rect, uint32 resizeMask,
uint32 mask = B_FOLLOW_LEFT | B_FOLLOW_TOP, uint32 flags = B_WILL_DRAW | B_PULSE_NEEDED);
uint32 flags = B_WILL_DRAW | B_NAVIGABLE); _BTextInput_(BMessage *data);
~_BTextInput_(); ~_BTextInput_();
virtual void AttachedToWindow(); static BArchivable* Instantiate(BMessage *data);
virtual void MakeFocus(bool state = true); virtual status_t Archive(BMessage *data, bool deep = true) const;
virtual void SetViewColor(rgb_color);
rgb_color ViewColor(); virtual void FrameResized(float width, float height);
virtual bool CanEndLine(int32); virtual void KeyDown(const char *bytes, int32 numBytes);
virtual void KeyDown(const char* bytes, int32 numBytes); virtual void MakeFocus(bool focusState = true);
virtual void Draw(BRect);
virtual void SetEnabled(bool state); void AlignTextRect();
virtual void MouseDown(BPoint where); void SetInitialText();
virtual void Paste(BClipboard *clipboard);
protected:
virtual void InsertText(const char *inText, int32 inLength,
int32 inOffset, const text_run_array *inRuns);
virtual void DeleteText(int32 fromOffset, int32 toOffset);
private: private:
rgb_color fViewColor;
bool fEnabled; BTextControl *TextControl();
bool fChanged;
BTextControl* fParent; char *fPreviousText;
bool fBool;
}; };
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
src/kits/interface/Box.cpp
+388 -362
View File
@@ -1,362 +1,388 @@
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
// Copyright (c) 2001-2002, OpenBeOS // Copyright (c) 2001-2002, OpenBeOS
// //
// Permission is hereby granted, free of charge, to any person obtaining a // Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the "Software"), // copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation // to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense, // the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom the // and/or sell copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following conditions: // Software is furnished to do so, subject to the following conditions:
// //
// The above copyright notice and this permission notice shall be included in // The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software. // all copies or substantial portions of the Software.
// //
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE. // DEALINGS IN THE SOFTWARE.
// //
// File Name: Box.cpp // File Name: Box.cpp
// Author: Marc Flerackers ([email protected]) // Author: Marc Flerackers ([email protected])
// Description: BBox objects group views together and draw a border // Description: BBox objects group views together and draw a border
// around them. // around them.
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
// Standard Includes ----------------------------------------------------------- // Standard Includes -----------------------------------------------------------
#include <string.h> #include <string.h>
// System Includes ------------------------------------------------------------- // System Includes -------------------------------------------------------------
#include <Box.h> #include <Box.h>
#include <Errors.h> #include <Errors.h>
#include <Message.h> #include <Message.h>
// Project Includes ------------------------------------------------------------ // Project Includes ------------------------------------------------------------
// Local Includes -------------------------------------------------------------- // Local Includes --------------------------------------------------------------
// Local Defines --------------------------------------------------------------- // Local Defines ---------------------------------------------------------------
// Globals --------------------------------------------------------------------- // Globals ---------------------------------------------------------------------
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
BBox::BBox(BRect frame, const char *name, uint32 resizingMode, uint32 flags, BBox::BBox(BRect frame, const char *name, uint32 resizingMode, uint32 flags,
border_style border) border_style border)
: BView(frame, name, resizingMode, flags), : BView(frame, name, resizingMode, flags)
fLabel(NULL), {
fStyle(border), SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR));
fLabelView(NULL) SetLowColor(ui_color(B_PANEL_BACKGROUND_COLOR));
{
fBounds = Bounds(); InitObject();
}
SetFont(be_bold_font); //------------------------------------------------------------------------------
SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR)); BBox::~BBox()
} {
//------------------------------------------------------------------------------ ClearAnyLabel();
BBox::~BBox() }
{ //------------------------------------------------------------------------------
if (fLabel) BBox::BBox(BMessage *archive)
delete fLabel; : BView(archive)
} {
//------------------------------------------------------------------------------ InitObject(archive);
BBox::BBox(BMessage *archive)
: BView(archive) const char *string;
{
fBounds = Bounds(); if (archive->FindString("_label", &string) == B_OK)
fLabelView = NULL; SetLabel(string);
const char *string; bool aBool;
int32 anInt32;
if (archive->FindString("_label", &string) != B_OK)
fLabel = NULL; if (archive->FindBool("_style", &aBool) == B_OK)
else fStyle = aBool ? B_FANCY_BORDER : B_PLAIN_BORDER;
SetLabel(string); else if (archive->FindInt32("_style", &anInt32) == B_OK)
fStyle = (border_style)anInt32;
int32 anInt32;
if (archive->FindBool("_lblview", &aBool) == B_OK)
if (archive->FindInt32("_style", &anInt32) != B_OK) fLabelView = ChildAt(0);
fStyle = B_FANCY_BORDER; }
else //------------------------------------------------------------------------------
fStyle = (border_style)anInt32; BArchivable *BBox::Instantiate(BMessage *archive)
} {
//------------------------------------------------------------------------------ if (validate_instantiation(archive, "BBox"))
BArchivable *BBox::Instantiate(BMessage *archive) return new BBox(archive);
{ else
if ( validate_instantiation ( archive, "BBox" ) ) return NULL;
return new BBox ( archive ); }
else //------------------------------------------------------------------------------
return NULL; status_t BBox::Archive(BMessage *archive, bool deep) const
} {
//------------------------------------------------------------------------------ BView::Archive(archive, deep);
status_t BBox::Archive(BMessage *archive, bool deep) const
{ if (fLabel)
status_t err = BView::Archive(archive, deep); archive->AddString("_label", fLabel);
if (err != B_OK) if (fLabelView)
return err; archive->AddBool("_lblview", true);
if (fLabel) if (fStyle != B_FANCY_BORDER)
err = archive->AddString("_label",fLabel); archive->AddInt32("_style", fStyle);
if (err != B_OK) return B_OK;
return err; }
//------------------------------------------------------------------------------
if (fStyle != B_FANCY_BORDER) void BBox::SetBorder(border_style border)
err = archive->AddInt32("_style", fStyle); {
fStyle = border;
return err;
} LockLooper();
//------------------------------------------------------------------------------ Invalidate();
void BBox::SetBorder(border_style border) UnlockLooper();
{ }
fStyle = border; //------------------------------------------------------------------------------
border_style BBox::Border() const
Invalidate(); {
} return fStyle;
//------------------------------------------------------------------------------ }
border_style BBox::Border() const //------------------------------------------------------------------------------
{ void BBox::SetLabel(const char *string)
return fStyle; {
} ClearAnyLabel();
//------------------------------------------------------------------------------
void BBox::SetLabel(const char *string) if (string)
{ {
if (fLabel) // Update fBounds
delete fLabel; fBounds = Bounds();
font_height fh;
fLabel = strdup(string); GetFontHeight(&fh);
// Update fBounds fBounds.top = (float)ceil((fh.ascent + fh.descent) / 2.0f);
fBounds = Bounds();
fLabel = strdup(string);
if (fLabel) }
{
font_height fh; if (Window())
GetFontHeight(&fh); Invalidate();
}
fBounds.top = (float)ceil((fh.ascent + fh.descent) / 2.0f); //------------------------------------------------------------------------------
} status_t BBox::SetLabel(BView *viewLabel)
{
Invalidate(); ClearAnyLabel();
}
//------------------------------------------------------------------------------ if (viewLabel)
status_t BBox::SetLabel(BView *viewLabel) {
{ // Update fBounds
if (viewLabel) fBounds = Bounds();
{ font_height fh;
if (fLabelView) GetFontHeight(&fh);
RemoveChild(fLabelView);
fBounds.top = (float)ceil(viewLabel->Bounds().Height() / 2.0f);
fLabelView = viewLabel;
AddChild(fLabelView); fLabelView = viewLabel;
fLabelView->MoveTo(10.0f, 0.0f);
if(fLabel) AddChild(fLabelView, ChildAt(0));
{ }
delete fLabel;
fLabel = NULL; if (Window())
} Invalidate();
}
return B_OK;
// Update fBounds }
fBounds = Bounds(); //------------------------------------------------------------------------------
const char *BBox::Label() const
if (fLabelView) {
fBounds.top = (float)ceil(fLabelView->Frame().Height() / 2.0f); return fLabel;
}
Invalidate(); //------------------------------------------------------------------------------
BView *BBox::LabelView() const
return B_OK; {
} return fLabelView;
//------------------------------------------------------------------------------ }
const char *BBox::Label() const //------------------------------------------------------------------------------
{ void BBox::Draw(BRect updateRect)
return fLabel; {
} switch (fStyle)
//------------------------------------------------------------------------------ {
BView *BBox::LabelView() const case B_FANCY_BORDER:
{ DrawFancy();
return fLabelView; break;
}
//------------------------------------------------------------------------------ case B_PLAIN_BORDER:
void BBox::Draw(BRect updateRect) DrawPlain();
{ break;
switch (fStyle)
{ default:
case B_FANCY_BORDER: break;
DrawFancy(); }
break;
if (fLabel)
case B_PLAIN_BORDER: {
DrawPlain(); font_height fh;
break; GetFontHeight(&fh);
default: SetHighColor(ViewColor());
break;
} FillRect(BRect(6.0f, 1.0f, 12.0f + StringWidth(fLabel),
(float)ceil(fh.ascent + fh.descent))/*, B_SOLID_LOW*/);
if (fLabel)
{ SetHighColor(0, 0, 0);
font_height fh; DrawString(fLabel, BPoint(10.0f, (float)ceil(fh.ascent - fh.descent)
GetFontHeight(&fh); + 1.0f));
}
SetHighColor(ViewColor()); }
//------------------------------------------------------------------------------
FillRect(BRect(6.0f, 1.0f, 12.0f + StringWidth(fLabel), void BBox::AttachedToWindow()
(float)ceil(fh.ascent + fh.descent))/*, B_SOLID_LOW*/); {
if (Parent())
SetHighColor(0, 0, 0); {
DrawString(fLabel, BPoint(10.0f, (float)ceil(fh.ascent - fh.descent) + 1.0f )); SetViewColor(Parent()->ViewColor());
} SetLowColor(Parent()->ViewColor());
} }
//------------------------------------------------------------------------------ }
void BBox::AttachedToWindow() //------------------------------------------------------------------------------
{ void BBox::DetachedFromWindow()
if (Parent()) {
{ BView::DetachedFromWindow();
SetViewColor(Parent()->ViewColor()); }
SetLowColor(Parent()->ViewColor()); //------------------------------------------------------------------------------
} void BBox::AllAttached()
} {
//------------------------------------------------------------------------------ BView::AllAttached();
void BBox::DetachedFromWindow() }
{ //------------------------------------------------------------------------------
BView::DetachedFromWindow(); void BBox::AllDetached()
} {
//------------------------------------------------------------------------------ BView::AllDetached();
void BBox::AllAttached() }
{ //------------------------------------------------------------------------------
BView::AllAttached(); void BBox::FrameResized(float width, float height)
} {
//------------------------------------------------------------------------------ BRect bounds(Bounds());
void BBox::AllDetached()
{ fBounds.right = Bounds().right;
BView::AllDetached(); fBounds.bottom = Bounds().bottom;
}
//------------------------------------------------------------------------------ Invalidate();
void BBox::FrameResized(float width, float height) }
{ //------------------------------------------------------------------------------
fBounds.right = Bounds().right; void BBox::MessageReceived(BMessage *message)
fBounds.bottom = Bounds().bottom; {
} BView::MessageReceived(message);
//------------------------------------------------------------------------------ }
void BBox::MessageReceived(BMessage *message) //------------------------------------------------------------------------------
{ void BBox::MouseDown(BPoint point)
BView::MessageReceived(message); {
} BView::MouseDown(point);
//------------------------------------------------------------------------------ }
void BBox::MouseDown(BPoint point) //------------------------------------------------------------------------------
{ void BBox::MouseUp(BPoint point)
BView::MouseDown(point); {
} BView::MouseUp(point);
//------------------------------------------------------------------------------ }
void BBox::MouseUp(BPoint point) //------------------------------------------------------------------------------
{ void BBox::WindowActivated(bool active)
BView::MouseUp(point); {
} BView::WindowActivated(active);
//------------------------------------------------------------------------------ }
void BBox::WindowActivated(bool active) //------------------------------------------------------------------------------
{ void BBox::MouseMoved(BPoint point, uint32 transit, const BMessage *message)
BView::WindowActivated(active); {
} BView::MouseMoved(point, transit, message);
//------------------------------------------------------------------------------ }
void BBox::MouseMoved(BPoint point, uint32 transit, const BMessage *message) //------------------------------------------------------------------------------
{ void BBox::FrameMoved(BPoint newLocation)
BView::MouseMoved(point, transit, message); {
} BView::FrameMoved(newLocation);
//------------------------------------------------------------------------------ }
void BBox::FrameMoved(BPoint newLocation) //------------------------------------------------------------------------------
{ BHandler *BBox::ResolveSpecifier(BMessage *message, int32 index,
BView::FrameMoved(newLocation); BMessage *specifier, int32 what,
} const char *property)
//------------------------------------------------------------------------------ {
BHandler *BBox::ResolveSpecifier(BMessage *message, int32 index, return BView::ResolveSpecifier(message, index, specifier, what, property);
BMessage *specifier, int32 what, }
const char *property) //------------------------------------------------------------------------------
{ void BBox::ResizeToPreferred()
return BView::ResolveSpecifier(message, index, specifier, what, property); {
} BView::ResizeToPreferred();
//------------------------------------------------------------------------------ }
void BBox::ResizeToPreferred() //------------------------------------------------------------------------------
{ void BBox::GetPreferredSize(float *width, float *height)
BView::ResizeToPreferred(); {
} /* BRect rect(0,0,99,99);
//------------------------------------------------------------------------------
void BBox::GetPreferredSize(float *width, float *height) if (Parent())
{ {
BRect rect(0,0,99,99); rect = Parent()->Bounds();
rect.InsetBy(10,10);
if (Parent()) }
{
rect = Parent()->Bounds(); *width = rect.Width();
rect.InsetBy(10,10); *height = rect.Height();*/
}
BView::GetPreferredSize(width, height);
*width = rect.Width(); }
*height = rect.Height(); //------------------------------------------------------------------------------
} void BBox::MakeFocus(bool focused)
//------------------------------------------------------------------------------ {
void BBox::MakeFocus(bool focused) BView::MakeFocus(focused);
{ }
BView::MakeFocus(focused); //------------------------------------------------------------------------------
} status_t BBox::GetSupportedSuites(BMessage *message)
//------------------------------------------------------------------------------ {
status_t BBox::GetSupportedSuites(BMessage *message) return BView::GetSupportedSuites(message);
{ }
return BView::GetSupportedSuites(message); //------------------------------------------------------------------------------
} status_t BBox::Perform(perform_code d, void *arg)
//------------------------------------------------------------------------------ {
status_t BBox::Perform(perform_code d, void *arg) return BView::Perform(d, arg);
{ }
return B_ERROR; //------------------------------------------------------------------------------
} void BBox::_ReservedBox1() {}
//------------------------------------------------------------------------------ void BBox::_ReservedBox2() {}
void BBox::_ReservedBox1() {} //------------------------------------------------------------------------------
void BBox::_ReservedBox2() {} BBox &BBox::operator=(const BBox &)
//------------------------------------------------------------------------------ {
BBox &BBox::operator=(const BBox &) return *this;
{ }
return *this; //------------------------------------------------------------------------------
} void BBox::InitObject(BMessage *data)
//------------------------------------------------------------------------------ {
void BBox::InitObject(BMessage *data) fLabel = NULL;
{ fBounds = Bounds();
} fStyle = B_FANCY_BORDER;
//------------------------------------------------------------------------------ fLabelView = NULL;
void BBox::DrawPlain()
{ int32 flags = 0;
BRect rect = fBounds;
BFont font(be_bold_font);
SetHighColor(tint_color(ViewColor(), B_LIGHTEN_MAX_TINT));
StrokeLine(BPoint(rect.left, rect.bottom), BPoint(rect.left, rect.top)); if (!data || !data->HasString("_fname"))
StrokeLine(BPoint(rect.left+1.0f, rect.top), BPoint(rect.right, rect.top)); flags = 1;
SetHighColor(tint_color(ViewColor(), B_DARKEN_3_TINT));
StrokeLine(BPoint(rect.left+1.0f, rect.bottom), BPoint(rect.right, rect.bottom)); if (!data || !data->HasFloat("_fflt"))
StrokeLine(BPoint(rect.right, rect.bottom), BPoint(rect.right, rect.top+1.0f)); flags |= 2;
}
//------------------------------------------------------------------------------ if (flags != 0)
void BBox::DrawFancy() SetFont(&font, flags);
{ }
BRect rect = fBounds; //------------------------------------------------------------------------------
void BBox::DrawPlain()
SetHighColor(tint_color(ViewColor(), B_LIGHTEN_MAX_TINT)); {
rect.left++; BRect rect = fBounds;
rect.top++;
StrokeRect(rect); SetHighColor(tint_color(ViewColor(), B_LIGHTEN_MAX_TINT));
SetHighColor(tint_color(ViewColor(), B_DARKEN_3_TINT)); StrokeLine(BPoint(rect.left, rect.bottom), BPoint(rect.left, rect.top));
rect.OffsetBy(-1,-1); StrokeLine(BPoint(rect.left+1.0f, rect.top), BPoint(rect.right, rect.top));
StrokeRect(rect); SetHighColor(tint_color(ViewColor(), B_DARKEN_3_TINT));
} StrokeLine(BPoint(rect.left+1.0f, rect.bottom), BPoint(rect.right, rect.bottom));
//------------------------------------------------------------------------------ StrokeLine(BPoint(rect.right, rect.bottom), BPoint(rect.right, rect.top+1.0f));
void BBox::ClearAnyLabel() }
{ //------------------------------------------------------------------------------
} void BBox::DrawFancy()
//------------------------------------------------------------------------------ {
BRect rect = fBounds;
/*
* $Log $ SetHighColor(tint_color(ViewColor(), B_LIGHTEN_MAX_TINT));
* rect.left++;
* $Id $ rect.top++;
* StrokeRect(rect);
*/ SetHighColor(tint_color(ViewColor(), B_DARKEN_3_TINT));
rect.OffsetBy(-1,-1);
StrokeRect(rect);
}
//------------------------------------------------------------------------------
void BBox::ClearAnyLabel()
{
if (fLabel)
{
free(fLabel);
fLabel = NULL;
}
else if (fLabelView)
{
fLabelView->RemoveSelf();
delete fLabelView;
fLabelView = NULL;
}
}
//------------------------------------------------------------------------------
/*
* $Log $
*
* $Id $
*
*/
src/kits/interface/TabView.cpp
+858 -795
View File
File diff suppressed because it is too large Load Diff
src/kits/interface/TextControl.cpp
+338 -183
View File
@@ -42,136 +42,126 @@
// Globals --------------------------------------------------------------------- // Globals ---------------------------------------------------------------------
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
BTextControl::BTextControl(BRect frame, const char* name, const char* label, BTextControl::BTextControl(BRect frame, const char *name, const char *label,
const char* text, BMessage* message, uint32 mask, const char *text, BMessage *message, uint32 mask,
uint32 flags) uint32 flags)
: BControl(frame, name, label, message, mask, flags) : BControl(frame, name, label, message, mask, flags | B_FRAME_EVENTS)
{ {
if (label) InitData(label, text);
{
fDivider = frame.Width() / 2.0f;
}
else
{
// no label
fDivider = 0.0f;
}
fModificationMessage = NULL; BRect bounds(Bounds());
font_height fh;
GetFontHeight(&fh);
frame = Bounds(); float height = (float)ceil(fh.ascent + fh.descent + fh.leading);
if (fDivider) float lineHeight = fText->LineHeight(0);
{
frame.left = fDivider + 5.0f;
}
BRect rect(frame); ResizeTo(bounds.Width(), height + 8);
rect.OffsetTo(0,0);
frame.OffsetBy(-2,1); BRect textBounds(fText->Bounds());
rect.InsetBy(2,2); fText->ResizeTo(textBounds.Width(), lineHeight + 4);
fText = new _BTextInput_(this, frame, "text", rect); fText->MoveBy(0, (bounds.Height() - height) / 2.0f);
fText->SetText(text);
AddChild(fText);
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
BTextControl::~BTextControl() BTextControl::~BTextControl()
{ {
if (fText) SetModificationMessage(NULL);
{
fText->RemoveSelf();
delete fText;
}
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
BTextControl::BTextControl(BMessage* data) BTextControl::BTextControl(BMessage *data)
: BControl(data) : BControl(data)
{ {
if (data->FindInt32("_a_label", (int32*)&fLabelAlign) != B_OK) InitData(Label(), NULL, data);
{
fLabelAlign = B_ALIGN_LEFT;
}
alignment textAlign; int32 _a_label = B_ALIGN_LEFT;
if (data->FindInt32("_a_text", (int32*)&textAlign) != B_OK) int32 _a_text = B_ALIGN_LEFT;
if (data->HasInt32("_a_label"))
data->FindInt32("_a_label", &_a_label);
if (data->HasInt32("_a_text"))
data->FindInt32("_a_text", &_a_text);
SetAlignment((alignment)_a_label, (alignment)_a_text);
if (data->HasFloat("_divide"))
data->FindFloat("_a_text", &fDivider);
if (data->HasMessage("_mod_msg"))
{ {
fText->SetAlignment(B_ALIGN_LEFT); BMessage *_mod_msg = new BMessage;
data->FindMessage("_mod_msg", _mod_msg);
SetModificationMessage(_mod_msg);
} }
}
//------------------------------------------------------------------------------
BArchivable* BTextControl::Instantiate(BMessage *archive)
{
if (validate_instantiation(archive, "BTextControl"))
return new BTextControl(archive);
else else
{
fText->SetAlignment(textAlign);
}
if (data->FindFloat("_divide", &fDivider) != B_OK)
{
if (Label())
fDivider = Frame().Width()/2.0f;
else
fDivider = 0.0f;
}
if (data->FindMessage("_mod_msg", fModificationMessage) != B_OK)
{
fModificationMessage = NULL; // Is this really necessary?
}
// TODO: Recover additional info as per final implementation of Archive()
}
//------------------------------------------------------------------------------
BArchivable* BTextControl::Instantiate(BMessage* data)
{
if (!validate_instantiation(data,"BTextControl"))
{
return NULL; return NULL;
}
return new BTextControl(data);
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
status_t BTextControl::Archive(BMessage* data, bool deep) const status_t BTextControl::Archive(BMessage *data, bool deep) const
{ {
// TODO: compare against original version and finish BView::Archive(data, deep);
status_t err = BView::Archive(data, deep);
if (!err) alignment _a_label, _a_text;
err = data->AddInt32("_a_label", fLabelAlign);
if (!err)
err = data->AddInt32("_a_text", fText->Alignment());
if (!err)
err = data->AddFloat("_divide", fDivider);
if (!err && fModificationMessage)
err = data->AddMessage("_mod_msg", fModificationMessage);
return err; GetAlignment(&_a_label, &_a_text);
data->AddInt32("_a_label", _a_label);
data->AddInt32("_a_text", _a_text);
data->AddFloat("_divide", Divider());
if (ModificationMessage())
data->AddMessage("_mod_msg", ModificationMessage());
return B_OK;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void BTextControl::SetText(const char* text) void BTextControl::SetText(const char *text)
{ {
if (InvokeKind() != B_CONTROL_INVOKED)
return;
fText->SetText(text); fText->SetText(text);
if (IsFocus())
fText->SetInitialText();
fText->Invalidate();
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
const char* BTextControl::Text() const const char *BTextControl::Text() const
{ {
return fText->Text(); return fText->Text();
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void BTextControl::SetValue(int32 value) void BTextControl::SetValue(int32 value)
{ {
BControl::SetValue(value);
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
status_t BTextControl::Invoke(BMessage* msg) status_t BTextControl::Invoke(BMessage *msg)
{ {
return BControl::Invoke(msg); return BControl::Invoke(msg);
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
BTextView* BTextControl::TextView() const BTextView* BTextControl::TextView() const
{ {
return (BTextView*)fText; return fText;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void BTextControl::SetModificationMessage(BMessage* message) void BTextControl::SetModificationMessage(BMessage *message)
{ {
if (fModificationMessage)
delete fModificationMessage;
fModificationMessage = message; fModificationMessage = message;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
@@ -182,11 +172,17 @@ BMessage* BTextControl::ModificationMessage() const
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void BTextControl::SetAlignment(alignment label, alignment text) void BTextControl::SetAlignment(alignment label, alignment text)
{ {
fLabelAlign = label;
fText->SetAlignment(text); fText->SetAlignment(text);
fText->AlignTextRect();
if (fLabelAlign != label)
{
fLabelAlign = label;
Invalidate();
}
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void BTextControl::GetAlignment(alignment* label, alignment* text) const void BTextControl::GetAlignment(alignment *label, alignment *text) const
{ {
*label = fLabelAlign; *label = fLabelAlign;
*text = fText->Alignment(); *text = fText->Alignment();
@@ -194,30 +190,18 @@ void BTextControl::GetAlignment(alignment* label, alignment* text) const
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void BTextControl::SetDivider(float dividing_line) void BTextControl::SetDivider(float dividing_line)
{ {
float dx = fDivider - dividing_line;
fDivider = dividing_line; fDivider = dividing_line;
// here I need some code to resize and invalidate the textView
BRect frame = fText->Frame(); fText->MoveBy(-dx, 0.0f);
if (fDivider) fText->ResizeBy(dx, 0.0f);
{
frame.left = fDivider + 5.0f;
}
else
{
frame.left = 0.0f;
}
if (!frame.IsValid())
{
frame.left = frame.right - 6.0f;
}
fText->ResizeTo( frame.Width(), frame.Height()); if (Window())
// fText->FrameResized( frame.Width(), frame.Height()); {
fText->MoveTo( frame.left, frame.top); fText->Invalidate();
fText->Invalidate(); Invalidate();
}
Invalidate();
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
float BTextControl::Divider() const float BTextControl::Divider() const
@@ -225,26 +209,82 @@ float BTextControl::Divider() const
return fDivider; return fDivider;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void BTextControl::Draw(BRect rect) void BTextControl::Draw(BRect updateRect)
{ {
SetLowColor(ViewColor()); rgb_color no_tint = ui_color(B_PANEL_BACKGROUND_COLOR),
BFont font; lighten1 = tint_color(no_tint, B_LIGHTEN_1_TINT),
GetFont(&font); lighten2 = tint_color(no_tint, B_LIGHTEN_2_TINT),
font_height fh; lightenmax = tint_color(no_tint, B_LIGHTEN_MAX_TINT),
font.GetHeight(&fh); darken1 = tint_color(no_tint, B_DARKEN_1_TINT),
darken2 = tint_color(no_tint, B_DARKEN_2_TINT),
darken4 = tint_color(no_tint, B_DARKEN_4_TINT),
darkenmax = tint_color(no_tint, B_DARKEN_MAX_TINT),
nav = ui_color(B_KEYBOARD_NAVIGATION_COLOR);
BRect bounds(Bounds());
bool enabled = IsEnabled();
bool active = false;
if (fText->IsFocus() && Window()->IsActive())
active = true;
BRect rect(fText->Frame());
rect.InsetBy(-1.0f, -1.0f);
if (active)
{
SetHighColor(nav);
StrokeRect(rect);
}
else
{
if (enabled)
SetHighColor(darken4);
else
SetHighColor(darken2);
StrokeLine(rect.LeftTop(), rect.LeftBottom());
StrokeLine(rect.LeftTop(), rect.RightTop());
SetHighColor(no_tint);
StrokeLine(BPoint(rect.left + 1.0f, rect.bottom), rect.RightBottom());
StrokeLine(BPoint(rect.right, rect.top + 1.0f));
}
rect.InsetBy(-1.0f, -1.0f);
if (enabled)
SetHighColor(darken1);
else
SetHighColor(no_tint);
StrokeLine(rect.LeftBottom(), rect.LeftTop());
StrokeLine(rect.RightTop());
if (enabled)
SetHighColor(lighten2);
else
SetHighColor(lighten1);
StrokeLine(BPoint(rect.left + 1.0f, rect.bottom), rect.RightBottom());
StrokeLine(BPoint(rect.right, rect.top + 1.0f), rect.RightBottom());
if (Label()) if (Label())
{ {
float y = ceil(fh.ascent + fh.descent + fh.leading) + 2.0f; font_height fh;
GetFontHeight(&fh);
float y = (float)ceil(fh.ascent + fh.descent + fh.leading) + 2.0f;
float x; float x;
switch (fLabelAlign) switch (fLabelAlign)
{ {
case B_ALIGN_RIGHT: case B_ALIGN_RIGHT:
x = fDivider - font.StringWidth(Label()) - 3.0f; x = fDivider - StringWidth(Label()) - 3.0f;
break; break;
case B_ALIGN_CENTER: case B_ALIGN_CENTER:
x = fDivider - font.StringWidth(Label())/2.0f; x = fDivider - StringWidth(Label()) / 2.0f;
break; break;
default: default:
@@ -256,73 +296,111 @@ void BTextControl::Draw(BRect rect)
IsEnabled() ? B_DARKEN_MAX_TINT : B_DISABLED_LABEL_TINT)); IsEnabled() ? B_DARKEN_MAX_TINT : B_DISABLED_LABEL_TINT));
DrawString(Label(), BPoint(x, y)); DrawString(Label(), BPoint(x, y));
} }
rect = fText->Frame();
rgb_color base = ui_color(B_PANEL_BACKGROUND_COLOR);
rect.InsetBy(-1,-1);
SetHighColor(tint_color(base, IsEnabled() ?
B_DARKEN_1_TINT : B_DARKEN_2_TINT));
StrokeLine(BPoint(rect.left,rect.bottom), BPoint(rect.left, rect.top));
StrokeLine(BPoint(rect.left+1.0f,rect.top), BPoint(rect.right, rect.top));
SetHighColor(tint_color(base, IsEnabled() ?
B_LIGHTEN_MAX_TINT : B_LIGHTEN_2_TINT));
StrokeLine(BPoint(rect.left+1.0f,rect.bottom),
BPoint(rect.right, rect.bottom));
StrokeLine(BPoint(rect.right,rect.bottom),
BPoint(rect.right, rect.top+1.0f));
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void BTextControl::MouseDown(BPoint where) void BTextControl::MouseDown(BPoint where)
{ {
if (IsEnabled()) if (!fText->IsFocus())
{ {
MakeFocus(true); fText->MakeFocus(true);
fText->SelectAll();
} }
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void BTextControl::AttachedToWindow() void BTextControl::AttachedToWindow()
{ {
BControl::AttachedToWindow(); BControl::AttachedToWindow();
if (Parent())
{
SetViewColor(Parent()->ViewColor());
}
float w; bool enabled = IsEnabled();
float h; rgb_color textColor;
GetPreferredSize(&w, &h); rgb_color color = HighColor();
ResizeTo(Bounds().Width(), h); BFont font;
fText->ResizeTo(fText->Bounds().Width(), h);
fText->GetFontAndColor(0, &font, &color);
if (enabled)
textColor = color;
else
textColor = tint_color(color, B_LIGHTEN_2_TINT);
fText->SetFontAndColor(&font, B_FONT_ALL, &textColor);
if (enabled)
{
color.red = 255;
color.green = 255;
color.blue = 255;
}
else
color = tint_color(color, B_LIGHTEN_2_TINT);
fText->SetViewColor(color);
fText->SetLowColor(color);
fText->MakeEditable(enabled);
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void BTextControl::MakeFocus(bool state) void BTextControl::MakeFocus(bool state)
{ {
if (IsEnabled()) fText->MakeFocus(state);
{
fText->MakeFocus(state); if (state)
Invalidate(); fText->SelectAll();
}
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void BTextControl::SetEnabled(bool state) void BTextControl::SetEnabled(bool state)
{ {
fText->SetEnabled(state); if (IsEnabled() == state)
return;
if (Window())
{
fText->MakeEditable(state);
rgb_color textColor;
rgb_color color = {0, 0, 0, 255};
BFont font;
fText->GetFontAndColor(0, &font, &color);
if (state)
textColor = color;
else
textColor = tint_color(color, B_DISABLED_LABEL_TINT);
fText->SetFontAndColor(&font, B_FONT_ALL, &textColor);
if (state)
{
color.red = 255;
color.green = 255;
color.blue = 255;
}
else
color = tint_color(ui_color(B_PANEL_BACKGROUND_COLOR),
B_LIGHTEN_2_TINT);
fText->SetViewColor(color);
fText->SetLowColor(color);
fText->Invalidate();
Window()->UpdateIfNeeded();
}
BControl::SetEnabled(state); BControl::SetEnabled(state);
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void BTextControl::GetPreferredSize(float* width, float* height) void BTextControl::GetPreferredSize(float *width, float *height)
{ {
BFont font; BFont font;
GetFont(&font); GetFont(&font);
font_height fh; font_height fh;
font.GetHeight(&fh); font.GetHeight(&fh);
*height = ceil(fh.ascent + fh.descent + fh.leading) + 7.0f; *height = (float)ceil(fh.ascent + fh.descent + fh.leading) + 7.0f;
// TODO: this one I need to find out // TODO: this one I need to find out
*width = 4.0f + ceil(font.StringWidth(Label()))*2.0f; *width = 4.0f + (float)ceil(font.StringWidth(Label()))*2.0f;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void BTextControl::ResizeToPreferred() void BTextControl::ResizeToPreferred()
@@ -335,36 +413,62 @@ void BTextControl::ResizeToPreferred()
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void BTextControl::SetFlags(uint32 flags) void BTextControl::SetFlags(uint32 flags)
{ {
if (!fSkipSetFlags)
{
// If the textview is navigable, set it to not navigable if needed
// Else if it is not navigable, set it to navigable if needed
if (fText->Flags() & B_NAVIGABLE)
{
if (!(flags & B_NAVIGABLE))
fText->SetFlags(fText->Flags() & ~B_NAVIGABLE);
}
else
{
if (flags & B_NAVIGABLE)
fText->SetFlags(fText->Flags() | B_NAVIGABLE);
}
// Don't make this one navigable
flags &= ~B_NAVIGABLE;
}
BView::SetFlags(flags); BView::SetFlags(flags);
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void BTextControl::MessageReceived(BMessage* msg) void BTextControl::MessageReceived(BMessage *msg)
{ {
switch(msg->what) switch(msg->what)
{ {
case B_CONTROL_MODIFIED: case B_SET_PROPERTY:
if (fModificationMessage) case B_GET_PROPERTY:
{ // TODO
BControl::Invoke(fModificationMessage);
}
break; break;
default: default:
BControl::MessageReceived(msg); BControl::MessageReceived(msg);
break; break;
} }
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
BHandler* BTextControl::ResolveSpecifier(BMessage* msg, int32 index, BHandler *BTextControl::ResolveSpecifier(BMessage *msg, int32 index,
BMessage* specifier, int32 form, BMessage *specifier, int32 form,
const char* property) const char *property)
{ {
return NULL; /*
BPropertyInfo propInfo(prop_list);
BHandler *target = NULL;
if (propInfo.FindMatch(message, 0, specifier, what, property) < B_OK)
return BControl::ResolveSpecifier(message, index, specifier, what,
property);
else
return this;
*/
return BControl::ResolveSpecifier(msg, index, specifier, form, property);
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
status_t BTextControl::GetSupportedSuites(BMessage* data) status_t BTextControl::GetSupportedSuites(BMessage *data)
{ {
return B_OK; return BControl::GetSupportedSuites(data);
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void BTextControl::MouseUp(BPoint pt) void BTextControl::MouseUp(BPoint pt)
@@ -372,7 +476,7 @@ void BTextControl::MouseUp(BPoint pt)
BControl::MouseUp(pt); BControl::MouseUp(pt);
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void BTextControl::MouseMoved(BPoint pt, uint32 code, const BMessage* msg) void BTextControl::MouseMoved(BPoint pt, uint32 code, const BMessage *msg)
{ {
BControl::MouseMoved(pt, code, msg); BControl::MouseMoved(pt, code, msg);
} }
@@ -404,36 +508,87 @@ void BTextControl::FrameResized(float newWidth, float newHeight)
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void BTextControl::WindowActivated(bool active) void BTextControl::WindowActivated(bool active)
{ {
BControl::WindowActivated(active); if (fText->IsFocus())
Draw(Bounds());
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
status_t BTextControl::Perform(perform_code d, void* arg) status_t BTextControl::Perform(perform_code d, void *arg)
{ {
return BControl::Perform(d, arg); return BControl::Perform(d, arg);
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void BTextControl::_ReservedTextControl1() void BTextControl::_ReservedTextControl1() {}
{ void BTextControl::_ReservedTextControl2() {}
} void BTextControl::_ReservedTextControl3() {}
void BTextControl::_ReservedTextControl4() {}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void BTextControl::_ReservedTextControl2() BTextControl &BTextControl::operator=(const BTextControl&)
{ {
}
//------------------------------------------------------------------------------
void BTextControl::_ReservedTextControl3()
{
}
//------------------------------------------------------------------------------
void BTextControl::_ReservedTextControl4()
{
}
//------------------------------------------------------------------------------
BTextControl& BTextControl::operator=(const BTextControl&)
{
// Assignment not allowed
return *this; return *this;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void BTextControl::CommitValue()
{
}
//------------------------------------------------------------------------------
void BTextControl::InitData(const char *label, const char *initial_text,
BMessage *data)
{
BRect bounds(Bounds());
fText = NULL;
//fLabel = NULL;
fModificationMessage = NULL;
fLabelAlign = B_ALIGN_LEFT;
fDivider = 0.0f;
fPrevWidth = 0;
fPrevHeight = 0;
//fClean = true;
fSkipSetFlags = false;
int32 flags = 0;
BFont font(be_bold_font);
if (!data || !data->HasString("_fname"))
flags = 1;
if (!data || !data->HasFloat("_fflt"))
flags |= 2;
if (flags != 0)
SetFont(&font, flags);
if (label)
fDivider = bounds.Width() / 2.0f;
if (Flags() & B_NAVIGABLE)
{
fSkipSetFlags = true;
SetFlags(Flags() & ~B_NAVIGABLE);
fSkipSetFlags = false;
}
if (data)
fText = (_BTextInput_*)FindView("_input_");
else
{
BRect frame(fDivider, bounds.top + 2.0f, bounds.right - 2.0f,
bounds.bottom - 2.0f);
BRect textRect(frame.OffsetToCopy(0.0f, 0.0f));
fText = new _BTextInput_(frame, textRect,
B_FOLLOW_LEFT_RIGHT | B_FOLLOW_TOP, B_WILL_DRAW | B_FRAME_EVENTS |
B_NAVIGABLE);
AddChild(fText);
SetText(initial_text);
fText->SetAlignment(B_ALIGN_LEFT);
fText->AlignTextRect();
}
}
//------------------------------------------------------------------------------
/* /*
* $Log $ * $Log $
src/kits/interface/TextInput.cpp
+163 -163
View File
@@ -46,197 +46,197 @@
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
_BTextInput_::_BTextInput_(BTextControl* parent, BRect frame, const char* name, _BTextInput_::_BTextInput_(BRect frame, BRect textRect, uint32 resizeMask,
BRect rect, uint32 mask, uint32 flags) uint32 flags)
: BTextView(frame, name, rect, mask, flags), : BTextView(frame, "_input_", textRect, resizeMask, flags),
fEnabled(true), fPreviousText(NULL),
fChanged(false), fBool(false)
fParent(parent)
{ {
SetMaxBytes(255); MakeResizable(true);
SetWordWrap(false); }
//------------------------------------------------------------------------------
_BTextInput_::_BTextInput_(BMessage *archive)
: BTextView(archive),
fPreviousText(NULL),
fBool(false)
{
MakeResizable(true);
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
_BTextInput_::~_BTextInput_() _BTextInput_::~_BTextInput_()
{ {
if (fPreviousText)
free(fPreviousText);
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void _BTextInput_::SetEnabled(bool state) BArchivable *_BTextInput_::Instantiate(BMessage *archive)
{ {
fEnabled = state; if (validate_instantiation(archive, "_BTextInput_"))
if (fEnabled) return new _BTextInput_(archive);
{
BView::SetFlags(Flags() | B_NAVIGABLE);
}
else else
{ return NULL;
BView::SetFlags(Flags() & (0xffffffff - B_NAVIGABLE));
}
Invalidate();
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void _BTextInput_::AttachedToWindow() status_t _BTextInput_::Archive(BMessage *data, bool deep) const
{ {
BFont font; return BTextView::Archive(data, true);
GetFont(&font);
float h = font.Size() + 6.0f;
ResizeTo(Bounds().Width(), h);
fViewColor = BTextView::ViewColor();
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
rgb_color _BTextInput_::ViewColor() void _BTextInput_::FrameResized(float width, float height)
{ {
return fViewColor; BTextView::FrameResized(width, height);
} AlignTextRect();
//------------------------------------------------------------------------------
void _BTextInput_::SetViewColor(rgb_color color)
{
fViewColor = color;
}
//------------------------------------------------------------------------------
void _BTextInput_::MakeFocus(bool state)
{
BTextView::MakeFocus(state);
if (state)
{
BTextView::SetViewColor(255, 255, 255, 255);
fChanged = false;
SelectAll();
}
else
{
BTextView::SetViewColor(fViewColor);
}
Invalidate();
}
//------------------------------------------------------------------------------
bool _BTextInput_::CanEndLine(int32 end)
{
return false;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void _BTextInput_::KeyDown(const char* bytes, int32 numBytes) void _BTextInput_::KeyDown(const char* bytes, int32 numBytes)
{ {
bool send = false; switch (*bytes)
BMessage* msg = Window()->CurrentMessage();
if (numBytes == 1)
{ {
switch (bytes[0]) case B_ENTER:
{ {
case B_UP_ARROW: if (!TextControl()->IsEnabled())
msg->ReplaceInt64("when", (int64)system_time());
msg->ReplaceInt32("key", 38);
msg->ReplaceInt32("raw_char", B_TAB);
msg->ReplaceInt32("modifiers", B_SCROLL_LOCK | B_SHIFT_KEY);
msg->ReplaceInt8("byte", B_TAB);
msg->ReplaceString("bytes", "");
fParent->BView::MakeFocus(true);
Looper()->PostMessage(msg);
send = true;
break; break;
case B_ENTER: if(strcmp(Text(), fPreviousText) != 0)
{ {
SelectAll(); TextControl()->Invoke();
send = true; free(fPreviousText);
fChanged = true; fPreviousText = strdup(Text());
break; }
}
case B_DOWN_ARROW: SelectAll();
msg->ReplaceInt64("when", (int64)system_time()); break;
msg->ReplaceInt32("key", 38); }
msg->ReplaceInt32("raw_char", B_TAB);
msg->ReplaceInt8("byte", B_TAB);
msg->ReplaceString("bytes", "");
Looper()->PostMessage(msg);
send = true;
break;
case B_TAB: case B_TAB:
// This will make sure that it will skip to the next object BView::KeyDown(bytes, numBytes);
BView::KeyDown(bytes, numBytes); break;
send = true;
break;
default:
BTextView::KeyDown(bytes, numBytes);
}
}
else
{
BTextView::KeyDown(bytes, numBytes);
}
if (send)
{
if (fChanged)
{
Window()->PostMessage(new BMessage(B_CONTROL_INVOKED), fParent);
}
}
else
{
Window()->PostMessage(new BMessage(B_CONTROL_MODIFIED), fParent);
}
fChanged = true;
}
//------------------------------------------------------------------------------
void _BTextInput_::MouseDown(BPoint where)
{
if (fEnabled)
{
BTextView::MouseDown(where);
}
}
//------------------------------------------------------------------------------
void _BTextInput_::Draw(BRect rect)
{
BTextView::Draw(rect);
rect = Bounds(); default:
BTextView::KeyDown(bytes, numBytes);
rgb_color base = ui_color(B_PANEL_BACKGROUND_COLOR);
SetHighColor(tint_color(base, fEnabled ?
B_DARKEN_4_TINT : B_LIGHTEN_2_TINT));
StrokeLine(BPoint(rect.left,rect.bottom), BPoint(rect.left, rect.top));
StrokeLine(BPoint(rect.left+1.0f,rect.top), BPoint(rect.right, rect.top));
SetHighColor(tint_color(base, B_NO_TINT));
StrokeLine(BPoint(rect.left+1.0f,rect.bottom),
BPoint(rect.right, rect.bottom));
StrokeLine(BPoint(rect.right,rect.bottom),
BPoint(rect.right, rect.top+1.0f));
if (IsFocus())
{
SetHighColor(ui_color(B_KEYBOARD_NAVIGATION_COLOR));
StrokeRect(rect);
}
if (!fEnabled)
{
rect.InsetBy(1,1);
SetDrawingMode(B_OP_ALPHA);
rgb_color color = tint_color(ui_color(B_PANEL_BACKGROUND_COLOR),
B_LIGHTEN_1_TINT);
color.alpha = 140;
SetHighColor(color);
FillRect(rect);
SetDrawingMode(B_OP_COPY);
} }
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void _BTextInput_::MakeFocus(bool state)
{
if (state == IsFocus())
return;
/* BTextView::MakeFocus(state);
* $Log $
*
* $Id $
*
*/
if (state)
{
SetInitialText();
fBool = true;
if (Window())
{
BMessage *msg = Window()->CurrentMessage();
if (msg && msg->what == B_KEY_DOWN)
SelectAll();
}
}
else
{
if (strcmp(Text(), fPreviousText) != 0)
TextControl()->Invoke();
free(fPreviousText);
fPreviousText = NULL;
fBool = false;
if (Window())
{
BMessage *msg = Window()->CurrentMessage();
if (msg && msg->what == B_MOUSE_DOWN)
{
Select(0, 0);
}
}
}
if (Window())
{
Draw(Bounds());
Flush();
}
}
//------------------------------------------------------------------------------
void _BTextInput_::AlignTextRect()
{
// TODO
}
//------------------------------------------------------------------------------
void _BTextInput_::SetInitialText()
{
if (fPreviousText)
{
free(fPreviousText);
fPreviousText = NULL;
}
if (Text())
fPreviousText = strdup(Text());
}
//------------------------------------------------------------------------------
void _BTextInput_::Paste(BClipboard *clipboard)
{
BTextView::Paste(clipboard);
Invalidate();
}
//------------------------------------------------------------------------------
void _BTextInput_::InsertText(const char *inText, int32 inLength,
int32 inOffset, const text_run_array *inRuns)
{
char *buffer = NULL;
if (strpbrk(inText, "\r\n") && inLength <= 1024)
{
buffer = (char*)malloc(inLength);
if (buffer)
{
strcpy(buffer, inText);
for (int32 i = 0; i < inLength; i++)
if (buffer[i] == '\r' || buffer[i] == '\n')
buffer[i] = ' ';
}
}
BTextView::InsertText(buffer ? buffer : inText, inLength, inOffset,
inRuns);
TextControl()->InvokeNotify(TextControl()->ModificationMessage(),
B_CONTROL_MODIFIED);
if (buffer)
free(buffer);
}
//------------------------------------------------------------------------------
void _BTextInput_::DeleteText(int32 fromOffset, int32 toOffset)
{
BTextView::DeleteText(fromOffset, toOffset);
TextControl()->InvokeNotify(TextControl()->ModificationMessage(),
B_CONTROL_MODIFIED);
}
//------------------------------------------------------------------------------
BTextControl *_BTextInput_::TextControl()
{
BTextControl *textControl;
if (Parent())
textControl = dynamic_cast<BTextControl*>(Parent());
else
textControl = NULL;
if (!textControl)
debugger("_BTextInput_ should have a BTextControl as parent");
return textControl;
}
//------------------------------------------------------------------------------